## save a message 'm' to an open file pointer 'fp'
 def save m, fp
-  m.source.each_raw_full_message_line(m.source_info) { |l| fp.print l }
+  m.source.each_raw_message_line(m.source_info) { |l| fp.print l }
 end
 def die msg
   $stderr.puts "Error: #{msg}"
 
     ret
   end
 
-  def raw_full_message offset
+  def raw_message offset
     IO.readlines(fn_for_offset(offset)).join
   end
 
 
   end
 
   def load_message id
-    RMail::Parser.read raw_full_message(id)
+    RMail::Parser.read raw_message(id)
   end
 
   def raw_header id
   end
   synchronized :raw_header
 
-  def raw_full_message id
+  def raw_message id
     unsynchronized_scan_mailbox
     get_imap_fields(id, 'RFC822').first.gsub(/\r\n/, "\n")
   end
-  synchronized :raw_full_message
+  synchronized :raw_message
 
   def connect
     return if @imap
 
     ret
   end
 
-  def raw_full_message id
+  def raw_message id
     scan_mailbox
     with_file_for(id) { |f| f.readlines.join }
   end
 
     ret
   end
 
-  def raw_full_message offset
+  def raw_message offset
     ret = ""
-    each_raw_full_message_line(offset) { |l| ret += l }
+    each_raw_message_line(offset) { |l| ret += l }
     ret
   end
 
   ## apparently it's a million times faster to call this directly if
   ## we're just moving messages around on disk, than reading things
-  ## into memory with raw_full_message.
+  ## into memory with raw_message.
   ##
   ## i hoped never to have to move shit around on disk but
   ## sup-sync-back has to do it.
-  def each_raw_full_message_line offset
+  def each_raw_message_line offset
     @mutex.synchronize do
       @f.seek offset
       yield @f.gets
 
     end
   end
 
-  [:start_offset, :load_header, :load_message, :raw_header, :raw_full_message].each do |meth|
+  [:start_offset, :load_header, :load_message, :raw_header, :raw_message].each do |meth|
     define_method(meth) { |*a| safely { @loader.send meth, *a } }
   end
 end
 
     with_source_errors_handled { @source.raw_header @source_info }
   end
 
-  def raw_full_message
-    with_source_errors_handled { @source.raw_full_message @source_info }
+  def raw_message
+    with_source_errors_handled { @source.raw_message @source_info }
   end
 
-  ## much faster than raw_full_message
-  def each_raw_full_message_line &b
-    with_source_errors_handled { @source.each_raw_full_message_line(@source_info, &b) }
+  ## much faster than raw_message
+  def each_raw_message_line &b
+    with_source_errors_handled { @source.each_raw_message_line(@source_info, &b) }
   end
 
   def content
 
       fn = BufferManager.ask_for_filename :filename, "Save message to file: "
       return unless fn
       save_to_file(fn) do |f|
-        m.each_raw_full_message_line { |l| f.print l }
+        m.each_raw_message_line { |l| f.print l }
       end
     end
   end
 
   ## - load_header offset
   ## - load_message offset
   ## - raw_header offset
-  ## - raw_full_message offset
+  ## - raw_message offset
   ## - check
   ## - next (or each, if you prefer): should return a message and an
   ##   array of labels.