rpl 0.4.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fabbce316a5c08423208383985c44621b20e0032499072ada99fe46aa24b7f9a
-  data.tar.gz: d1861c145f2647640cf5192fd376177a2565915e979a15cb46a34a7e340d6171
+  metadata.gz: 2cde98587c0d2ec81f1a6a6d9918b8f7b3ffa40c26959a58d97e7f6e6aef6ef3
+  data.tar.gz: a8aef5c02a2956265a862b3a2530cd972639c60055387adb2dd74c3785a71dc5
 SHA512:
-  metadata.gz: 2150ec4f68a633e83e1e17ce6508ad706e8e3a5cfe9e3683322f9e257d59ac6d37303d2ea87072f4479fe2b42189231748e3d294028a2fdfa6952ad8ae528aa3
-  data.tar.gz: 9e4b5766997db3b9825bd9d713e90a0494d3a007f3f4882bfe7f5eb5aed2e5b47281ee9d077e96915697f884e4a362aed3f652ce647e71b92cee1c4689e4212e
+  metadata.gz: 4fc702e52d8c6d8089bb45cc251964056be1758aea579f3a798afcf404468a7ac754de90f2bb5eacc67c5d1f0489c65b3eb6ca0b3d38c3c0f0f8be54961ad44f
+  data.tar.gz: 83346cce2d900ca261932ceed751e268abc4cab1c5d37da2b198709a1823647d8fefd375f55adbc67b92ee2b3ed3d7c4e28c4fde30c9b8e1f213f275bfdffb7f

data/bin/rpl

@@ -10,6 +10,7 @@ require 'rpl'
 class RplRepl
   def initialize( interpreter )
     interpreter ||= Rpl.new
+
     @interpreter = interpreter
   end
 
@@ -33,28 +34,22 @@ class RplRepl
       begin
         @interpreter.run( input )
       rescue ArgumentError => e
-        p e
+        pp e
       end
 
       print_stack
     end
   end
 
-  def format_element( elt )
-    @interpreter.stringify( elt )
-  end
-
   def print_stack
     stack_size = @interpreter.stack.size
 
     @interpreter.stack.each_with_index do |elt, i|
-      puts "#{stack_size - i}: #{format_element( elt )}"
+      puts "#{stack_size - i}: #{elt}"
     end
   end
 end
 
-interpreter = Rpl.new
-
 options = { run_REPL: ARGV.empty?,
             files: [],
             programs: [] }
@@ -73,14 +68,21 @@ OptionParser.new do |opts|
   end
 end.parse!
 
+# Instantiate interpreter
+interpreter = Rpl.new
+
+# first run provided files if any
 options[:files].each do |filename|
   interpreter.run "\"#{filename}\" feval"
 end
 
+# second run provided code if any
 options[:programs].each do |program|
   interpreter.run program
 end
 
+# third launch REPL if (explicitely or implicitely) asked
 RplRepl.new( interpreter ).run if options[:run_REPL]
 
-pp interpreter.stack.map { |elt| interpreter.stringify( elt ) }.join(' ')
+# last print resulting stack on exit (formatted so that it can be fed back later to interpreter)
+pp interpreter.export_stack

data/lib/rpl/interpreter.rb

@@ -5,9 +5,11 @@ require 'bigdecimal/math'
 require 'bigdecimal/util'
 
 require 'rpl/dictionary'
+require 'rpl/types'
 
 class Interpreter
   include BigMath
+  include Types
 
   attr_reader :stack,
               :dictionary,
@@ -16,173 +18,37 @@ class Interpreter
   attr_accessor :precision
 
   def initialize( stack = [], dictionary = Rpl::Lang::Dictionary.new )
-    @version = 0.1
-
-    @precision = default_precision
+    @version = 0.7
 
     @dictionary = dictionary
     @stack = stack
