rpl 0.1.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d134c204019846af46914a72d7cd820e58dbe5f5aba2e8cd3f7ec278a7b0cfa4
-  data.tar.gz: 61d0ae3b6bd7e9971af16dc7800d0ec53240c6e05e040e43842e26e19c2dfb4e
+  metadata.gz: db2185e41b8f4562c26b03d1b71ae420661697cb7dfbe3fe27763bc13146427b
+  data.tar.gz: 7130c10e23d621b08d2a71840b48afc5adbd49d8ed2e8f4fc80e507f07cc5dd3
 SHA512:
-  metadata.gz: 2e60874443dd57923ba5674ad18ed3c858f8dbe95868d6e102e740daa7fcb6e550e7e1359a56d08ec7e611da43a26aeb0afba61e4fd7527c45dba2152d07ce0b
-  data.tar.gz: 635163aadcc99ccbce2ab5c047090db712c40eff0b3a973b38d7d7a9545611d6abe03e86dce319189ee92696f6e4c5cea7aef795102ddefacd2b2ba3675e9200
+  metadata.gz: 9a45f40c4fd25cf9eb5471d02cbcd74e2512744e81495aeaeee2f90e278298f09e6f8168caf10f97f93da56c2beadb992c0d927c5bf27a337a21f5ef07fcc6d8
+  data.tar.gz: 44a18620e90a806ebc24488e133e9250dab50165ec27508d5f0d867b7b32e9fee6bb6aa311cfacfe2ccb796e3a8ac408caf1b5e5f4938a81b2ff9aaba21a1603

data/bin/rpl

@@ -1,16 +1,21 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require 'English'
+require 'optparse'
 require 'readline'
 
 require 'rpl'
 
 class RplRepl
-  def initialize
-    @interpreter = Rpl.new
+  def initialize( interpreter )
+    interpreter ||= Rpl.new
+    @interpreter = interpreter
   end
 
   def run
+    print_stack unless @interpreter.stack.empty?
+
     Readline.completion_proc = proc do |s|
       ( @interpreter.dictionary.words.keys + @interpreter.dictionary.vars.keys ).grep(/^#{Regexp.escape(s)}/)
     end
@@ -48,4 +53,34 @@ class RplRepl
   end
 end
 
-RplRepl.new.run
+interpreter = Rpl.new
+
+options = { run_REPL: ARGV.empty?,
+            files: [],
+            programs: [] }
+
+OptionParser.new do |opts|
+  opts.on('-c', '--code "program"', ' ') do |program|
+    options[:programs] << program
+  end
+
+  opts.on('-f', '--file program.rpl', 'load program.rpl') do |filename|
+    options[:files] << filename
+  end
+
+  opts.on('-i', '--interactive', 'launch interactive REPL') do
+    options[:run_REPL] = true
+  end
+end.parse!
+
+options[:files].each do |filename|
+  interpreter.run "\"#{filename}\" feval"
+end
+
+options[:programs].each do |program|
+  interpreter.run program
+end
+
+RplRepl.new( interpreter ).run if options[:run_REPL]
+
+pp interpreter.stack.map { |elt| interpreter.stringify( elt ) }.join(' ')

data/lib/rpl/core/operations.rb

@@ -293,12 +293,16 @@ module RplLang
                                 @stack << ( args[0][:value] > args[1][:value] ? args[0] : args[1] )
                               end )
 
-        # @dictionary.add_word( ['mant'],
-        #                       'Operations on reals',
-        #                       'mantissa of a real number',
-        #                       proc do
+        @dictionary.add_word( ['mant'],
+                              'Operations on reals',
+                              'mantissa of a real number',
+                              proc do
+                                args = stack_extract( [%i[numeric]] )
 
-        #                       end )
+                                @stack << { type: :numeric,
+                                            base: infer_resulting_base( args ),
+                                            value: BigDecimal( args[0][:value].to_s.split('e').first.to_f.abs, @precision ) }
+                              end )
 
         @dictionary.add_word( ['xpon'],
                               'Operations on reals',

data/lib/rpl/core/program.rb

@@ -12,7 +12,11 @@ module RplLang
                               proc do
                                 args = stack_extract( [:any] )
 
-                                run( args[0][:value].to_s )
+                                if %i[list numeric boolean].include?( args[0][:type] )
+                                  @stack << args[0] # these types evaluate to themselves
+                                else
+                                  run( args[0][:value].to_s )
+                                end
                               end )
       end
     end

data/lib/rpl/interpreter.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require 'bigdecimal'
 require 'bigdecimal/math'
+require 'bigdecimal/util'
 
 require 'rpl/dictionary'
 
@@ -41,12 +43,31 @@ class Interpreter
       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
@@ -56,22 +77,33 @@ class Interpreter
       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
-      string_delimiters += 1 if elt[0] == '"' && elt.length > 1
-      name_delimiters += 1 if elt[0] == "'" && elt.length > 1
 
       elt = "#{regrouped_input.pop} #{elt}".strip if regrouping
 
       regrouped_input << elt
 
-      if elt[-1] == '»'
+      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
-      string_delimiters += 1 if elt[-1] == '"'
-      name_delimiters += 1 if elt[-1] == "'"
 
-      regrouping = string_delimiters.odd? || name_delimiters.odd? || (opened_programs > closed_programs )
+      regrouping = string_delimiters.odd? || name_delimiters.odd? || (opened_programs > closed_programs ) || (opened_lists > closed_lists )
     end
 
     # 2. parse
@@ -83,6 +115,8 @@ class Interpreter
       parsed_entry[:type] = case elt[0]
                             when '«'
                               :program
+                            when '{'
+                              :list
                             when '"'
                               :string
                             when "'"
@@ -97,18 +131,30 @@ class Interpreter
 
       if %I[string name].include?( parsed_entry[:type] )
         parsed_entry[:value] = parsed_entry[:value][1..-2]
-      elsif parsed_entry[:type] == :program
+      elsif %I[program].include?( parsed_entry[:type] )
         parsed_entry[:value] = parsed_entry[:value][2..-3]
-      elsif parsed_entry[:type] == :numeric
-        parsed_entry[:base] = 10 # TODO: parse others possible bases 0x...
-
-        begin
-          parsed_entry[:value] = Float( parsed_entry[:value] )
-          parsed_entry[:value] = parsed_entry[:value].to_i if (parsed_entry[:value] % 1).zero? && elt.index('.').nil?
-        rescue ArgumentError
-          parsed_entry[:value] = Integer( parsed_entry[:value] )
+      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
 
@@ -197,7 +243,7 @@ class Interpreter
 
       "#{prefix}#{suffix}"
     when :list
-      "[#{elt[:value].map { |e| stringify( e ) }.join(', ')}]"
+      "{ #{elt[:value].map { |e| stringify( e ) }.join(' ')} }"
     when :program
       "« #{elt[:value]} »"
     when :string

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rpl
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Gwenhael Le Moine
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-15 00:00:00.000000000 Z
+date: 2022-02-22 00:00:00.000000000 Z
 dependencies: []
 description: A language inspired by HP's RPL and https://github.com/louisrubet/rpn/
 email: gwenhael@le-moine.org