xrpn 1.1

data/lib/debug_mode

@@ -0,0 +1,124 @@
+def debug_mode
+  prompt = TTY::Prompt.new
+  loop do
+    if $prompt
+      @line = prompt.ask(":")
+      break
+    else
+      puts "─" * 30
+      @p.prstk
+      print "> "
+      @ln = STDIN.getch
+      while IO.select([STDIN], [], [], 0) != nil # Flush STDIN (remove control chars)
+        STDIN.getch
+      end
+      if ["+", "-", "*", "/", "%"].include?(@ln)
+        print "\e[32m" + @ln + "\e[0m\n"
+        @ln   = [@ln]
+        @line = hp_41(@ln)[0]
+        break
+      elsif @ln == "\r" # A simple ENTER
+        @line = "lift"
+        puts "\n"
+        break
+      end
+      print "\e[1G\e[K" # Clears from the beginning of line (removes getch prompt)
+      @line = prompt.ask(">", value: @ln)
+      unless @line == nil or @line.length == 1
+        @line = [@line]
+        @line = hp_41(@line)[0]
+      end
+    end
+    case @line
+    when "q" # Quit
+      puts "\n"
+      exit
+    when "Q" # Save and quit
+      save_state()
+      puts "\n"
+      exit
+    when /> .*/
+      state = @line.sub(/> /, '')
+      save_state(state)
+    when /< .*/
+      state = @line.sub(/< /, '')
+      read_state(state)
+    when "c"
+      system("clear")
+    when "C"
+      @p.x   = 0.0
+      @p.y   = 0.0
+      @p.z   = 0.0
+      @p.t   = 0.0
+      @p.l   = 0.0
+      @p.a   = ""
+      @p.deg = "deg"
+      @p.i   = 4
+      @p.s   = 6
+      @p.srg = 11
+      @p.reg = {}
+      @p.flg = {}
+      system("clear")
+    when "R" # Reload all commands from the cmd directory
+      read_cmd
+      puts "Commands reloaded."
+    when "l" # Show current line
+      @line  = @p.prg[@p.pg][@p.pc]
+      puts "Line #{@p.pc + 1}: \"#{@line}\"" # Line 1 is @p.prg[@p.pg][0]
+    when "n" # Show next line
+      if @p.pc + 1 > @p.prg[@p.pg].length
+        puts "End of program"
+      else
+        @line = @p.prg[@p.pg][@p.pc + 1]
+        puts "Line #{@p.pc + 2}: \"#{@line}\"" # Line 1 is @p.prg[@p.pg][0]
+      end
+    when "p" # Show previous line
+      if @p.pc - 1 < 0
+        puts "Beginning of program"
+      else
+        @line  = @p.prg[@p.pg][@p.pc - 1]
+        puts "Line #{@p.pc}: \"#{@line}\"" # Line 1 is @p.prg[@p.pg][0]
+      end
+    when "S" # Go to next line without executing it
+      @p.pc += 1
+      if @p.pc > @p.prg[@p.pg].length
+        puts "End of program"
+      else
+        @line = @p.prg[@p.pg][@p.pc + 1]
+        puts "Line #{@p.pc + 2}: \"#{@line}\"" # Line 1 is @p.prg[@p.pg][0]
+      end
+    when "s" # Single-step the next program line
+      @p.pc += 1
+      if @p.pc == @p.prg[@p.pg].length
+        @line = "END"
+        break
+      end
+      @line  = @p.prg[@p.pg][@p.pc]
+      puts "Line #{@p.pc + 1}: #{@line}" # Line 1 is @p.prg[@p.pg][0]
+      $sst   = true
+      break
+    when "b" # Back-step one line
+      @p.pc -= 1 unless @p.pc == 0
+    when /^\+\+ /
+      @p.prg[@p.pg].insert(@p.pc + 1, @line.sub(/^\+\+ /, ''))
+    when "--"
+      @p.prg[@p.pg].delete_at(@p.pc)
+    when nil # A simple ENTER
+      @line = "lift"
+      break
+    when "r" # End debug mode
+      @p.pc += 1
+      @line  = @p.prg[@p.pg][@p.pc]
+      @line  = "end" if @line == nil
+      $debug = false
+      $sst   = false
+      break unless @p.flg["44"]
+    else
+      break unless @p.flg["44"]
+    end
+  end
+  $prompt = false
+end
+
+ 
+# vim:ft=ruby:

data/lib/dtparse

@@ -0,0 +1,10 @@
+def dtparse(date)
+  @flg["31"] ? d = date.to_i : m =  date.to_i
+  @flg["31"] ? m = ((date - date.to_i) * 100).to_i : d = ((date - date.to_i) * 100).to_i
+  y  = (((date * 100) - (date * 100).to_i) * 10000).to_i
+  dt = "#{y.to_s}-#{m.to_s}-#{d.to_s}"
+  return Date.parse(dt)
+end
+
+ 
+# vim:ft=ruby:

data/lib/error

@@ -0,0 +1,10 @@
+def error(msg)
+  if @p.flg["25"]
+    @p.flg["25"] = false
+  else
+    puts msg
+    @p.stop
+  end
+end
+ 
+# vim:ft=ruby:

data/lib/fact

@@ -0,0 +1,7 @@
+class Integer
+  def fact
+    (1..self).reduce(:*) || 1
+  end
+end
+ 
+# vim:ft=ruby:

data/lib/getpt

@@ -0,0 +1,7 @@
+def getpt
+  r = @xmcont[0][3].to_i + 1
+  c = (@xmcont[0][3].frc * 1000).to_i
+  return r, c
+end
+ 
+# vim:ft=ruby:

data/lib/help

@@ -0,0 +1,12 @@
+def help
+puts <<HELPTEXT
+XRPN is a stack-based programming language. It uses Reverse Polish Notation for calculations.
+The language is a superset of FOCAL, implementing the full set of HP-41CX calculator commands.
+XRPN is on-the-fly extensible. Language functions can be upgraded or implemented while programs are running.
+It runs programs in text files or manually in debug mode (if no text file is supplied or when a program stops)
+XRPN implements indirect adressing, self-modification and features well beyond the FOCAL language.
+For detailed information, visit the GitHub page: https://github.com/isene/xrpn
+HELPTEXT
+end
+ 
+# vim:ft=ruby:

data/lib/hp_41

