fOOrth 0.5.0

data/lib/fOOrth/main.rb

@@ -0,0 +1,125 @@
+# coding: utf-8
+
+require 'getoptlong'
+
+#* main.rb - The entry point for a stand-alone foorth session.
+module XfOOrth
+
+  #The user facing format used for date/time display.
+  TimeFormat = '%Y-%m-%d at %I:%M%P'
+
+  #The starting point for an interactive fOOrth programming session.
+  #This method only returns when the session is closed.
+  #<br>Returns:
+  #* The virtual machine used to run the session.
+  #<br>To launch a fOOrth interactive session, simply use:
+  # XfOOrth::main
+  #<br>Endemic Code Smells
+  #* :reek:TooManyStatements
+  def self.main
+    vm = VirtualMachine.vm('Console')
+    running = false
+
+    loop do
+      begin
+        running ||= start_up(vm)
+        vm.process_console
+
+      rescue Interrupt, ForceExit, SilentExit, MiniReadlineEOI => err
+        puts "\n#{err.foorth_message}"
+        break
+
+      rescue StandardError => err
+        vm.display_abort(err)
+
+      rescue Exception => err
+        puts "\n#{err.class.to_s.gsub(/.*::/, '')} detected: #{err}"
+        puts err.backtrace
+        break
+      end
+
+      break unless running
+    end
+
+    vm
+  end
+
+  #Perform one time start-up actions.
+  def self.start_up(vm)
+    announcements
+    vm.debug = false
+    vm.show_stack = false
+    vm.process_string(process_command_line_options)
+    true
+  end
+
+  #Display the start-up messages for the interactive session.
+  def self.announcements
+    puts "Welcome to fOOrth: fO(bject)O(riented)rth."
+    puts "\nfOOrth Reference Implementation Version: #{XfOOrth.version}"
+    puts "\nSession began on: #{Time.now.strftime(TimeFormat)}"
+  end
+
+  #Process the command line arguments. A string is returned containing
+  #fOOrth commands to be executed after the dictionary is loaded.
+  #<br>Returns
+  #* A string of fOOrth commands to be executed after the dictionary is loaded.
+  #<br>Endemic Code Smells
+  #* :reek:TooManyStatements
+  def self.process_command_line_options
+    begin
+
+      defer, found = "", false
+
+      opts = GetoptLong.new(
+        [ "--help",  "-h", "-?", GetoptLong::NO_ARGUMENT ],
+        [ "--load",  "-l",       GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--debug", "-d",       GetoptLong::NO_ARGUMENT ],
+        [ "--show",  "-s",       GetoptLong::NO_ARGUMENT ],
+        [ "--quit",  "-q",       GetoptLong::NO_ARGUMENT ],
+        [ "--words", "-w",       GetoptLong::NO_ARGUMENT ])
+
+      # Translate the parsed options into fOOrth.
+      opts.each do |opt, arg|
+
+        unless found
+          puts
+          found = true
+        end
+
+        case opt
+        when "--debug"
+          defer << ")debug "
+        when "--show"
+          defer << ")show "
+        when "--load"
+          defer << "\"#{arg}\" .load "
+        when "--quit"
+          defer << ")quit "
+        when "--words"
+          defer << ")words "
+        else
+          fail SilentExit
+        end
+      end
+
+      puts if found
+
+    rescue Exception
+      puts
+      puts "fOOrth available options:"
+      puts
+      puts "--help  -h  -?          Display this message and exit."
+      puts "--load  -l <filename>   Load the specified fOOrth source file."
+      puts "--debug -d              Default to debug ON."
+      puts "--quit  -q              Quit after processing the command line."
+      puts "--show  -s              Default to show results ON."
+      puts "--words -w              List the current vocabulary."
+      puts
+      raise SilentExit
+    end
+
+    defer
+  end
+
+end

data/lib/fOOrth/monkey_patch.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+#A collection of standard library monkey patches required by foorth.
+
+require_relative 'monkey_patch/exceptions'
+require_relative 'monkey_patch/object'
+require_relative 'monkey_patch/false'
+require_relative 'monkey_patch/nil'
+require_relative 'monkey_patch/numeric'
+require_relative 'monkey_patch/integer'
+require_relative 'monkey_patch/float'
+require_relative 'monkey_patch/rational'
+require_relative 'monkey_patch/complex'
+require_relative 'monkey_patch/string'

data/lib/fOOrth/monkey_patch/complex.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+#Extensions to the \Complex class required by the fOOrth language system.
+class Complex
+  #Convert this complex number to a form suitable for embedding in a source string.
+  #<br>Returns
+  #* An embeddable form of this complex number as a string.
+  def foorth_embed
+    "Complex(#{self.real.foorth_embed},#{self.imaginary.foorth_embed})"
+  end
+
+  #Argument coercion methods.
+
+  #Coerce the argument to match my type.
+  def foorth_coerce(arg)
+    Complex(arg)
+  rescue
+    error "F40: Cannot coerce a #{arg.foorth_name} to a Complex"
+  end
+
+  #Cannot convert this number to a single character string.
+  def to_foorth_c
+    error "F40: Cannot convert a Complex instance to a character"
+  end
+
+  #Cannot convert this number to a Rational.
+  def to_foorth_r
+    nil
+  end
+end

data/lib/fOOrth/monkey_patch/exceptions.rb

@@ -0,0 +1,154 @@
+# coding: utf-8
+
+# Extensions to Exception to support fOOrth.
+class Exception
+
+  #A hash of exception classes and their fOOrth codes.
+  FOORTH_EXCEPTION_CODE = {
+    SignalException                             =>  "E30:",
+      Interrupt                                 =>  "E30,01:",
+      MiniReadlineEOI                           =>  "E30,02:",
+    StandardError                               =>  "E:",
+      ArgumentError                             =>  "E01:",
+        Gem::Requirement::BadRequirementError   =>  "E01,01:",
+      EncodingError                             =>  "E02:",
+        Encoding::CompatibilityError            =>  "E02,01:",
+        Encoding::ConverterNotFoundError        =>  "E02,02:",
+        Encoding::InvalidByteSequenceError      =>  "E02,03:",
+        Encoding::UndefinedConversionError      =>  "E02,04:",
+      FiberError                                =>  "E03:",
+      IOError                                   =>  "E04:",
+        EOFError                                =>  "E04,01:",
+      IndexError                                =>  "E05:",
+        KeyError                                =>  "E05,01:",
+        StopIteration                           =>  "E05,02:",
+      LocalJumpError                            =>  "E06:",
+      Math::DomainError                         =>  "E07:",
+      NameError                                 =>  "E08:",
+        NoMethodError                           =>  "E08,01:",
+      RangeError                                =>  "E09:",
+        FloatDomainError                        =>  "E09,01:",
+      RegexpError                               =>  "E10:",
+      RuntimeError                              =>  "E11:",
+        Gem::Exception                          =>  "E11,01:",
+          Gem::CommandLineError                 =>  "E11,01,01:",
+          Gem::DependencyError                  =>  "E11,01,02:",
+          Gem::DependencyRemovalException       =>  "E11,01,03:",
+          Gem::DependencyResolutionError        =>  "E11,01,04:",
+          Gem::DocumentError                    =>  "E11,01,05:",
+          Gem::EndOfYAMLException               =>  "E11,01,06:",
+          Gem::FilePermissionError              =>  "E11,01,07:",
+          Gem::FormatException                  =>  "E11,01,08:",
+          Gem::GemNotFoundException             =>  "E11,01,09:",
+            Gem::SpecificGemNotFoundException   =>  "E11,01,09,01:",
+          Gem::GemNotInHomeException            =>  "E11,01,10:",
+          Gem::ImpossibleDependenciesError      =>  "E11,01,11:",
+          Gem::InstallError                     =>  "E11,01,12:",
+          Gem::InvalidSpecificationException    =>  "E11,01,13:",
+          Gem::OperationNotSupportedError       =>  "E11,01,14:",
+          Gem::RemoteError                      =>  "E11,01,15:",
+          Gem::RemoteInstallationCancelled      =>  "E11,01,16:",
+          Gem::RemoteInstallationSkipped        =>  "E11,01,17:",
+          Gem::RemoteSourceException            =>  "E11,01,18:",
+         #Gem::RubyVersionMismatch              =>  "E11,01,19:",
+          Gem::UnsatisfiableDependencyError     =>  "E11,01,20:",
+          Gem::VerificationError                =>  "E11,01,21:",
+     #SystemCallError                           =>  "E12,<error_name>:",
+      ThreadError                               =>  "E13:",
+      TypeError                                 =>  "E14:",
+      ZeroDivisionError                         =>  "E15:"}
+
+  if Object.const_defined?('RubyVersionMismatch')
+    FOORTH_EXCEPTION_CODE[Gem::RubyVersionMismatch] = "E11,01,19:"
+  end
+
+  #Retrieve the fOOrth exception code of this exception.
+  def foorth_code
+    if /^[A-Z]\d\d(,\d\d)*:/ =~ self.message
+      result = $MATCH
+    else
+      klass = self.class
+
+      while (klass)
+        break if (result = FOORTH_EXCEPTION_CODE[klass])
+        klass = klass.superclass
+      end
+    end
+
+    result ||= "E??:"
+  end
+
+  #Is this exception covered by target?
+  def foorth_match(target)
+    self.foorth_code[0, target.length] == target
+  end
+
+  #Get the error message for this exception.
+  def foorth_message
+    "#{self.foorth_code} #{self.message}"
+  end
+end
+
+# Extensions to SystemCallError to support fOOrth.
+class SystemCallError
+
+  #Get the fOOrth error code for a system call error.
+  def foorth_code
+    result = "E12"
+
+    if /::/ =~ self.class.to_s
+      result += ",#{$POSTMATCH}"
+    end
+
+    result + ':'
+  end
+
+end
+
+# Extensions to Interrupt to support fOOrth.
+class Interrupt
+
+  #The message text for the interrupt. Needed as Ruby provides none.
+  def message
+    "Interrupt detected. Exiting fOOrth."
+  end
+
+end
+
+#Shut up already!
+module Exception::Gem #:nodoc: don't document this!
+end
+
+#* exceptions.rb - Exception classes for the fOOrth language interpreter.
+module XfOOrth
+  #The generalize exception used by all fOOrth specific exceptions.
+  class XfOOrthError < StandardError
+
+    #Get the error message for this exception.
+    def foorth_message
+      self.message
+    end
+
+  end
+
+  #The exception raised to force the fOOrth language system to exit.
+  class ForceExit < StandardError
+
+    #Get the error message for this exception.
+    def foorth_message
+      "F00: Quit command received. Exiting fOOrth."
+    end
+
+  end
+
+  #The exception raised to silently force the fOOrth language system to exit.
+  class SilentExit < StandardError
+
+    #Get the error message for this exception. Nothing... It's silent!
+    def foorth_message
+      ""
+    end
+
+  end
+
+end

data/lib/fOOrth/monkey_patch/false.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+#Extensions to the \FalseClass class required by the fOOrth language system.
+class FalseClass
+
+  #Convert this object to a fOOrth boolean.
+  def to_foorth_b
+    self
+  end
+
+end

data/lib/fOOrth/monkey_patch/float.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+
+#Extensions to the \Float class required by the fOOrth language system.
+class Float
+
+  #Argument coercion methods.
+
+  #Coerce the argument to match my type.
+  def self.foorth_coerce(arg)
+    Float(arg)
+  rescue
+    error "F40: Cannot coerce a #{arg.foorth_name} to a Float instance"
+  end
+
+  #Coerce the argument to match my type.
+  def foorth_coerce(arg)
+    Float(arg)
+  rescue
+    error "F40: Cannot coerce a #{arg.foorth_name} to a Float instance"
+  end
+
+end

data/lib/fOOrth/monkey_patch/integer.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+
+#Extensions to the \Integer class required by the fOOrth language system.
+class Integer
+
+  #Argument coercion methods.
+
+  #Coerce the argument to match my type.
+  def self.foorth_coerce(arg)
+    Integer(arg)
+  rescue
+    error "F40: Cannot coerce a #{arg.foorth_name} to an Integer instance"
+  end
+
+  #Coerce the argument to match my type.
+  def foorth_coerce(arg)
+    Integer(arg)
+  rescue
+    error "F40: Cannot coerce a #{arg.foorth_name} to an Integer instance"
+  end
+
+end

data/lib/fOOrth/monkey_patch/nil.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+#Extensions to the \NilClass class required by the fOOrth language system.
+class NilClass
+
+  #Convert this object to a fOOrth boolean.
+  def to_foorth_b
+    false
+  end
+
+end

data/lib/fOOrth/monkey_patch/numeric.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+#Extensions to the \Numeric class required by the fOOrth language system.
+class Numeric
+  #Convert this number to a form suitable for embedding in a source string.
+  #<br>Returns
+  #* An embeddable form of this number as a string.
+  def foorth_embed
+    self.to_s
+  end
+
+  #Convert this number to a single character string.
+  def to_foorth_c
+    as_int = Integer.foorth_coerce(self)
+
+    if as_int < 0 || as_int > 1114111
+      error "F40: Can't convert #{self} to a character."
+    else
+      [as_int].pack('U')
+    end
+  end
+
+  #Convert this numeric to a numeric. Return self.
+  def to_foorth_n
+    self
+  end
+
+  #Convert this numeric to a rational.
+  def to_foorth_r
+    self.rationalize
+  end
+
+end

data/lib/fOOrth/monkey_patch/object.rb

@@ -0,0 +1,43 @@
+# coding: utf-8
+
+#Extensions to the \Object class required by the fOOrth language system.
+class Object
+
+  #Raise a fOOrth language internal exception as this operation is not allowed.
+  def foorth_embed
+    error "F40: Can't embed class #{self.class.to_s}"
+  end
+
+  #Convert this object to a fOOrth boolean.
+  def to_foorth_b
+    true
+  end
+
+  #Convert this object to a single character string.
+  def to_foorth_c
+    "\x00"
+  end
+
+  #Convert this object to a numeric. Returns nil for fail.
+  def to_foorth_n
+    nil
+  end
+
+  #Convert this object to a rational. Returns nil for fail.
+  def to_foorth_r
+    nil
+  end
+
+  #Fail with XfOOrthError argument error.
+  def error(msg)
+    fail XfOOrth::XfOOrthError, msg, caller
+  end
+
+  #Argument coercion methods. These are stubs.
+
+  #Coerce the argument to match my type. Stub
+  def foorth_coerce(_arg)
+    error "F40: Cannot coerce to a #{self.foorth_name}"
+  end
+
+end