rubylabs 0.9.0 → 0.9.1

data/lib/marslab.rb

@@ -1,94 +1,151 @@
+module RubyLabs
 
 =begin rdoc
   
-== Core Wars Lab
+== MarsLab
 
-Ruby implementation of the MARS virtual machine used in Core Wars.
+The MARSLab module has definitions of classes and methods used in the projects for Chapter 8
+of <em>Explorations in Computing</em>.  
 
+The module has a Ruby implementation of the MARS 
+virtual machine used in the game of Core War.
 The machine implemented here conforms as close as possible to the ICWS'88 standard,
 as described by Mark Durham in his Introduction to Redcode (http://corewar.co.uk/guides.htm).  
 
-Currently there is no attempt to translate instructions into a numerical format.  MARS
-code is a set of Word objects.  Each Word has an opcode and two operands (A and B), all of 
-which are represented as strings.  Integer data is represented by a Word where the opcode
-field is DAT.  Other Word objects have executable machine instructions for opcodes.
+Instructions and data in a MARS program are represented by Word objects.  
+Each Word has an opcode and two operands (A and B).  Integer data is represented by a Word where the opcode
+field is DAT.  Other Word objects have names of executable machine instructions for opcodes.
 
-To test a single program students can make an instance of a class named MiniMARS, passing
+To test a single program users can make an instance of a class named MiniMARS, passing
 it the name of a test program.  The test machine will have a small memory, only big enough
 to hold the test machine, and special versions of the step, dump and other methods.
 
 The main machine that runs one, two, or three programs simultaneously is in the module
 named MARS.  Methods that assemble, load, and run programs are module methods, e.g.
 to assemble a program call MARS.assemble(foo).
-
+#--
+TODO add [] and []= methods to Word, use it to extract/assign bits or ranges of bits
+TODO define ranges for fields, e.g. @@opcode = 0..3; use to get opcode of Word, e.g. instr[@@opcode]
+TODO make sure all code uses [] interface (e.g. no more instr.amode[0] == ?#)
+TODO pack words into binary -- will kill several birds at once -- speed, trim values to 0..4095, ..
+TODO color a cell black when a thread halts after executing an instruction in that cell
+TODO MARS.dump
+TODO pass load address to contest (which passes it on to Warrior.load)?
+#++
 =end
+  
+module MARSLab
+  
+    # -- Initializations -- These are "global" vars in the outer MARSLab scope that are
+    # accessible to all the classes and modules defined inside MARSLab
+  
+  @@marsDirectory = File.join(File.dirname(__FILE__), '..', 'data', 'mars')
+
+  @@opcodes = ["DAT", "MOV", "ADD", "SUB", "JMP", "JMZ", "JMN", "DJN", "CMP", "SPL", "END", "SLT", "EQU"]
+  @@modes = "@<#"
 
-# TODO add [] and []= methods to Word, use it to extract/assign bits or ranges of bits
-# TODO define ranges for fields, e.g. @@opcode = 0..3; use to get opcode of Word, e.g. instr[@@opcode]
-# TODO make sure all code uses [] interface (e.g. no more instr.amode[0] == ?#)
-# TODO pack words into binary -- will kill several birds at once -- speed, trim values to 0..4095, ..
-# TODO color a cell black when a thread halts after executing an instruction in that cell
-# TODO MARS.dump
-# TODO pass load address to contest (which passes it on to Warrior.load)?
+  @@maxEntries = 3
+  @@displayMemSize = 4096
 
-module RubyLabs
-	
-module MARSLab
+  @@params = {
+    :maxRounds => 1000,
+    :memSize => @@displayMemSize,
+    :buffer => 100,
+    :tracing => false,
+    :pause => 0.01,
+  }
   
   MARSView = Struct.new(:cells, :palettes, :options)
 
+  @@viewOptions = {
+    :cellSize => 8,
+    :cellRows => 32,
+    :cellCols => 128,
+    :padding => 20,
+    :traceSize => 10,
+    :cellColor => '#DDDDDD',
+  }
+
+  @@drawing = nil
+  
+=begin rdoc
+  A MARSRuntimeException is raised when MARS tries to execute an illegal instruction,
+  e.g. when a program contains an instruction with the wrong type of addressing mode for
+  its opcode.
+=end
+
   class MARSRuntimeException < StandardError
   end
+  
+=begin rdoc
+  A RedcodeSyntaxError is raised when a source program contains an instruction that cannot
+  be translated into MARS machine language, e.g. it has an unknown opcode or a missing operand.
+=end
 
   class RedcodeSyntaxError < StandardError
   end
 
-	# An object of the Word class represents a single item from memory, either a machine 
-	# instruction or a piece of data.  Attributes are the opcode, the A operand mode, and 
-	# the B operand (all strings).  Instruction execution proceeds according to the description 
-	# in Durham's spec.
-
-	class	Word
-		
-		attr_reader :op, :lineno
-		attr_accessor :a, :b
-				
-		def initialize(*args)
-			@op, @a, @b, @lineno = args
-		end
-		
-		def inspect
-		  sprintf "%s %s %s", @op, @a, @b
-		end
-		
-		alias to_s inspect
-		
-		# two Words are the same if the strings representing the opcode and
-		# both operands are the same
-		
-		def ==(other)
-		  return (op == other.op && a == other.a && b == other.b)
-	  end
-		
-		def clone
-		  Word.new(@op.clone, @a.clone, @b.clone, @lineno)
-		end
-		
+=begin rdoc
+
+== Word
+
+An object of the Word class represents a single item from memory, either a machine 
+instruction or a piece of data.  Attributes are the opcode, the A operand mode, and 
+the B operand (all strings).  Instruction execution proceeds according to the description 
+in Durham's spec.
+
+=end
+
+  class Word
+    
+    attr_reader :op, :lineno
+    attr_accessor :a, :b
+    
+    # Create a new Word from +op+, +a+, +b+, and +n+.
+    # :call-seq:
+    #   Word.new(op, a, b, n) => Word
+    #
+        
+    def initialize(*args)
+      @op, @a, @b, @lineno = args
+    end
+    
+    # Return a string representation of this word.
+    
+    def inspect
+      sprintf "%s %s %s", @op, @a, @b
+    end
+    
+    alias to_s inspect
+    
+    # Two Words are the same if the strings representing the opcode and
+    # both operands are the same.
+    
+    def ==(other)
+      return (op == other.op && a == other.a && b == other.b)
+    end
+    
+    # Make a new Word object with all the same attributes as this object.
+    
+    def clone
+      Word.new(@op.clone, @a.clone, @b.clone, @lineno)
+    end
+    
     # Convert a field specification into an integer value, stripping off a leading
     # addressing mode character if it's there
     
     def field_value(field)
       return @@modes.include?(field[0]) ? field[1..-1].to_i : field.to_i
     end
-		
-		# Return the address of an operand; note that for immediate operands the 
-		# address is the address of the current instruction.
-		
-		def dereference(field, pc, mem)
-		  case field[0]
-		  when ?#
-		    return pc.current[:addr]
-	    when ?@
+    
+    # Return the address of an operand; note that for immediate operands the 
+    # address is the address of the current instruction.
+    
+    def dereference(field, pc, mem)
+      case field[0]
+      when ?#
+        return pc.current[:addr]
+      when ?@
         ptrloc = (field_value(field) + pc.current[:addr]) % mem.size
         ptr = mem.fetch(ptrloc)
         return (field_value(ptr.b) + ptrloc) % mem.size
@@ -99,36 +156,40 @@ module MARSLab
         mem.store_field(ptrloc, (newb % mem.size), :b)
         return (newb + ptrloc) % mem.size
       else
-		    return (field_value(field) + pc.current[:addr]) % mem.size
-		  end
-		end
-		
-		# Execute an instruction.  The first parameter is the program counter used
-		# to fetch the instruction, the second is the machine's memory array.  
-		
-		def execute(pc, mem)
-	    self.send(@op, pc, mem)
-	    return (@op == "DAT") ? (:halt) : (:continue) 
-		end
-		
-		private
-		
-		# The DAT instruction is effectively a "halt", but we still need to dereference
-		# both its operands to generate the side effects in auto-decrement modes.
-		
-		def DAT(pc, mem)
+        return (field_value(field) + pc.current[:addr]) % mem.size
+      end
+    end
+    
+    # Execute the instruction represented by this word.  The first parameter is the program counter used
+    # to fetch the instruction, the second is the machine's memory array.  
+    #
+    # The semantics for each type of instruction are defined by private methods that have the same
+    # name as the opcode, e.g. then the opcode is "ADD" execute calls +ADD+, sending it the +pc+ and
+    # +mem+ arguments so the instruction can dereference its arguments and carry out the specified operation.
+    
+    def execute(pc, mem)
+      self.send(@op, pc, mem)
+      return (@op == "DAT") ? (:halt) : (:continue) 
+    end
+    
+    private
+    
+    # The DAT instruction is effectively a "halt", but we still need to dereference
+    # both its operands to generate the side effects in auto-decrement modes.
+    
+    def DAT(pc, mem)    # :doc:
       dereference(@a, pc, mem)
       dereference(@b, pc, mem)
-		end
-		
-		# Durham isn't clear on how to handle immediate moves -- does the immediate value
-		# go in the A or B field of the destination?  Guess:  B, in case the destination
-		# is a DAT.
-				
-		def MOV(pc, mem)
-		  raise MARSRuntimeException, "MOV: immediate B-field not allowed" if @b[0] == ?#
-		  src = dereference(@a, pc, mem)
-		  val = mem.fetch(src)
+    end
+    
+    # Durham isn't clear on how to handle immediate moves -- does the immediate value
+    # go in the A or B field of the destination?  Guess:  B, in case the destination
+    # is a DAT.
+        
+    def MOV(pc, mem)    # :doc:
+      raise MARSRuntimeException, "MOV: immediate B-field not allowed" if @b[0] == ?#
+      src = dereference(@a, pc, mem)
+      val = mem.fetch(src)
       dest = dereference(@b, pc, mem)
       if @a[0] == ?#
         mem.store_field(dest, field_value(val.a), :b)
@@ -137,15 +198,15 @@ module MARSLab
       end
       pc.log(src)
       pc.log(dest)
-		end
-		
-		# Ambiguity on how to handle immediate A values:  add operand to the A or B
-		# field of the destination?  Guess:  B (for same reasons given for MOV)
+    end
+    
+    # Ambiguity on how to handle immediate A values:  add operand to the A or B
+    # field of the destination?  Guess:  B (for same reasons given for MOV)
 
-		def ADD(pc, mem)
-		  raise MARSRuntimeException, "ADD: immediate B-field not allowed" if @b[0] == ?#
+    def ADD(pc, mem)    # :doc:
+      raise MARSRuntimeException, "ADD: immediate B-field not allowed" if @b[0] == ?#
       src = dereference(@a, pc, mem)
-		  left_operand = mem.fetch(src)
+      left_operand = mem.fetch(src)
       dest = dereference(@b, pc, mem)
       right_operand = mem.fetch(dest)
       if @a[0] == ?#
@@ -156,14 +217,14 @@ module MARSLab
       end
       pc.log(src)
       pc.log(dest)
-		end
-		
-		# See note for ADD, re immediate A operand.
-		
-		def SUB(pc, mem)
-		  raise MARSRuntimeException, "SUB: immediate B-field not allowed" if @b[0] == ?#
+    end
+    
+    # See note for ADD, re immediate A operand.
+    
+    def SUB(pc, mem)    # :doc:
+      raise MARSRuntimeException, "SUB: immediate B-field not allowed" if @b[0] == ?#
       src = dereference(@a, pc, mem)
-		  right_operand = mem.fetch(src)
+      right_operand = mem.fetch(src)
       dest = dereference(@b, pc, mem)
       left_operand = mem.fetch(dest)
       if @a[0] == ?#
@@ -174,56 +235,56 @@ module MARSLab
       end
       pc.log(src)
       pc.log(dest)
-		end
-		
-		# Durham doesn't mention this explicitly, but since a B operand is allowed it implies
-		# we have to dereference it in case it has a side effect.
-				
-		def JMP(pc, mem)
-		  raise MARSRuntimeException, "JMP: immediate A-field not allowed" if @a[0] == ?#
-		  target = dereference(@a, pc, mem) % mem.size
+    end
+    
+    # Durham doesn't mention this explicitly, but since a B operand is allowed it implies
+    # we have to dereference it in case it has a side effect.
+        
+    def JMP(pc, mem)    # :doc:
+      raise MARSRuntimeException, "JMP: immediate A-field not allowed" if @a[0] == ?#
+      target = dereference(@a, pc, mem) % mem.size
       dereference(@b, pc, mem)
-		  pc.branch(target)
-		end
-		
-		# Branch to address specified by A if the B-field of the B operand is zero.
-		
-		def JMZ(pc, mem)
-		  raise MARSRuntimeException, "JMZ: immediate A-field not allowed" if @a[0] == ?#
-		  target = dereference(@a, pc, mem) % mem.size
+      pc.branch(target)
+    end
+    
+    # Branch to address specified by A if the B-field of the B operand is zero.
+    
+    def JMZ(pc, mem)    # :doc:
+      raise MARSRuntimeException, "JMZ: immediate A-field not allowed" if @a[0] == ?#
+      target = dereference(@a, pc, mem) % mem.size
       operand = mem.fetch(dereference(@b, pc, mem))
       if field_value(operand.b) == 0
-		    pc.branch(target)
-	    end
-		end
-		
-		# As in JMZ, but branch if operand is non-zero
-		
-		def JMN(pc, mem)
-		  raise MARSRuntimeException, "JMN: immediate A-field not allowed" if @a[0] == ?#
-		  target = dereference(@a, pc, mem) % mem.size
+        pc.branch(target)
+      end
+    end
+    
+    # As in JMZ, but branch if operand is non-zero
+    
+    def JMN(pc, mem)    # :doc:
+      raise MARSRuntimeException, "JMN: immediate A-field not allowed" if @a[0] == ?#
+      target = dereference(@a, pc, mem) % mem.size
       operand = mem.fetch(dereference(@b, pc, mem))
       if field_value(operand.b) != 0
-		    pc.branch(target)
-	    end
-		end
-		
-		# DJN combines the auto-decrement mode dereference logic with a branch -- take
-		# the branch if the new value of the B field of the pointer is non-zero.
-		
-		def DJN(pc, mem)
-		  raise MARSRuntimeException, "DJN: immediate A-field not allowed" if @a[0] == ?#
-		  target = dereference(@a, pc, mem)
+        pc.branch(target)
+      end
+    end
+    
+    # DJN combines the auto-decrement mode dereference logic with a branch -- take
+    # the branch if the new value of the B field of the pointer is non-zero.
+    
+    def DJN(pc, mem)    # :doc:
+      raise MARSRuntimeException, "DJN: immediate A-field not allowed" if @a[0] == ?#
+      target = dereference(@a, pc, mem)
       operand_addr = dereference(@b, pc, mem)
       operand = mem.fetch(operand_addr)
       newb = field_value(operand.b) - 1
       mem.store_field(operand_addr, (newb % mem.size), :b)
       if newb != 0
-		    pc.branch(target)
-	    end
+        pc.branch(target)
+      end
       pc.log(operand_addr)
-		end
-		
+    end
+    
     # Durham just says "compare two fields" if the operand is immediate.  Since
     # B can't be immediate, we just need to look at the A operand and, presumably,
     # compare it to the A operand of the dereferenced operand fetched by the B field.
@@ -231,67 +292,73 @@ module MARSLab
     # The call to pc.next increments the program counter for this thread, which causes 
     # the skip.
 
-		def CMP(pc, mem)
-		  raise MARSRuntimeException, "CMP: immediate B-field not allowed" if @b[0] == ?#
+    def CMP(pc, mem)    # :doc:
+      raise MARSRuntimeException, "CMP: immediate B-field not allowed" if @b[0] == ?#
       right = mem.fetch(dereference(@b, pc, mem))
-		  if @a[0] == ?#
-		    left = field_value(@a)
-		    right = field_value(right.a)
-	    else
-  		  left = mem.fetch(dereference(@a, pc, mem))
+      if @a[0] == ?#
+        left = field_value(@a)
+        right = field_value(right.a)
+      else
+        left = mem.fetch(dereference(@a, pc, mem))
       end
       if left == right
-		    pc.next
-	    end
-		end
-		
-		# Major ambiguity here -- what does it mean for a word A to be "less than"
-		# word B?  First assumption, don't compare opcodes.  Second, we're just going
-		# to implement one-field comparisons of B fields.  Otherwise for full-word operands
-		# we'd need to do a lexicographic compare of A and B fields of both operands, skipping
-		# modes and just comparing values.
-		
-		def SLT(pc, mem)
-		  raise MARSRuntimeException, "SLT: immediate B-field not allowed" if @b[0] == ?#
-		  if @a[0] == ?#
-		    left = field_value(@a)
-	    else
-  		  left = field_value(mem.fetch(dereference(@a, pc, mem)).b)
-		  end
+        pc.next
+      end
+    end
+    
+    # More ambiguity here -- what does it mean for a word A to be "less than"
+    # word B?  First assumption, don't compare opcodes.  Second, we're just going
+    # to implement one-field comparisons of B fields.  Otherwise for full-word operands
+    # we'd need to do a lexicographic compare of A and B fields of both operands, skipping
+    # modes and just comparing values.
+    
+    def SLT(pc, mem)    # :doc:
+      raise MARSRuntimeException, "SLT: immediate B-field not allowed" if @b[0] == ?#
+      if @a[0] == ?#
+        left = field_value(@a)
+      else
+        left = field_value(mem.fetch(dereference(@a, pc, mem)).b)
+      end
       right = field_value(mem.fetch(dereference(@b, pc, mem)).b)
-		  if left < right 
-		    pc.next
-	    end
-		end
-		
-		# Fork a new thread at the address specified by A.  The new thread goes at the end
-		# of the queue.  Immediate operands are not allowed.  Durham doesn't mention it, but
-		# implies only A is dereferenced, so ignore B.
-		
-		def SPL(pc, mem)
-		  raise MARSRuntimeException, "SPL: immediate A-field not allowed" if @a[0] == ?#
-		  target = dereference(@a, pc, mem)
-		  pc.add_thread(target)
-		end
-				
-	end # class Word
-	
-	
-=begin rdoc
-  A Warrior is a core warrior -- an object of this class is a simple struct that
-  has the program name, assembled code, the starting location, and the symbol table.
+      if left < right 
+        pc.next
+      end
+    end
+    
+    # Fork a new thread at the address specified by A.  The new thread goes at the end
+    # of the queue.  Immediate operands are not allowed.  Durham doesn't mention it, but
+    # implies only A is dereferenced, so ignore B.
+    
+    def SPL(pc, mem)    # :doc:
+      raise MARSRuntimeException, "SPL: immediate A-field not allowed" if @a[0] == ?#
+      target = dereference(@a, pc, mem)
+      pc.add_thread(target)
+    end
+        
+  end # class Word
   
-  A static method (Warrior.load) will load an assembled Warrior into memory, making
-  sure the max number of programs is not exceeded.  The addr attribute is set to the
-  starting location of the program when it is loaded.
+  
+=begin rdoc
+
+== Warrior
+
+A Warrior is a core warrior -- an object of this class is a simple struct that
+has the program name, assembled code, the starting location, and the symbol table.
+
+A static method (Warrior.load) will load an assembled Warrior into memory, making
+sure the max number of programs is not exceeded.  The addr attribute is set to the
+starting location of the program when it is loaded.
 =end
 
   class Warrior
     attr_reader :name, :code, :symbols, :errors
-			
-  	def initialize(filename)
-  	  if filename.class == Symbol
-  	    filename = File.join(@@marsDirectory, filename.to_s + ".txt")
+
+    # Create a new Warrior by reading and assembling the instructions in +filename+.
+    # The +code+ array is empty if there are any assembly errors.
+
+    def initialize(filename)
+      if filename.class == Symbol
+        filename = File.join(@@marsDirectory, filename.to_s + ".txt")
       end
 
       if ! File.exists?(filename)
@@ -300,20 +367,27 @@ module MARSLab
 
       @name, @code, @symbols, @errors = MARS.assemble( File.open(filename).readlines )
 
-  		if @errors.length > 0
-  		  puts "Syntax errors in #{filename}:"
-  	    puts errors
-  	    @code.clear
-  	  end
+      if @errors.length > 0
+        puts "Syntax errors in #{filename}:"
+        puts errors
+        @code.clear
+      end
     end
+    
+    # Create a string with essential information about this object.
 
-  	def inspect
-  	  sprintf "Name: #{@name} Code: #{@code.inspect}"
-  	end
-  	
-  	alias to_s inspect
-  	
-   def Warrior.load(app, addr = :random)
+    def inspect
+      sprintf "Name: #{@name} Code: #{@code.inspect}"
+    end
+    
+    alias to_s inspect
+    
+    # Load the code for the Warrior object reference by +app+ into the MARS main memory.
+    # If an address is specified, load that code starting at that location, otherwise
+    # choose a random location.  The memory addresses used by the program are recorded
+    # so programs aren't accidentally loaded on top of each other.
+    
+    def Warrior.load(app, addr = :random)
       if app.class != Warrior
         puts "Argument must be a Warrior object, not a #{app.class}"
         return nil
@@ -365,6 +439,9 @@ module MARSLab
     
     @@in_use = Array.new
     
+    # Clear the data structure that records which memory locations are in use, allowing
+    # new programs to be loaded into any location.
+    
     def Warrior.reset
       @@in_use = Array.new
     end
@@ -374,30 +451,24 @@ module MARSLab
     # Return true if a program loaded between lb and ub would not overlap another
     # program already loaded (including a buffer surrounding loaded programs).
 
-    def Warrior.check_loc(lb, ub)
+    def Warrior.check_loc(lb, ub)   # :doc:
       @@in_use.each do |range|
         return false if range.include?(lb) || range.include?(ub)
       end
       return true
     end
-	  
+    
   end # class Warrior
   
   
 =begin rdoc
-  The PC class is used to represent the set of program counters for a running program.
-  It has an array of locations to hold the next instruction from each thread, plus the
-  index of the thread to use on the next instruction fetch cycle.
-  
-  Call next to get the address of the next instruction to execute; as a side effect this
-  call bumps the thread pointer to the next thread in the program.  Call add_thread(n)
-  to start a new thread running at location n.  Call kill_thread to remove the thread
-  that was used in the most recent call to next (i.e. when that program dies).
-  
-  To help visualize the operation of a program the class keeps a history of memory
-  references made by each thread.  A call to next automatically records the program counter
-  value, but a semantic routine can also call log(x) to append location x to a history.
-  Call history to get the history vectors for all threads. 
+
+== PC
+
+The PC (program counter) class is used to keep track of the next instruction to execute when a program is running.
+A PC object has an array of locations to hold the next instruction from each thread, plus the
+index of the thread to use on the next instruction fetch cycle.
+
 =end
 
   class PC
@@ -405,6 +476,10 @@ module MARSLab
     
     @@hmax = 10       # see also @@threadMax in Draw -- allowed to be a different value
 
+    # Create a new program counter.  The +id+ argument is a tag that can be used to 
+    # identify which program is running at this location.  The PC is intialized with
+    # one thread starting at location +addr+.
+    
     def initialize(id, addr)
       @id = id
       @addrs = [addr]
@@ -414,6 +489,9 @@ module MARSLab
       @first = addr
     end
     
+    # Restore this program counter to its original state, a single thread starting
+    # at the location passed when the object was created.
+    
     def reset
       @addrs = [@first]
       @history.clear
@@ -421,6 +499,9 @@ module MARSLab
       @current = {:thread => nil, :addr => nil}
       return @first
     end
+    
+    # Create a string showing the name of the program and the current instruction
+    # for each thread.
   
     def inspect
       s = "[ "
@@ -434,6 +515,8 @@ module MARSLab
     
     alias to_s inspect
     
+    # Add a new thread, which will begin execution at location +addr+.
+    #--
     # Not sure if this is right -- new thread appended to list, as per Durham, but
     # the execution stays with the current thread (thread switch happens in 'next' method)
 
@@ -442,6 +525,9 @@ module MARSLab
       @history << Array.new
       self
     end
+    
+    # Return the address of the next instruction to execute for this program.
+    # If more than one thread is active, make the next thread the current thread.
         
     def next
       return nil if @addrs.empty?
@@ -454,9 +540,15 @@ module MARSLab
       return addr
     end
     
+    # Implement a branch instruction by setting the next instruction address for the
+    # current thread to +loc+.
+    
     def branch(loc)
       @addrs[@current[:thread]] = loc
     end
+    
+    # Remove the current thread from the list of active threads.  The return value
+    # is the number of remaining threads.
   
     def kill_thread
       return 0 if @addrs.empty?
@@ -466,16 +558,18 @@ module MARSLab
       return @addrs.length
     end
 
-=begin rdoc
-  record the location of a memory operation in the history vector for the current thread
-=end
+    # Record the location of a memory operation in the history vector for the current thread.
+    # The history vector is used by the methods that display the progress of a program on
+    # the RubyLabs canvas.
 
     def log(loc)
-    	a = @history[@current[:thread]]
-    	a << loc
-    	a.shift if a.length > @@hmax	
+      a = @history[@current[:thread]]
+      a << loc
+      a.shift if a.length > @@hmax  
     end
     
+    # Return a reference to the set of history vectors for this Warrior object.
+    
     def history
       return @history
     end
@@ -483,25 +577,35 @@ module MARSLab
   end # class PC
   
 =begin rdoc
-  An object of the Memory class is a 1-D array of the specified size.  Methods namde
-  store and fetch operate on full words, while store_field and fetch_field operate on partial words.
+
+== Memory
+
+An object of the Memory class is a 1-D array of the specified size.  Items in a Memory
+are Word objects.
+
+According to the Core War standard, memory should be initialized with DAT #0 instructions
+before each contest.  For efficiency, newly (re)initialized Memory objects have +nil+
+at each location, but +nil+ is treated the same as DAT #0.
+  
 =end
-	
-	class Memory
-				
+  
+  class Memory
+        
     attr_reader :array
 
-		def initialize(size)
-			@array = Array.new(size)
-		end
-		
-		def to_s
-		  sprintf "Memory [0..#{@array.size-1}]"
-		end
-				
-=begin rdoc
-  dump(loc,n) -- print the n words in memory starting at loc
-=end
+    # Create a new Memory of the specified size.
+    
+    def initialize(size)
+      @array = Array.new(size)
+    end
+    
+    # Create a string describing this Memory object.
+    
+    def to_s
+      sprintf "Memory [0..#{@array.size-1}]"
+    end
+        
+    # Print the +n+ words in memory starting at +loc+.
 
     def dump(loc, n)
       (loc...(loc+n)).each do |x|
@@ -510,51 +614,61 @@ module MARSLab
       end
     end
 
-		def size
-		  return @array.size
-	  end
-				
-		# Methods for fetching and storing data in memory.  According to the standard,
-		# memory is initialized with DAT #0 instructions, but our array has nils; the
-		# fetch method returns a DAT #0 from an uninitialized location.  
-		
-		def fetch(loc)
-			return ( @array[loc] || Word.new("DAT", "#0", "#0", nil) )
-		end
-		
-		def store(loc, val)
-			@array[loc] = val.clone
-		end
-		
-		# fetch and store operations that work on partial words
-		
-		def fetch_field(loc, field)
-		  instr = self.fetch(loc)
-			return field == :a ? instr.a : instr.b
-		end
-		
-		def store_field(loc, val, field)
-		  instr = self.fetch(loc)
-		  part = (field == :a) ? instr.a : instr.b
-		  mode = @@modes.include?(part[0]) ? part[0].chr : ""
-		  part.replace(mode + val.to_s)
-	    self.store(loc, instr)
-		end
-								
-	end # class Memory
-	
+    # Return the size (number of words that can be stored) of this Memory object.
+     
+    def size
+      return @array.size
+    end
+        
+    # Return the Word object stored in location +loc+ in this Memory object. 
+    
+    def fetch(loc)
+      return ( @array[loc] || Word.new("DAT", "#0", "#0", nil) )
+    end
+    
+    # Store object +val+ in location +loc+.
+    
+    def store(loc, val)
+      @array[loc] = val.clone
+    end
+    
+    # Same as +fetch+, but return only the designated field of the Word stored at location +loc+.
+    
+    def fetch_field(loc, field)
+      instr = self.fetch(loc)
+      return field == :a ? instr.a : instr.b
+    end
+    
+    # Same as +store+, but overwrite only the designated field of the Word in location +loc+.
+    
+    def store_field(loc, val, field)
+      instr = self.fetch(loc)
+      part = (field == :a) ? instr.a : instr.b
+      mode = @@modes.include?(part[0]) ? part[0].chr : ""
+      part.replace(mode + val.to_s)
+      self.store(loc, instr)
+    end
+                
+  end # class Memory
+  
 =begin rdoc
-  A miniature machine (MiniMARS) object is used to test a program.  Pass the name of
-  a Recode program to the constructor and get back a VM that has a memory where this
-  program has been loaded into location 0.  Pass an extra parameter to define the size
-  of the memory (otherwise the memory is just big enough to hold the program).  Call the
-  step method to execute a single instruction, or run to run the program until it hits
-  a DAT instruction or executes max instructions.
+
+== MiniMARS
+
+A miniature machine (MiniMARS) object is used to test a Redcode program.  It is essentially
+a MARS VM connected to a "thumb drive" that contains the assembled code for a single program.
+By single-stepping through the program users can learn how the code works or debug a 
+program they are developing.
+
 =end
 
-	class MiniMARS
-	  attr_reader :mem, :pc, :state
-	  
+  class MiniMARS
+    attr_reader :mem, :pc, :state
+    
+    # Create a VM that has a memory with the assembled form of the Redcode program in +file+.
+    # has been loaded into location 0.  The optional second argument defines the size
+    # of the memory (otherwise the memory is just big enough to hold the program).  
+
     def initialize(file, size = nil)
       w = Warrior.new(file)
       @mem = size ? Memory.new(size) : Memory.new(w.code.length)
@@ -566,27 +680,41 @@ module MARSLab
       @pc = PC.new(w.name, w.symbols[:start])
       @state = :ready
     end
-	 
+   
+    # Create a string with a short description of this VM.
+    
     def inspect
       return "#<MiniMARS mem = #{@mem.array.inspect} pc = #{@pc}>"
     end
     
     alias to_s inspect
     
+    # Print a string that describes the program status (running or halted, current
+    # instruction address, ...)
+    
     def status
       s = "Run: #{@state}"
       s += " PC: #{@pc}" unless @state == :halt
       puts s
     end
 
-	  def step
-	    return "machine halted" if @state == :halt
-	    instr = @mem.fetch(@pc.next)
-	    @state = instr.execute(@pc, @mem)
-	    return instr
-	  end
-	  
-	  def run(nsteps = 1000)
+    # Execute the next instruction in the program loaded into this VM.  The
+    # return value is the Word object for the instruction just executed.
+    
+    def step
+      return "machine halted" if @state == :halt
+      instr = @mem.fetch(@pc.next)
+      @state = instr.execute(@pc, @mem)
+      return instr
+    end
+    
+    # Execute instructions in the program loaded into this VM until it hits
+    # a HALT (DAT) instruction.  The return value is the number of instructions
+    # executed. The optional argument is a maximum number of steps
+    # to execute; afer executing this number of instructions the method will
+    # return, whether or not the program halts.
+
+    def run(nsteps = 1000)
       count = 0
       loop do
         break if @state == :halt || nsteps <= 0
@@ -595,43 +723,56 @@ module MARSLab
         count += 1
       end
       return count 
-	  end
-	  
-	  def reset
-	    @pc.reset
-	    puts "warning: memory may not be in initial state"
-	  end
-	  
-	  def dump(*args)
-	    if args.empty?
-	      @mem.dump(0, @mem.array.length)
+    end
+    
+    # Reset the program counter to 0, so the program starts over.  But the 
+    # contents of memory are not restored, they are left as they were after the
+    # last instruction executed.
+    
+    def reset
+      @pc.reset
+      puts "warning: memory may not be in initial state"
+    end
+    
+    # Print the contents of the VM memory.  If two arguments are passed they
+    # are used as the addresses of the first and last words to print.
+    
+    def dump(*args)
+      if args.empty?
+        @mem.dump(0, @mem.array.length)
       else
         x = args[0]
         y = args[1] || x
         @mem.dump(x, y-x+1)
       end
       return nil
-	  end
-	 
-	end # MiniMARS
-	  
+    end
+   
+  end # MiniMARS
+    
   
 =begin rdoc
-  The MARS module is a package that has the methods used to assemble, load, and execute
-  up to three programs at a time.
+
+== MARS
+
+The MARS class defines a singleton object that has the methods used to assemble, load, and execute
+up to three Redcode programs at a time.
+
 =end
 
   class MARS
   
-  #  -------- Assembler ----------
+    #  -------- Assembler ----------
   
-  # line format:
-  #     <label>   <opcode> <A-mode><A-field>, <B-mode><B-field>   <comment>
+    # line format:
+    #     <label>   <opcode> <A-mode><A-field>, <B-mode><B-field>   <comment>
   
-  # Parsing methods strip off and return the item they are looking for, or raise
-  # an error if the line doesn't start with a well-formed item
+    # Parsing methods strip off and return the item they are looking for, or raise
+    # an error if the line doesn't start with a well-formed item
+  
+    # Labels start in column 0, can be any length
 
-    def MARS.parseLabel(s)             # labels start in column 0, can be any length
+    def MARS.parseLabel(s)        # :nodoc:
       return nil if s =~ /^\s/
       x = s[/^\w+/]               # set x to the label
       if x.nil?                   # x is nil if label didn't start with a word char
@@ -644,8 +785,10 @@ module MARSLab
       return x                    # return it
     end
   
-    def MARS.parseOpCode(s)
-      if s !~ /^\s/               # expect opcode to be separated from label (or start of line) by white space
+    # Expect opcodes to be separated from labels (or start of line) by white space
+  
+    def MARS.parseOpCode(s)       # :nodoc:
+      if s !~ /^\s/               
         raise RedcodeSyntaxError, "illegal label in '#{s}'"
       end
       s.lstrip!
@@ -657,7 +800,7 @@ module MARSLab
       return x.upcase             # return it
     end
   
-    def MARS.parseOperand(s)
+    def MARS.parseOperand(s)      # :nodoc:
       s.lstrip!
       return s if s.length == 0
       x = s[/^[#{@@modes}]?[+-]?\w+/]
@@ -668,7 +811,7 @@ module MARSLab
       return x.upcase
     end
   
-    def MARS.parseSeparator(s)
+    def MARS.parseSeparator(s)    # :nodoc:
       s.lstrip!
       return if s.length == 0
       if s[0] == ?,
@@ -677,17 +820,21 @@ module MARSLab
         raise RedcodeSyntaxError, "operands must be separated by a comma"
       end
     end
+    
+    # Helper method called by the assembler to break an input line into its constituent
+    # parts.  Calls its own helpers named +parseLabel+, +parseOpCode+, and +parseOperand+;
+    # see marslab.rb for more information.
   
     def MARS.parse(s)
-  	  label = MARS.parseLabel(s)
-  	  op = MARS.parseOpCode(s)
-  	  a = MARS.parseOperand(s)
-  	  MARS.parseSeparator(s)
-  	  b = MARS.parseOperand(s)
+      label = MARS.parseLabel(s)
+      op = MARS.parseOpCode(s)
+      a = MARS.parseOperand(s)
+      MARS.parseSeparator(s)
+      b = MARS.parseOperand(s)
       return [label,op,a,b]
     end
   
-    def MARS.saveWord(instr, label, code, symbols)		    
+    def MARS.saveWord(instr, label, code, symbols)    # :nodoc:    
       if instr.op == "EQU"
         operand = instr.a
         arg = operand[/[+-]?\d+/]
@@ -709,7 +856,7 @@ module MARSLab
       end
     end
       
-    def MARS.translate(s, symbols, loc)
+    def MARS.translate(s, symbols, loc)   # :nodoc:
       if s.length == 0
         s.insert(0, "#0")
         return true
@@ -725,11 +872,12 @@ module MARSLab
       return false
     end
   
-=begin rdoc
-  Assembler -- pass in an array of strings, one instruction per string, get back
-  the program name, an array of Word objects, a symbol table, and an array 
-  of error messages.
-=end
+    # A simple two-pass assembler for Redcode.  The input is an array of strings read
+    # from a file.  The result of the call is an array of 4 items:  
+    # +name+:: the name of the program (if there was a name pseudo-op in the source code)
+    # +code+:: the assembled code, in the form of an array of Word objects
+    # +symbols+:: a Hash with labels and their values
+    # +errors+:: an array of error messages
 
     def MARS.assemble(strings)
       code = Array.new              # save Word objects here
@@ -738,34 +886,33 @@ module MARSLab
       name = "unknown"              # default program name
       name += @@entries.size.to_s
       symbols[:start] = 0           # default starting address
-		
-  		# Pass 1 -- create list of Word objects, build the symbol table:
-		
-  		strings.each_with_index do |line, lineno|
-  			line.rstrip!
-  			next if line.length == 0                    # skip blank lines
-  			if line[0] == ?;                            # comments have ; in column 0
-  			  if md = line.match(/;\s*name\s+(\w+)/)    # does comment have program name?
-  			    name = md[1]                            # yes -- save it
-  		    end
-  			  next
-  		  end
-  		  if n = line.index(";")                      # if comment at end remove it
-  		    line.slice!(n..-1)
-  	    end
+    
+      # Pass 1 -- create list of Word objects, build the symbol table:
+    
+      strings.each_with_index do |line, lineno|
+        line.rstrip!
+        next if line.length == 0                    # skip blank lines
+        if line[0] == ?;                            # comments have ; in column 0
+          if md = line.match(/;\s*name\s+(\w+)/)    # does comment have program name?
+            name = md[1]                            # yes -- save it
+          end
+          next
+        end
+        if n = line.index(";")                      # if comment at end remove it
+          line.slice!(n..-1)
+        end
         begin
           label, op, a, b = MARS.parse(line)
-          # puts "parse '#{label}' '#{op}' '#{a}' '#{b}'"
           instr = Word.new(op, a, b, lineno+1)
-          MARS.saveWord(instr, label, code, symbols)		    
+          MARS.saveWord(instr, label, code, symbols)        
         rescue RedcodeSyntaxError
           errors << "  line #{lineno+1}: #{$!}"
         end
-  		end
-		
-  		# Pass 2 -- translate labels into ints on each instruction:
+      end
+    
+      # Pass 2 -- translate labels into ints on each instruction:
       # TODO -- deal with expressions, e.g. "JMP label + 1"
-		
+    
       code.each_with_index do |instr, loc|
         if instr.op == "DAT" && instr.b.length == 0
           instr.a, instr.b = instr.b, instr.a
@@ -773,23 +920,21 @@ module MARSLab
         begin
           MARS.translate(instr.a, symbols, loc) or raise RedcodeSyntaxError, "unknown/illegal label"
           MARS.translate(instr.b, symbols, loc) or raise RedcodeSyntaxError, "unknown/illegal label"
-    		rescue RedcodeSyntaxError
+        rescue RedcodeSyntaxError
           errors << "  line #{instr.lineno}: #{$!}"
         end
-  		end
-		
-  		return [name, code, symbols, errors]
-  	end
+      end
+    
+      return [name, code, symbols, errors]
+    end
 
     #  -------- End Assembler ----------
 
-  
-=begin rdoc
-  step() -- execute one instruction from each active program.  If a thread dies remove the PC
-  from the array for that program.  A program dies when its last thread dies.
-=end
-		
-  	def MARS.step	  
+    # Execute one instruction from each active program.  If a thread dies remove the PC
+    # from the array for that program.  A program dies when its last thread dies.  The
+    # return value is the number of programs still running.
+    
+    def MARS.step   
       if @@entries.empty?
         puts "no programs loaded"
         return 0
@@ -805,11 +950,11 @@ module MARSLab
       @@pcs.each_with_index do |pc, id|
         loc = pc.next 
         instr = @@mem.fetch(loc)
-  		  printf("%04d: %s\n", pc.current[:addr], instr) if @@params[:tracing]
+        printf("%04d: %s\n", pc.current[:addr], instr) if @@params[:tracing]
 
         if @@drawing
           MARS.updateCells(pc)
-          sleep(@@params[:pace])
+          sleep(@@params[:pause])
         end
       
         begin
@@ -840,28 +985,26 @@ module MARSLab
     
       return @@pcs.size
     
-  	end
-	
-=begin rdoc
-  run(n) -- run the programs, stopping when the number of surviving programs is n.  For a
-  contest n will be 1, but for testing it can be 0.  Another way to return from this method
-  is when a specified number of rounds of instruction executions have taken place.
-=end
-	
-  	def MARS.run(nleft = 0)
+    end
+  
+    # Run the programs in memory, stopping when the number of surviving programs is +nleft+.  
+    # To hold a contest that continues until only one program survives call <tt>Mars.run(1)</tt>,
+    # but when testing a single program the call can be <tt>Mars.run(0)</tt>.  This method will
+    # also return when the maximum number of instructions has been executed (determined by the runtime
+    # parameter +maxRounds+).
+  
+    def MARS.run(nleft = 0)
       nrounds = @@params[:maxRounds]
       loop do
         nprog = MARS.step
         nrounds -= 1
         break if nprog == nleft || nrounds <= 0
       end
-  	end
-	
-=begin rdoc
-  state() -- print info about the machine and any programs in memory
-=end
-	
-  	def MARS.state
+    end
+  
+    # Print information about the machine and any programs in memory.
+  
+    def MARS.state
       puts "MARS CPU with #{@@mem.size}-word memory"
       if @@entries.length == 0
         puts "no programs loaded"
@@ -877,13 +1020,21 @@ module MARSLab
         puts "  #{key}:  #{val}"
       end
       return true
-  	end
-	
-	
-=begin rdoc
-  set_option(key, val) -- set the value of one of the run-time options (valid
-  only when no programs are loaded)
-=end
+    end
+  
+  
+  # Set the value of one of the run-time options.  The options, and their default values, are:
+  # memSize:: size of the virtual machine memory (4096 words)
+  # buffer:: minimum distance between code for two warriors (100 words)
+  # tracing:: when true, print detailed trace as machine runs (false)
+  # pause:: amount of time to pause between screen updates when programs are run (0.01 sec)
+  # maxRounds:: number of turns to give each program before calling a draw (1000)
+  #
+  # Example:
+  #   >>!blue MARS.set_option(:pause, 0.5)
+  #   => 0.5
+  #
+  # Note: Call MARS.state to see the current settings for the options.
 
     def MARS.set_option(key, val)
       if ! @@entries.empty?
@@ -901,7 +1052,7 @@ module MARSLab
           puts ":#{key} must be an integer"
           return nil
         end
-      when :pace
+      when :pause
         if val.class != Float
           puts ":#{key} must be an floating point number (e.g. 0.05)"
           return nil
@@ -913,18 +1064,20 @@ module MARSLab
         end
       else
         puts "Unknown option: #{key}"
+        puts "Call MARS.state to see a list of options and their current settings."
         return nil
       end
       @@params[key] = val
     end
-	
-=begin rdoc
-  view() -- open a visual view of the machine state
   
-	initialize palettes with blends from a dingy color to gray, then
-	add a bright color as the last item
-=end
-
+    # Initialize the RubyLabs canvas with a drawing of the MARS VM main memory.  The
+    # display will show one rectangle for each memory cell.  When a core warrior is 
+    # loaded into memory, the rectangles for the cells it occupies will change color,
+    # with a different color for each contestant.  As a program runs, any memory cells
+    # it references will be filled with that program's color.  To keep the screen from
+    # having too much color, cells gradually fade back to gray if they are not referenced
+    # for a long time.
+    
     def MARS.view(userOptions = {} )
 
       options = @@viewOptions.merge(userOptions)
@@ -938,42 +1091,40 @@ module MARSLab
       
       cells = []
       for i in 0...@@displayMemSize
-  			x = (i % options[:cellCols]) * cellsize + padding
-  			y = (i / options[:cellCols]) * cellsize + padding
-  			cells << Canvas::Rectangle.new( x, y, x+cellsize, y+cellsize, :outline => "#888888", :fill => options[:cellColor] ) 
+        x = (i % options[:cellCols]) * cellsize + padding
+        y = (i / options[:cellCols]) * cellsize + padding
+        cells << Canvas::Rectangle.new( x, y, x+cellsize, y+cellsize, :outline => "#888888", :fill => options[:cellColor] ) 
       end
       
-  		palettes = [
-  			Canvas.palette( [204,204,204], [204,100,100], options[:traceSize] ), 
-  			Canvas.palette( [204,204,204], [100,100,204], options[:traceSize] ),
-  			Canvas.palette( [204,204,204], [100,204,100], options[:traceSize] ),
-  		]
-  		palettes[0] << "#FF0000"
-  		palettes[1] << "#0000FF"
-  		palettes[2] << "#00FF00"
-  		
+      palettes = [
+        Canvas.palette( [204,204,204], [204,100,100], options[:traceSize] ), 
+        Canvas.palette( [204,204,204], [100,100,204], options[:traceSize] ),
+        Canvas.palette( [204,204,204], [100,204,100], options[:traceSize] ),
+      ]
+      palettes[0] << "#FF0000"
+      palettes[1] << "#0000FF"
+      palettes[2] << "#00FF00"
+      
       @@drawing = MARSView.new(cells, palettes, options)
       return true
       
     end
+    
+    # Close the RubyLabs Canvas window.
   
     def MARS.close_view
       Canvas.close
     end
-    
-    def MARS.updateCells(pc)
-  	  id = pc.id
-  	  a = pc.history[pc.current[:thread]]
-  		d = @@drawing.palettes[id].length - a.length
-  		a.each_with_index do |x, i|
-  		  @@drawing.cells[x].fill = @@drawing.palettes[id][i+d]
-  		end    	
-    end
-  
-=begin rdoc
-  Run a contest.  Parameters are names of up to three programs.  Make a Warrior
-  object for each one, load them, and call run.
-=end
+      
+    # Load up to three core warrior programs and start a contest, returning when only one
+    # program is still running or when the maximum number of turns have been taken.  Arguments
+    # can be symbols, in which case they are names of programs in the MARSLab data directory,
+    # or strings, in which case they are interpreted as names of Redcode files in the current
+    # directory. 
+    # 
+    # Example:
+    #   >>!blue MARS.contest(:imp, :dwarf)
+    #   => nil  
 
     def MARS.contest(*args)
       MARS.reset
@@ -987,13 +1138,12 @@ module MARSLab
       MARS.run(1)      # the 1 means stop when only 1 program left running
     end
 
-=begin rdoc
-  reset() -- stop the current contest; clear all PCs, reset memory to all nils
-=end
-
+    # Reset the machine state by clearing memory and removing all programs from
+    # the list of active warriors.
+    
     def MARS.reset
       @@pcs = Array.new
-    	@@mem = Memory.new(@@params[:memSize])
+      @@mem = Memory.new(@@params[:memSize])
       @@entries = Array.new
       Warrior.reset
       if @@drawing
@@ -1004,9 +1154,9 @@ module MARSLab
       return true
     end
    
-=begin rdoc
-  Print the code for one of the Redcode source programs.
-=end
+    # Print a listing of a Redcode source programs.  If the argument is a symbol, it
+    # is interpreted as the name of a program in the MARSLab data directory; if it is
+    # a string, it should be the name of a file in the current directory.
 
     def MARS.listing(prog, dest = nil)
       filename = prog.to_s
@@ -1016,17 +1166,19 @@ module MARSLab
       if !File.exists?(filename)
         puts "File not found: #{filename}"
       else
-    	  File.open(filename).each do |line|
-    	    dest.puts line.chomp
-    	  end
-  	  end
-  	  return nil
+        File.open(filename).each do |line|
+          dest.puts line.chomp
+        end
+      end
+      return nil
     end
     
-=begin rdoc
-  Save a copy of a Redcode source program; if no output file name specified
-  make a file name from the program name.
-=end
+    # Save a copy of a Redcode source program. 
+    # A program named "x" is saved in a file named "x.txt" in the current directory
+    # unless a different file name is passed as a second argument.
+    # If the argument is a symbol, it
+    # is interpreted as the name of a program in the MARSLab data directory; if it is
+    # a string, it should be the name of a file in the current directory.
 
     def MARS.checkout(prog, filename = nil)
       filename = prog.to_s + ".txt" if filename.nil?
@@ -1036,9 +1188,7 @@ module MARSLab
       puts "Copy of #{prog} saved in #{filename}"
     end
     
-=begin rdoc
-  Print a list of programs
-=end
+    # Print a list of programs in the MARSLab data directory.
 
     def MARS.dir
       puts "Redcode programs in #{@@marsDirectory}:"
@@ -1049,13 +1199,26 @@ module MARSLab
       end
       return nil
     end
+    
+    private
+    
+    # Drawing hook, called from MARS.step when the canvas is active.
+    
+    def MARS.updateCells(pc)
+      id = pc.id
+      a = pc.history[pc.current[:thread]]
+      d = @@drawing.palettes[id].length - a.length
+      a.each_with_index do |x, i|
+        @@drawing.cells[x].fill = @@drawing.palettes[id][i+d]
+      end     
+    end
       
   end # class MARS
   
   
-=begin rdoc
-  Make a test machine
-=end
+  # Make a MiniMARS VM with a single program loaded into memory at location 0.
+  # By default the size of the memory is the number of words in the program, but a memory
+  # size can be passed as a second argument.
   
   def make_test_machine(file, size = nil)
     begin
@@ -1065,39 +1228,9 @@ module MARSLab
       return nil
     end
   end
-
-    # -- Initializations -- These are "global" vars in the outer MARSLab scope that are
-    # accessible to all the classes and modules defined inside MARSLab
   
-	@@marsDirectory = File.join(File.dirname(__FILE__), '..', 'data', 'mars')
-
-  @@opcodes = ["DAT", "MOV", "ADD", "SUB", "JMP", "JMZ", "JMN", "DJN", "CMP", "SPL", "END", "SLT", "EQU"]
-  @@modes = "@<#"
-
-  @@maxEntries = 3
-  @@displayMemSize = 4096
-
-  @@params = {
-    :maxRounds => 1000,
-    :memSize => @@displayMemSize,
-    :buffer => 100,
-    :tracing => false,
-    :pace => 0.01,
-  }
-  
-  @@viewOptions = {
-    :cellSize => 8,
-  	:cellRows => 32,
-  	:cellCols => 128,
-  	:padding => 20,
-  	:traceSize => 10,
-  	:cellColor => '#DDDDDD',
-  }
-
-	@@drawing = nil
-
   @@pcs = Array.new
-	@@mem = Memory.new(@@params[:memSize])
+  @@mem = Memory.new(@@params[:memSize])
   @@entries = Array.new
 
 end # MARSLab