-
-    populate_dictionary if @dictionary.words.empty?
-  end
-
-  def default_precision
-    12
-  end
-
-  def parse( input )
-    is_numeric = lambda do |elt|
-      begin
-        !Float(elt).nil?
-      rescue ArgumentError
-        begin
-          !Integer(elt).nil?
-        rescue ArgumentError
-          false
-        end
-      end
-    end
-
-    unless input.index("\n").nil?
-      input = input
-                .split("\n")
-                .map do |line|
-        comment_begin_index = line.index('#')
-
-        if comment_begin_index.nil?
-          line
-        elsif comment_begin_index == 0
-          ''
-        else
-          line[0..(comment_begin_index - 1)]
-        end
-      end
-                .join(' ')
-    end
-
-    splitted_input = input.split(' ')
-
-    # 2-passes:
-    # 1. regroup strings and programs
-    opened_programs = 0
-    closed_programs = 0
-    opened_lists = 0
-    closed_lists = 0
-    string_delimiters = 0
-    name_delimiters = 0
-    regrouping = false
-
-    regrouped_input = []
-    splitted_input.each do |elt|
-      if elt[0] == '«'
-        opened_programs += 1
-        elt.gsub!( '«', '« ') if elt.length > 1 && elt[1] != ' '
-      elsif elt[0] == '{'
-        opened_lists += 1
-        elt.gsub!( '{', '{ ') if elt.length > 1 && elt[1] != ' '
-      elsif elt[0] == '"' && elt.length > 1
-        string_delimiters += 1
-      elsif elt[0] == "'" && elt.length > 1
-        name_delimiters += 1
-      end
-
-      elt = "#{regrouped_input.pop} #{elt}".strip if regrouping
-
-      regrouped_input << elt
-
-      case elt[-1]
-      when '»'
-        closed_programs += 1
-        elt.gsub!( '»', ' »') if elt.length > 1 && elt[-2] != ' '
-      when '}'
-        closed_lists += 1
-        elt.gsub!( '}', ' }') if elt.length > 1 && elt[-2] != ' '
-      when '"'
-        string_delimiters += 1
-      when "'"
-        name_delimiters += 1
-      end
-
-      regrouping = string_delimiters.odd? || name_delimiters.odd? || (opened_programs > closed_programs ) || (opened_lists > closed_lists )
-    end
-
-    # 2. parse
-    # TODO: parse ∞, <NaN> as numerics
-    parsed_tree = []
-    regrouped_input.each do |elt|
-      parsed_entry = { value: elt }
-
-      parsed_entry[:type] = case elt[0]
-                            when '«'
-                              :program
-                            when '{'
-                              :list
-                            when '"'
-                              :string
-                            when "'"
-                              :name # TODO: check for forbidden space
-                            else
-                              if is_numeric.call( elt )
-                                :numeric
-                              else
-                                :word
-                              end
-                            end
-
-      if %I[string name].include?( parsed_entry[:type] )
-        parsed_entry[:value] = parsed_entry[:value][1..-2]
-      elsif %I[program].include?( parsed_entry[:type] )
-        parsed_entry[:value] = parsed_entry[:value][2..-3]
-      elsif %I[list].include?( parsed_entry[:type] )
-        parsed_entry[:value] = parse( parsed_entry[:value][2..-3] )
-      elsif %I[numeric].include?( parsed_entry[:type] )
-        underscore_position = parsed_entry[:value].index('_')
-
-        if parsed_entry[:value][0] == '0' && ( ['b', 'o', 'x'].include?( parsed_entry[:value][1] ) || !underscore_position.nil? )
-          if parsed_entry[:value][1] == 'x'
-            parsed_entry[:base] = 16
-          elsif parsed_entry[:value][1] == 'b'
-            parsed_entry[:base] = 2
-          elsif parsed_entry[:value][1] == 'o'
-            parsed_entry[:base] = 8
-            parsed_entry[:value] = parsed_entry[:value][2..]
-          elsif !underscore_position.nil?
-            parsed_entry[:base] = parsed_entry[:value][1..(underscore_position - 1)].to_i
-            parsed_entry[:value] = parsed_entry[:value][(underscore_position + 1)..]
-          end
-        else
-          parsed_entry[:base] = 10
-        end
-
-        parsed_entry[:value] = parsed_entry[:value].to_i( parsed_entry[:base] ) unless parsed_entry[:base] == 10
-        parsed_entry[:value] = BigDecimal( parsed_entry[:value], @precision )
-      end
-
-      parsed_tree << parsed_entry
-    end
-
-    parsed_tree
   end
 
   def run( input )
     @dictionary.add_local_vars_layer
 