@@ -0,0 +1,83 @@
+def hp_41 (a)
+  a.map!{|x| x.sub( /^\s+/,      ""           )} # Remove spaces at start of line
+  a.map!{|x| x.sub( /^\d\d+[^0-9.]/, ""       )} # Remove line numbers from program
+  a.map!{|x| x.sub( /\s+$/,      ""           )} # Remove trailing spaces
+  a.map!{|x| x.sub( /\s\s+/,      ""          )} # Remove multiple spaces
+  a.map!{|x| x.sub( /([a-zA-Z ]*)/, &:downcase)} # Downcase everything (use the /i below here)
+  a.map!{|x| x.sub( /ENTER\^/i,  "enter"      )}
+  a.map!{|x| x.sub( /R\^/i,      "rup"        )}
+  a.map!{|x| x.sub( /X\^2/i,     "sqr"        )}
+  a.map!{|x| x.sub( /X\*\*2/i,   "sqr"        )}
+  a.map!{|x| x.sub( /^E(\d+)/i,  '1e\1'       )}
+  a.map!{|x| x.sub( /1\/X/i,     "recip"      )}
+  a.map!{|x| x.sub( /HMS\+/i,    "hmsplus"    )}
+  a.map!{|x| x.sub( /HMS-/i,     "hmsminus"   )}
+  a.map!{|x| x.sub( /DATE\+/i,   "dateplus"   )}
+  a.map!{|x| x.sub( /Σ\+/i,      "splus"      )}
+  a.map!{|x| x.sub( /Σ-/i,       "sminus"     )}
+  a.map!{|x| x.sub( /S\+/i,      "splus"      )}
+  a.map!{|x| x.sub( /S-/i,       "sminus"     )}
+  a.map!{|x| x.sub( /SIGMA\+/i,  "splus"      )}
+  a.map!{|x| x.sub( /SIGMA-/i,   "sminus"     )}
+  a.map!{|x| x.sub( /SIGMAREG/,  "sreg"       )}
+  a.map!{|x| x.sub( /CLSIGMA/,   "cls"        )}
+  a.map!{|x| x.sub( /STO?\+/i,   "stplus"     )}
+  a.map!{|x| x.sub( /STO?-/i,    "stsubtract" )}
+  a.map!{|x| x.sub( /STO?\*/i,   "stmultiply" )}
+  a.map!{|x| x.sub( /STO?\//i,   "stdivide"   )}
+  a.map!{|x| x.sub( /%CH/i,      "perch"      )}
+  a.map!{|x| x.sub( /Y\^X/i,     "pow"        )}
+  a.map!{|x| x.sub( /Y\*\*X/i,   "pow"        )}
+  a.map!{|x| x.sub( /LN1\+X/i,   "ln1x"       )}
+  a.map!{|x| x.sub( /E\^X-1/i,   "expx1"      )} # Must come before next
+  a.map!{|x| x.sub( /E\^X/i,     "exp"        )}
+  a.map!{|x| x.sub( /E\*\*X-1/i, "expx1"      )} # Must come before next
+  a.map!{|x| x.sub( /E\*\*X/i,   "exp"        )}
+  a.map!{|x| x.sub( /10\^X/i,    "tenx"       )}
+  a.map!{|x| x.sub( /10\*\*X/i,  "tenx"       )}
+  a.map!{|x| x.sub( /P-R/i,      "p_r"        )}
+  a.map!{|x| x.sub( /P->R/i,     "p_r"        )}
+  a.map!{|x| x.sub( /R-P/i,      "r_p"        )}
+  a.map!{|x| x.sub( /R->P/i,     "r_p"        )}
+  a.map!{|x| x.sub( /D-R/i,      "d_r"        )}
+  a.map!{|x| x.sub( /D->R/i,     "d_r"        )}
+  a.map!{|x| x.sub( /R-D/i,      "r_d"        )}
+  a.map!{|x| x.sub( /R->D/i,     "r_d"        )}
+  a.map!{|x| x.sub( /X<>Y/i,     "xy"         )}
+  a.map!{|x| x.sub( /X<>F/i,     "xf"         )}
+  a.map!{|x| x.sub( /X<>/i,      "xnn"        )}
+  a.map!{|x| x.sub( /X<>NN/i,    "xnn"        )}
+  a.map!{|x| x.sub( /FC\?C/i,    "fcc?"       )}
+  a.map!{|x| x.sub( /FS\?C/i,    "fsc?"       )}
+  a.map!{|x| x.sub( /X=Y\?/i,    "xeqy?"      )}
+  a.map!{|x| x.sub( /X#Y\?/i,    "xneqy?"     )}
+  a.map!{|x| x.sub( /X!=Y\?/i,   "xneqy?"     )}
+  a.map!{|x| x.sub( /X<>Y\?/i,   "xneqy?"     )}
+  a.map!{|x| x.sub( /X<Y\?/i,    "xlty?"      )}
+  a.map!{|x| x.sub( /X<=Y\?/i,   "xlteqy?"    )}
+  a.map!{|x| x.sub( /X>Y\?/i,    "xgty?"      )}
+  a.map!{|x| x.sub( /X>=Y\?/i,   "xgteqy?"    )}
+  a.map!{|x| x.sub( /X=0\?/i,    "xeq0?"      )}
+  a.map!{|x| x.sub( /X#0\?/i,    "xneq0?"     )}
+  a.map!{|x| x.sub( /X!=0\?/i,   "xneq0?"     )}
+  a.map!{|x| x.sub( /X<>0\?/i,   "xneq0?"     )}
+  a.map!{|x| x.sub( /X<0\?/i,    "xlt0?"      )}
+  a.map!{|x| x.sub( /X<=0\?/i,   "xlteq0?"    )}
+  a.map!{|x| x.sub( /X>0\?/i,    "xgt0?"      )}
+  a.map!{|x| x.sub( /X>=0\?/i,   "xgteq0?"    )}
+  a.map!{|x| x.sub( /X=NN\?/i,   "xeqnn?"     )}
+  a.map!{|x| x.sub( /X#NN\?/i,   "xneqnn?"    )}
+  a.map!{|x| x.sub( /X!=NN\?/i,  "xneqnn?"    )}
+  a.map!{|x| x.sub( /X<>NN\?/i,  "xneqnn?"    )}
+  a.map!{|x| x.sub( /X<NN\?/i,   "xltnn?"     )}
+  a.map!{|x| x.sub( /X<=NN\?/i,  "xlteqnn?"   )}
+  a.map!{|x| x.sub( /X>NN\?/i,   "xgtnn?"     )}
+  a.map!{|x| x.sub( /X>=NN\?/i,  "xgteqnn?"   )}
+  a.map!{|x| x.sub( /T\+X/i,     "tx"         )}
+  a.map!{|x| x.sub( /GOTO/i,     "gto"        )}
+  a.delete("")
+  a.compact!
+  return a
+end
+ 
+# vim:ft=ruby:

data/lib/ind

@@ -0,0 +1,21 @@
+def ind(l3)
+  case l3
+  when "x"
+    l2 = @p.x.to_i.to_s
+  when "y"
+    l2 = @p.y.to_i.to_s
+  when "z"
+    l2 = @p.z.to_i.to_s
+  when "t"
+    l2 = @p.t.to_i.to_s
+  when "l"
+    l2 = @p.l.to_i.to_s
+  else
+    l2 = @p.reg[l3].to_i.to_s 
+  end
+  l2 = "%02d" % [l2] if l2 == l2.to_i.to_s
+  return l2
+end
+
+ 
+# vim:ft=ruby:

data/lib/load_xm

@@ -0,0 +1,28 @@
+def load_xm(f, pt=nil) # Raw file name and pointer
+  f = Dir.home + "/.xrpn/data/" + f
+  fl  = [f + ".da", f + ".as"]
+  hit = false
+  fl.each do |file|
+    if File.exist?(file)
+    @xmcont = JSON.parse(File.read(file)) 
+    @xmfile = file
+    @xmcont[0][0] = file
+    unless pt == nil
+      @xmcont[0][3] = pt
+      save_xm
+    end
+    @xmcont[0][3] = 0.0 if @xmcont[0][3] < 0.0
+    @xmcont[0][3] = @xmcont.length.to_f - 2 if @xmcont[0][3] > @xmcont.length + 2
+    @xmcont[0][1] = "DA" if file.match(/da$/)
+    @xmcont[0][1] = "AS" if file.match(/as$/)
+    hit = true
+    end
+  end
+  if hit
+    puts "Loaded XM file: #{@a} (#{@xmcont[0][0]})"
+  else
+    puts "No such XM file: #{@a}"
+  end
+end
+ 
+# vim:ft=ruby:

data/lib/locate_prg

@@ -0,0 +1,32 @@
+def locate_prg (l)
+  lbl  = "lbl #{l}"
+  page = nil
+  pos  = nil
+  prgm = []
+  if lbl.match(/".*"/)
+    @prg.each_index do |p|
+      pos  = @prg[p].index {|e| e == lbl}
+      page = p unless pos == nil
+      break if pos != nil
+    end
+  else
+    @prg[@pg][@pc..-1].each_with_index do |e, i|
+      pos = i + @pc if e == lbl
+      break if pos != nil
+    end
+    pos = @prg[@pg].index {|e| e == lbl} if pos == nil
+    page = @pg
+  end
+  if pos != nil
+    l = pos
+    until l == @prg[page].length do
+      line = @prg[page][l]
+      prgm.push(line)
+      break if line == "END"
+      l += 1
+    end
+  end
+  return page, pos, prgm
+end
+ 
+# vim:ft=ruby:

data/lib/numeric

@@ -0,0 +1,62 @@
+class Numeric
+
+  def frc
+    f = BigDecimal(self.to_s) - BigDecimal(self.to_s).to_i
+    return BigDecimal(f.to_s).to_s('F').to_f
+  end
+	
+  def to_rad
+	  self * Math::PI / 180 
+  end
+  def to_radg
+	  self * Math::PI / 200 
+  end
+  def to_deg
+	  self * 180 / Math::PI 
+  end
+  def to_grad
+	  self * 200 / Math::PI 
+  end
+  
+  def to_num(n=3, i=2, g=1, c=false, p=false)
+    # n:  Threshold for when to show exponent
+    # i:  Number og digits after the period
+    # g:  Exponent grouping g=3 would always show exponent as a multiple of 3
+    # c:  Use comma instead of period (European format)
+    # p:  Separator per 3 digits (period if c=false, space when c=true)
+    # e:  Exponent
+    # ge: Grouped exponent
+    # x:  Absolute value of number less exponent
+    # s:  String to be displayed
+    n = g if g > n
+    self != 0 ? e = Math::log10(self.abs).floor : e = 0
+    ge = g*(e/g).to_i
+    x  = self.abs
+    x  = (x / 10 ** ge) if e.abs >= n 
+    s  = x.to_i.to_s
+    self < 0 ? m = "-" : m  = ""
+    s.sub!(/-/, '')
+    f  = x.frc.to_s[0..(i + 1)].to_f
+    f  = f.to_s.sub(/../, '')
+    i > 0 ? s.sub!(/(\d*\.)(\d{,#{i}}).*/, '\1\2') : s.sub!(/(\d*).*/, '\1') 
+    if e.abs >= n # If exponent kicks in
+      s += "." + f.ljust(i, "0")
+      s += "e"
+      if ge < 0
+        s += "-"
+        s.sub!(/0\.(\d)/, '\1.')
+      end
+      ge = ge.abs
+      s += "%02d" % [ge]
+    else # No exponent
+      o = "," if p and not c
+      o = " " if p and c
+      s.gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{o}") if p
+      s += "." + f.to_s.ljust(i, "0")
+    end
+    s.sub!(/\./, ',') if c
+    return m + s
+  end
+end
+ 
+# vim:ft=ruby:

data/lib/numformat

@@ -0,0 +1,12 @@
+def numformat(n)
+  return n unless n.is_a? Numeric
+  return "Inf" if n.infinite?
+  if n.to_f.nan?
+    n = "Not a number"
+    return n
+  end
+  return n.to_num(@s,@i,@g,!@flg["28"],@flg["29"])
+end
+
+ 
+# vim:ft=ruby:

data/lib/optparse

@@ -0,0 +1,23 @@
+# Handle the command line options
+options = {}
+optparse = OptionParser.new do |opts|
+  # Set a banner, displayed at the top of the help screen.
+  opts.banner = "Usage: xrpn [options]"
+
+  # Define the options, and what they do
+  opts.on('-f', '--file program', 'Specify the file to process')             { |f| $rfile = f  }
+  opts.on('-l', '--load program(s)', Array, 'File(s) to load, but not run')  { |l| $lfile = l  }
+  opts.on('-s', '--state STATE', 'Load a State file')                        { |s| $sfile = s  }
+  opts.on('-c', '--check program', 'Program file to check for errors')       { |c| check(c); exit }
+  opts.on('-x', '--X X-value', 'Set initial value in the X register')        { |x| @x = x.to_f }
+  opts.on('-y', '--Y Y-value', 'Set initial value in the Y register')        { |y| @y = y.to_f }
+  opts.on('-z', '--Z Z-value', 'Set initial value in the Z register')        { |z| @z = z.to_f }
+  opts.on('-t', '--T T-value', 'Set initial value in the T register')        { |t| @t = t.to_f }
+  opts.on('-a', '--Alpha Alpha-string', 'Set initial string in Alpha')       { |a| @a = a.to_s }
+  opts.on('-h', 'Display SHORT help text')                                   { puts opts; exit }
+  opts.on('--help', 'Display LONG help text')                     { help; puts; puts opts; exit}
+  opts.on('-v', '--version', 'Display the XRPN version number')              { xrpn_version; exit }
+end
+optparse.parse!
+ 
+# vim:ft=ruby:

data/lib/read_cmd

@@ -0,0 +1,12 @@
+def read_cmd
+  $cmd = []
+  Dir[Dir.home+"/.xrpn/cmd/*"].each do |file|
+    load file
+    l = IO.readlines(file)[1]
+    c = l.sub(/\s*def (\S+).*/, '\1').chomp
+    $cmd.push(c)
+  end
+  $cmd.sort!
+end
+ 
+# vim:ft=ruby:

data/lib/read_state

@@ -0,0 +1,6 @@
+def read_state (fn = "conf")
+  @p.flg["23"] = false
+  load (Dir.home + "/.xrpn/" + fn)
+end
+ 
+# vim:ft=ruby:

data/lib/save_state

@@ -0,0 +1,18 @@
+def save_state (fn = "conf")
+  @p.flg["23"] = false
+  cont    = "@p.x   = #{@p.x}\n"
+  cont   += "@p.y   = #{@p.y}\n"
+  cont   += "@p.z   = #{@p.z}\n"
+  cont   += "@p.t   = #{@p.t}\n"
+  cont   += "@p.l   = #{@p.l}\n"
+  cont   += "@p.a   = \"#{@p.a}\"\n"
+  cont   += "@p.i   = #{@p.i}\n"
+  cont   += "@p.s   = #{@p.s}\n"
+  cont   += "@p.srg = #{@p.srg}\n"
+  cont   += "@p.reg = #{@p.reg}\n"
+  cont   += "@p.flg = #{@p.flg}\n"
+  cont   += "@p.prg = #{@p.prg}\n"
+  File.write(Dir.home + "/.xrpn/" + fn, cont)
+end
+
+# vim:ft=ruby:

data/lib/save_xm

@@ -0,0 +1,5 @@
+def save_xm
+  File.write(@xmcont[0][0], @xmcont) if File.exist?(@xmcont[0][0])
+end
+ 
+# vim:ft=ruby:

data/lib/setpt

@@ -0,0 +1,5 @@
+def setpt(r, c)
+  @xmcont[0][3] = r - 1 + (0.001 * c).round(4)
+end
+ 
+# vim:ft=ruby:

data/lib/string

@@ -0,0 +1,28 @@
+class String
+
+  def color (color_code, bold=false)
+    bold ? "\e[38;5;#{color_code};1m#{self}\e[0m" : "\e[38;5;#{color_code}m#{self}\e[0m"
+  end
+
+  def c_x(bold=false)
+    color($colors["X"], bold)
+  end
+  def c_y(bold=false)
+    color($colors["Y"], bold)
+  end
+  def c_z(bold=false)
+    color($colors["Z"], bold)
+  end
+  def c_t(bold=false)
+    color($colors["T"], bold)
+  end
+  def c_l(bold=false)
+    color($colors["L"], bold)
+  end
+  def c_a(bold=false)
+    color($colors["A"], bold)
+  end
+
+end
+ 
+# vim:ft=ruby:

data/lib/theme_dark

@@ -0,0 +1,10 @@
+$colors = {
+  "X" => 255,
+  "Y" => 246,
+  "Z" => 243,
+  "T" => 240,
+  "L" => 130,
+  "A" =>  39
+}
+ 
+# vim:ft=ruby:

data/lib/theme_light

@@ -0,0 +1,10 @@
+$colors = {
+  "X" => 232,
+  "Y" => 241,
+  "Z" => 244,
+  "T" => 247,
+  "L" => 130,
+  "A" =>  39
+}
+ 
+# vim:ft=ruby:

data/lib/xrpn_class

@@ -0,0 +1,34 @@
+# Define the basis for the RPN class
+class XRPN
+  attr_accessor :nolift, :x, :y, :z, :t, :l, :a, :i, :s, :g, :deg, :srg, :reg, :flg, :clk24, :pg, :prg, :pc, :rtn, :xmfile, :xmcont
+  def initialize(file)
+    @nolift    = false  # Disable stacklift
+    @x         = 0.0	  # X register
+    @y         = 0.0	  # Y register
+    @z         = 0.0    # Z register
+    @t         = 0.0    # T register
+    @l         = 0.0    # Last X register
+    @a         = ""     # Alpha register
+    @i         = 4      # Fix (and Sci/Eng) nu,ber of digiet after period
+    @s         = 9      # Threshold for when exponents kick in
+    @g         = 1      # Exponent grouping (set to 3 when ENG mode is set)
+    @deg       = "deg"  # Degree mode (or "rad" for Radians or "grad" for 400°
+    @srg       = 11     # Statistics registers start
+    @reg       = {}     # Registers are stored in a Hash
+    @flg       = {}     # Flags are stored in a Hash
+    @flg["28"] = true   # Radix mark
+    @flg["29"] = true   # Digit separator mark
+    @flg["31"] = false  # Date format (MDY). "true" for DMY
+    @flg["44"] = false  # Continuous ON
+    @clk24     = false  # 24 hour time
+    @pg        = 0      # Active Page
+    @prg       = []     # Active Program
+    @prg[0]    = File.read(file).split("\n") if $rfile
+    @pc        = 0      # Active Program Counter (current step in the active program)
+    @rtn       = []     # Return stack
+    @xmfile    = ""     # Current eXtended Memory file
+    @xmcont    = [["", "", 0, 0.0]]
+  end
+end
+ 
+# vim:ft=ruby: