rpl 0.1.0

data/lib/rpl/core/string.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RplLang
+  module Core
+    module String
+      def populate_dictionary
+        super
+
+        @dictionary.add_word( ['→str', '->str'],
+                              'String',
+                              '( a -- s ) convert element to string',
+                              proc do
+                                args = stack_extract( [:any] )
+
+                                @stack << { type: :string,
+                                            value: stringify( args[0] ) }
+                              end )
+
+        @dictionary.add_word( ['str→', 'str->'],
+                              'String',
+                              '( s -- a ) convert string to element',
+                              proc do
+                                args = stack_extract( [%i[string]] )
+
+                                @stack += parse( args[0][:value] )
+                              end )
+
+        @dictionary.add_word( ['chr'],
+                              'String',
+                              '( n -- c ) convert ASCII character code in stack level 1 into a string',
+                              proc do
+                                args = stack_extract( [%i[numeric]] )
+
+                                @stack << { type: :string,
+                                            value: args[0][:value].to_i.chr }
+                              end )
+
+        @dictionary.add_word( ['num'],
+                              'String',
+                              '( s -- n ) return ASCII code of the first character of the string in stack level 1 as a real number',
+                              proc do
+                                args = stack_extract( [%i[string]] )
+
+                                @stack << { type: :numeric,
+                                            base: 10,
+                                            value: args[0][:value].ord }
+                              end )
+
+        @dictionary.add_word( ['size'],
+                              'String',
+                              '( s -- n ) return the length of the string',
+                              proc do
+                                args = stack_extract( [%i[string]] )
+
+                                @stack << { type: :numeric,
+                                            base: 10,
+                                            value: args[0][:value].length }
+                              end )
+
+        @dictionary.add_word( ['pos'],
+                              'String',
+                              '( s s -- n ) search for the string in level 1 within the string in level 2',
+                              proc do
+                                args = stack_extract( [%i[string], %i[string]] )
+
+                                @stack << { type: :numeric,
+                                            base: 10,
+                                            value: args[1][:value].index( args[0][:value] ) }
+                              end )
+
+        @dictionary.add_word( ['sub'],
+                              'String',
+                              '( s n n -- s ) return a substring of the string in level 3',
+                              proc do
+                                args = stack_extract( [%i[numeric], %i[numeric], %i[string]] )
+
+                                @stack << { type: :string,
+                                            value: args[2][:value][ (args[1][:value] - 1)..(args[0][:value] - 1) ] }
+                              end )
+
+        @dictionary.add_word( ['rev'],
+                              'String',
+                              '( s -- s ) reverse string',
+                              proc do
+                                args = stack_extract( [%i[string list]] )
+
+                                result = args[0]
+
+                                case args[0][:type]
+                                when :string
+                                  result = { type: :string,
+                                             value: args[0][:value].reverse }
+                                when :list
+                                  result[:value].reverse!
+                                end
+
+                                @stack << result
+                              end )
+
+        @dictionary.add_word( ['split'],
+                              'String',
+                              '( s c -- … ) split string s on character c',
+                              proc do
+                                args = stack_extract( [%i[string], %i[string]] )
+
+                                args[1][:value].split( args[0][:value] ).each do |elt|
+                                  @stack << { type: :string,
+                                              value: elt }
+                                end
+                              end )
+      end
+    end
+  end
+end

data/lib/rpl/core/test.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RplLang
+  module Core
+    module Test
+      def populate_dictionary
+        super
+
+        @dictionary.add_word( ['>'],
+                              'Test',
+                              '( a b -- t ) is a greater than b?',
+                              proc do
+                                args = stack_extract( %i[any any] )
+
+                                @stack << { type: :boolean,
+                                            value: args[1][:value] > args[0][:value] }
+                              end )
+
+        @dictionary.add_word( ['≥', '>='],
+                              'Test',
+                              '( a b -- t ) is a greater than or equal to b?',
+                              proc do
+                                args = stack_extract( %i[any any] )
+
+                                @stack << { type: :boolean,
+                                            value: args[1][:value] >= args[0][:value] }
+                              end )
+
+        @dictionary.add_word( ['<'],
+                              'Test',
+                              '( a b -- t ) is a less than b?',
+                              proc do
+                                args = stack_extract( %i[any any] )
+
+                                @stack << { type: :boolean,
+                                            value: args[1][:value] < args[0][:value] }
+                              end )
+
+        @dictionary.add_word( ['≤', '<='],
+                              'Test',
+                              '( a b -- t ) is a less than or equal to b?',
+                              proc do
+                                args = stack_extract( %i[any any] )
+
+                                @stack << { type: :boolean,
+                                            value: args[1][:value] <= args[0][:value] }
+                              end )
+
+        @dictionary.add_word( ['≠', '!='],
+                              'Test',
+                              '( a b -- t ) is a not equal to b',
+                              proc do
+                                args = stack_extract( %i[any any] )
+
+                                @stack << { type: :boolean,
+                                            value: args[1][:value] != args[0][:value] }
+                              end )
+
+        @dictionary.add_word( ['==', 'same'],
+                              'Test',
+                              '( a b -- t ) is a equal to b',
+                              proc do
+                                args = stack_extract( %i[any any] )
+
+                                @stack << { type: :boolean,
+                                            value: args[1][:value] == args[0][:value] }
+                              end )
+
+        @dictionary.add_word( ['and'],
+                              'Test',
+                              '( a b -- t ) boolean and',
+                              proc do
+                                args = stack_extract( [%i[boolean], %i[boolean]] )
+
+                                @stack << { type: :boolean,
+                                            value: args[1][:value] && args[0][:value] }
+                              end )
+
+        @dictionary.add_word( ['or'],
+                              'Test',
+                              '( a b -- t ) boolean or',
+                              proc do
+                                args = stack_extract( [%i[boolean], %i[boolean]] )
+
+                                @stack << { type: :boolean,
+                                            value: args[1][:value] || args[0][:value] }
+                              end )
+
+        @dictionary.add_word( ['xor'],
+                              'Test',
+                              '( a b -- t ) boolean xor',
+                              proc do
+                                args = stack_extract( [%i[boolean], %i[boolean]] )
+
+                                @stack << { type: :boolean,
+                                            value: args[1][:value] ^ args[0][:value] }
+                              end )
+
+        @dictionary.add_word( ['not'],
+                              'Test',
+                              '( a -- t ) invert boolean value',
+                              proc do
+                                args = stack_extract( [%i[boolean]] )
+
+                                @stack << { type: :boolean,
+                                            value: !args[0][:value] }
+                              end )
+
+        @dictionary.add_word( ['true'],
+                              'Test',
+                              '( -- t ) push true onto stack',
+                              proc do
+                                @stack << { type: :boolean,
+                                            value: true }
+                              end )
+
+        @dictionary.add_word( ['false'],
+                              'Test',
+                              '( -- t ) push false onto stack',
+                              proc do
+                                @stack << { type: :boolean,
+                                            value: false }
+                              end )
+      end
+    end
+  end
+end

data/lib/rpl/core/time-date.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module RplLang
+  module Core
+    module TimeAndDate
+      def populate_dictionary
+        super
+
+        @dictionary.add_word( ['time'],
+                              'Time and date',
+                              '( -- t ) push current time',
+                              proc do
+                                @stack << { type: :string,
+                                            value: Time.now.to_s }
+                              end )
+        @dictionary.add_word( ['date'],
+                              'Time and date',
+                              '( -- d ) push current date',
+                              proc do
+                                @stack << { type: :string,
+                                            value: Date.today.to_s }
+                              end )
+        @dictionary.add_word( ['ticks'],
+                              'Time and date',
+                              '( -- t ) push datetime as ticks',
+                              proc do
+                                ticks_since_epoch = Time.utc( 1, 1, 1 ).to_i * 10_000_000
+                                now = Time.now
+                                @stack << { type: :numeric,
+                                            base: 10,
+                                            value: now.to_i * 10_000_000 + now.nsec / 100 - ticks_since_epoch }
+                              end )
+      end
+    end
+  end
+end

data/lib/rpl/core/trig.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# https://rosettacode.org/wiki/Trigonometric_functions#Ruby
+
+module RplLang
+  module Core
+    module Trig
+      def populate_dictionary
+        super
+
+        @dictionary.add_word( ['𝛑', 'pi'],
+                              'Trig on reals and complexes',
+                              '( … -- 𝛑 ) push 𝛑',
+                              proc do
+                                @stack << { type: :numeric,
+                                            base: 10,
+                                            value: BigMath.PI( precision ) }
+                              end )
+
+        @dictionary.add_word( ['sin'],
+                              'Trig on reals and complexes',
+                              '( n -- m ) compute sinus of n',
+                              proc do
+                                args = stack_extract( [%i[numeric]] )
+
+                                @stack << { type: :numeric,
+                                            base: infer_resulting_base( args ),
+                                            value: BigMath.sin( BigDecimal( args[0][:value], precision ), precision ) }
+                              end )
+
+        @dictionary.add_word( ['asin'],
+                              'Trig on reals and complexes',
+                              '( n -- m ) compute arg-sinus of n',
+                              proc do
+                                run( '
+  dup abs 1 ==
+  « 𝛑 2 / * »
+  « dup sq 1 swap - sqrt / atan »
+  ifte' )
+                              end )
+
+        @dictionary.add_word( ['cos'],
+                              'Trig on reals and complexes',
+                              '( n -- m ) compute cosinus of n',
+                              proc do
+                                args = stack_extract( [%i[numeric]] )
+
+                                @stack << { type: :numeric,
+                                            base: infer_resulting_base( args ),
+                                            value: BigMath.cos( BigDecimal( args[0][:value], precision ), precision ) }
+                              end )
+        @dictionary.add_word( ['acos'],
+                              'Trig on reals and complexes',
+                              '( n -- m ) compute arg-cosinus of n',
+                              proc do
+                                run( '
+  dup 0 ==
+  « drop 𝛑 2 / »
+  «
+    dup sq 1 swap - sqrt / atan
+    dup 0 <
+    « 𝛑 + »
+    ift
+  »
+  ifte' )
+                              end )
+
+        @dictionary.add_word( ['tan'],
+                              'Trig on reals and complexes',
+                              '( n -- m ) compute tangent of n',
+                              proc do
+                                run( 'dup sin swap cos /' )
+                              end )
+
+        @dictionary.add_word( ['atan'],
+                              'Trig on reals and complexes',
+                              '( n -- m ) compute arc-tangent of n',
+                              proc do
+                                args = stack_extract( [%i[numeric]] )
+
+                                @stack << { type: :numeric,
+                                            base: infer_resulting_base( args ),
+                                            value: BigMath.atan( BigDecimal( args[0][:value], precision ), precision ) }
+                              end)
+        @dictionary.add_word( ['d→r', 'd->r'],
+                              'Trig on reals and complexes',
+                              '( n -- m ) convert degree to radian',
+                              proc do
+                                run( '180 / 𝛑 *' )
+                              end )
+        @dictionary.add_word( ['r→d', 'r->d'],
+                              'Trig on reals and complexes',
+                              '( n -- m ) convert radian to degree',
+                              proc do
+                                run( '𝛑 180 / /' )
+                              end)
+      end
+    end
+  end
+end

data/lib/rpl/dictionary.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+class Dictionary
+  attr_reader :words,
+              :vars,
+              :local_vars_layers
+
+  def initialize
+    @words = {}
+    @vars = {}
+    @local_vars_layers = []
+  end
+
+  def add_word( names, category, help, implementation )
+    names.each do |name|
+      @words[ name ] = { category: category,
+                         help: help,
+                         implementation: implementation }
+    end
+  end
+
+  def add_var( name, implementation )
+    @vars[ name ] = implementation
+  end
+
+  def remove_vars( names )
+    names.each do |name|
+      @vars.delete( name )
+    end
+  end
+
+  def remove_var( name )
+    remove_vars( [name] )
+  end
+
+  def remove_all_vars
+    @vars = {}
+  end
+
+  def add_local_vars_layer
+    @local_vars_layers << {}
+  end
+
+  def add_local_var( name, implementation )
+    @local_vars_layers.last[ name ] = implementation
+  end
+
+  def remove_local_vars( names )
+    names.each do |name|
+      @local_vars_layers.last.delete( name )
+    end
+  end
+
+  def remove_local_var( name )
+    remove_local_vars( [name] )
+  end
+
+  def remove_local_vars_layer
+    @local_vars_layers.pop
+  end
+
+  def lookup( name )
+    # look in local variables from the deepest layer up
+    local_vars_layer = @local_vars_layers.reverse.find { |layer| layer[ name ] }
+    word = local_vars_layer.nil? ? nil : local_vars_layer[ name ]
+
+    # otherwise look in (global) variables
+    word ||= @vars[ name ]
+
+    # or is it a core word
+    word ||= @words[ name ].nil? ? nil : @words[ name ][:implementation]
+
+    word
+  end
+end

data/lib/rpl/interpreter.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require 'bigdecimal/math'
+
+require 'rpl/dictionary'
+
+class Interpreter
+  include BigMath
+
+  attr_reader :stack,
+              :dictionary,
+              :version
+
+  attr_accessor :precision
+
+  def initialize( stack = [], dictionary = Rpl::Lang::Dictionary.new )
+    @version = 0.1
+
+    @precision = default_precision
+
+    @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
+
+    splitted_input = input.split(' ')
+
+    # 2-passes:
+    # 1. regroup strings and programs
+    opened_programs = 0
+    closed_programs = 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] != ' '
+      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] == '»'
+        closed_programs += 1
+        elt.gsub!( '»', ' »') if elt.length > 1 && elt[-2] != ' '
+      end
+      string_delimiters += 1 if elt[-1] == '"'
+      name_delimiters += 1 if elt[-1] == "'"
+
+      regrouping = string_delimiters.odd? || name_delimiters.odd? || (opened_programs > closed_programs )
+    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 '"'
+                              :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 parsed_entry[:type] == :program
+        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] )
+        end
+
+        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
+
+          @stack << elt
+        elsif command.is_a?( Proc )
+          command.call
+        else
+          run( command[:value] )
+        end
+      else
+        @stack << elt
+      end
+    end
+
+    @dictionary.remove_local_vars_layer
+
+    # superfluous but feels nice
+    @stack
+  end
+
+  def stack_extract( needs )
+    raise ArgumentError, 'Not enough elements' if @stack.size < needs.size
+
+    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] )
+    end
+
+    args = []
+    needs.size.times do
+      args << @stack.pop
+    end
+
+    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]
+  end
+end