-    parse( input.to_s ).each do |elt|
-      case elt[:type]
-      when :word
-        break if %w[break quit exit].include?( elt[:value] )
-
-        command = @dictionary.lookup( elt[:value] )
-
-        if command.nil?
-          # if there isn't a command by that name then it's a name
-          elt[:type] = :name
+    Parser.parse( input.to_s ).each do |elt|
+      if elt.instance_of?( RplName )
+        break if %w[break quit exit].include?( elt.value )
 
+        if elt.not_to_evaluate
           @stack << elt
-        elsif command.is_a?( Proc )
-          command.call
         else
-          run( command[:value] )
+          command = @dictionary.lookup( elt.value )
+          if command.nil?
+            # if there isn't a command by that name then it's a name
+            # elt[:type] = :name
+
+            @stack << elt
+          elsif command.is_a?( Proc )
+            command.call
+          else
+            if command.instance_of?( RplProgram )
+              run( command.value )
+            else
+              @stack << command
+            end
+          end
         end
       else
         @stack << elt
@@ -201,7 +67,7 @@ class Interpreter
     needs.each_with_index do |need, index|
       stack_index = (index + 1) * -1
 
-      raise ArgumentError, "Type Error, needed #{need} got #{@stack[stack_index]}" unless need == :any || need.include?( @stack[stack_index][:type] )
+      raise ArgumentError, "Type Error, needed #{need} got #{@stack[stack_index]}" unless need == :any || need.include?( @stack[stack_index].class )
     end
 
     args = []
@@ -212,52 +78,7 @@ class Interpreter
     args
   end
 
-  def stringify( elt )
-    case elt[:type]
-    when :numeric
-      prefix = case elt[:base]
-               when 2
-                 '0b'
-               when 8
-                 '0o'
-               when 10
-                 ''
-               when 16
-                 '0x'
-               else
-                 "0#{elt[:base]}_"
-               end
-
-      if elt[:value].infinite?
-        suffix = elt[:value].infinite?.positive? ? '∞' : '-∞'
-      elsif elt[:value].nan?
-        suffix = '<NaN>'
-      else
-        suffix = if elt[:value].to_i == elt[:value]
-                   elt[:value].to_i
-                 else
-                   elt[:value].to_s('F')
-                 end
-        suffix = elt[:value].to_s( elt[:base] ) unless elt[:base] == 10
-      end
-
-      "#{prefix}#{suffix}"
-    when :list
-      "{ #{elt[:value].map { |e| stringify( e ) }.join(' ')} }"
-    when :program
-      "« #{elt[:value]} »"
-    when :string
-      "\"#{elt[:value]}\""
-    when :name
-      "'#{elt[:value]}'"
-    else
-      elt[:value]
-    end
-  end
-
-  def infer_resulting_base( numerics )
-    10 if numerics.length.zero?
-
-    numerics.last[:base]
+  def export_stack
+    @stack.map(&:to_s).join(' ')
   end
 end

data/lib/rpl/parser.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class Parser
+  include Types
+
+  def self.parse( input )
+    unless input.index("\n").nil?
+      input = input.split("\n")
+                   .map do |line|
+        comment_begin_index = line.index('#')
+
+        case comment_begin_index
+        when nil
+          line
+        when 0
+          ''
+        else
+          line[0..(comment_begin_index - 1)]
+        end
+      end
+                   .join(' ')
+    end
+
+    splitted_input = input.split(' ')
+
+    # 2-passes:
+    # 1. regroup strings and programs
+    opened_programs = 0
+    closed_programs = 0
+    opened_lists = 0
+    closed_lists = 0
+    string_delimiters = 0
+    name_delimiters = 0
+    regrouping = false
+
+    regrouped_input = []
+    splitted_input.each do |elt|
+      if elt[0] == '«'
+        opened_programs += 1
+        elt.gsub!( '«', '« ') if elt.length > 1 && elt[1] != ' '
+      elsif elt[0] == '{'
+        opened_lists += 1
+        elt.gsub!( '{', '{ ') if elt.length > 1 && elt[1] != ' '
+      elsif elt[0] == '"' && elt.length > 1
+        string_delimiters += 1
+      elsif elt[0] == "'" && elt.length > 1
+        name_delimiters += 1
+      end
+
+      elt = "#{regrouped_input.pop} #{elt}".strip if regrouping
+
+      regrouped_input << elt
+
+      case elt[-1]
+      when '»'
+        closed_programs += 1
+        elt.gsub!( '»', ' »') if elt.length > 1 && elt[-2] != ' '
+      when '}'
+        closed_lists += 1
+        elt.gsub!( '}', ' }') if elt.length > 1 && elt[-2] != ' '
+      when '"'
+        string_delimiters += 1
+      when "'"
+        name_delimiters += 1
+      end
+
+      regrouping = string_delimiters.odd? || name_delimiters.odd? || (opened_programs > closed_programs ) || (opened_lists > closed_lists )
+    end
+
+    # 2. parse
+    regrouped_input.map do |element|
+      if RplBoolean.can_parse?( element )
+        Types.new_object( RplBoolean, element )
+      elsif RplNumeric.can_parse?( element )
+        Types.new_object( RplNumeric, element )
+      elsif RplList.can_parse?( element )
+        Types.new_object( RplList, element )
+      elsif RplString.can_parse?( element )
+        Types.new_object( RplString, element )
+      elsif RplProgram.can_parse?( element )
+        Types.new_object( RplProgram, element )
+      elsif RplName.can_parse?( element )
+        Types.new_object( RplName, element )
+      end
+    end
+  end
+end

data/lib/rpl/types/boolean.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Types
+  class RplBoolean
+    attr_accessor :value
+
+    def initialize( value )
+      raise RplTypeError unless self.class.can_parse?( value )
+
+      @value = if value.is_a?( String )
+                 value.downcase == 'true'
+               else
+                 value
+               end
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+    def self.can_parse?( value )
+      return %w[true false].include?( value.downcase ) if value.is_a?( String )
+
+      %w[TrueClass FalseClass].include?( value.class.to_s )
+    end
+
+    def ==( other )
+      other.class == RplBoolean and
+        other.value == value
+    end
+  end
+end

data/lib/rpl/types/list.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rpl/parser'
+
+module Types
+  class RplList
+    attr_accessor :value
+
+    def initialize( value )
+      raise RplTypeError unless self.class.can_parse?( value )
+
+      @value = if value.instance_of?( Array )
+                 value
+               else
+                 # we systematicalyl trim enclosing { }
+                 Parser.parse( value[2..-3] )
+               end
+    end
+
+    def to_s
+      "{ #{@value.map(&:to_s).join(' ')} }"
+    end
+
+    def self.can_parse?( value )
+      value.instance_of?( Array ) or
+        value[0..1] == '{ ' && value[-2..-1] == ' }'
+    end
+
+    def ==( other )
+      other.class == RplList and
+        other.value == value
+    end
+  end
+end

data/lib/rpl/types/name.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Types
+  class RplName
+    attr_accessor :value,
+                  :not_to_evaluate
+
+    def initialize( value )
+      raise RplTypeError unless self.class.can_parse?( value )
+
+      # we systematicalyl trim enclosing '
+      @not_to_evaluate = value[0] == "'"
+      @value = if value[0] == "'" && value[-1] == "'"
+                 value[1..-2]
+               else
+                 value
+               end
+    end
+
+    def to_s
+      "'#{@value}'"
+    end
+
+    def self.can_parse?( value )
+      ( value.length > 2 and value[0] == "'" and value[-1] == "'" ) or
+        ( value != "''" and !value.match?(/^[0-9']+$/) and
+          # it's not any other type
+          [RplBoolean, RplList, RplProgram, RplString, RplNumeric].reduce( true ) { |memo, type_class| memo && !type_class.can_parse?( value ) } )
+    end
+
+    def ==( other )
+      other.class == RplName and
+        other.value == value
+    end
+  end
+end

data/lib/rpl/types/numeric.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Types
+  class RplNumeric
+    attr_accessor :value,
+                  :base
+
+    @@precision = 12 # rubocop:disable Style/ClassVars
+
+    def self.default_precision
+      @@precision = 12 # rubocop:disable Style/ClassVars
+    end
+
+    def self.precision
+      @@precision
+    end
+
+    def self.precision=( precision )
+      @@precision = precision.to_i # rubocop:disable Style/ClassVars
+    end
+
+    def initialize( value, base = 10 )
+      raise RplTypeError unless self.class.can_parse?( value )
+
+      @base = base
+
+      case value
+      when RplNumeric
+        @value = value.value
+        @base = value.base
+      when BigDecimal
+        @value = value
+      when Integer
+        @value = BigDecimal( value, @@precision )
+      when Float
+        @value = BigDecimal( value, @@precision )
+      when String
+        begin
+          @value = BigDecimal( value )
+        rescue ArgumentError
+          case value
+          when /^0x[0-9a-f]+$/
+            @base = 16
+            @value = /^0x(?<value>[0-9a-f]+)$/.match( value )['value'].to_i( @base )
+          when /^0o[0-7]+$/
+            @base = 8
+            @value = /^0o(?<value>[0-7]+)$/.match( value )['value'].to_i( @base )
+          when /^0b[0-1]+$/
+            @base = 2
+            @value = /^0b(?<value>[0-1]+)$/.match( value )['value'].to_i( @base )
+          when '∞'
+            @value = BigDecimal('+Infinity')
+          when '-∞'
+            @value = BigDecimal('-Infinity')
+          else
+            matches = /(?<base>[0-9]+)b(?<value>[0-9a-z]+)/.match( value )
+            @base = matches['base'].to_i
+            @value = matches['value'].to_i( @base )
+          end
+        end
+      end
+    end
+
+    def to_s
+      prefix = case @base
+               when 2
+                 '0b'
+               when 8
+                 '0o'
+               when 10
+                 ''
+               when 16
+                 '0x'
+               else
+                 "0#{@base}_"
+               end
+
+      if @value.infinite?
+        suffix = @value.infinite?.positive? ? '∞' : '-∞'
+      elsif @value.nan?
+        suffix = '<NaN>'
+      else
+        suffix = if @value.to_i == @value
+                   @value.to_i
+                 else
+                   @value.to_s('F')
+                 end
+        suffix = @value.to_s( @base ) unless @base == 10
+      end
+
+      "#{prefix}#{suffix}"
+    end
+
+    def self.can_parse?( value )
+      [RplNumeric, BigDecimal, Integer, Float].include?( value.class ) or
+        ( value.is_a?( String ) and ( value.match?(/^-?[0-9]*\.?[0-9]+$/) or
+                                      value.match?(/^-?∞$/) or
+                                      value.match?(/^0b[0-1]+$/) or
+                                      value.match?(/^0o[0-7]+$/) or
+                                      value.match?(/^0x[0-9a-f]+$/) or
+                                      ( value.match?(/^[0-9]+b[0-9a-z]+$/) and
+                                        value.split('_').first.to_i <= 36 ) ) )
+    end
+
+    def ==( other )
+      other.class == RplNumeric and
+        other.base == base and
+        other.value == value
+    end
+  end
+end

data/lib/rpl/types/program.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Types
+  class RplProgram
+    attr_accessor :value
+
+    def initialize( value )
+      raise RplTypeError unless self.class.can_parse?( value )
+
+      # we systematicalyl trim enclosing « »
+      @value = value[2..-3] # TODO: parse each element ?
+    end
+
+    def to_s
+      "« #{@value} »"
+    end
+
+    def self.can_parse?( value )
+      value.length > 4 && value[0..1] == '« ' && value[-2..-1] == ' »' && !value[2..-3].strip.empty?
+    end
+
+    def ==( other )
+      other.class == RplProgram and
+        other.value == value
+    end
+  end
+end

data/lib/rpl/types/string.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Types
+  class RplString
+    attr_accessor :value
+
+    def initialize( value )
+      raise RplTypeError unless self.class.can_parse?( value )
+
+      # we systematicalyl trim enclosing "
+      @value = value[1..-2]
+    end
+
+    def to_s
+      "\"#{@value}\""
+    end
+
+    def self.can_parse?( value )
+      value[0] == '"' && value[-1] == '"'
+    end
+
+    def ==( other )
+      other.class == RplString and
+        other.value == value
+    end
+  end
+end