merge

Signed-off-by: Gwenhael Le Moine <gwenhael.le.moine@gmail.com>

language.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require './lib/core'
+require './lib/dictionary'
+require './lib/parser'
+require './lib/runner'
+
+module Rpl
+  class Language
+    attr_reader :stack
+
+    def initialize( stack = [] )
+      @stack = stack
+      @dictionary = Rpl::Lang::Dictionary.new
+      @parser = Rpl::Lang::Parser.new
+      @runner = Rpl::Lang::Runner.new
+    end
+
+    def run( input )
+      @stack, @dictionary = @runner.run_input( @parser.parse_input( input ),
+                                               @stack, @dictionary )
+    end
+  end
+end

lib/core.rb

@@ -1,49 +1,54 @@
+# frozen_string_literal: true
+
 require 'bigdecimal/math'
 
-require_relative './language/branch'
-require_relative './language/general'
-require_relative './language/mode'
-require_relative './language/operations'
-require_relative './language/program'
-require_relative './language/stack'
-require_relative './language/string'
-require_relative './language/test'
-require_relative './language/time-date'
-require_relative './language/trig'
-require_relative './language/logs'
+require_relative './core/branch'
+require_relative './core/general'
+require_relative './core/mode'
+require_relative './core/operations'
+require_relative './core/program'
+require_relative './core/stack'
+require_relative './core/store'
+require_relative './core/string'
+require_relative './core/test'
+require_relative './core/time-date'
+require_relative './core/trig'
+require_relative './core/logs'
 
 module Rpl
-  module Core
-    module_function
+  module Lang
+    module Core
+      module_function
 
-    include BigMath
+      include BigMath
 
-    def precision
-      @precision or 12
-    end
-
-    def precision=( value )
-      @precision = value
-    end
-
-    def stack_extract( stack, needs )
-      raise 'Not enough elements' if stack.size < needs.size
-
-      args = []
-      needs.each do |need|
-        elt = stack.pop
-
-        raise "Type Error, needed #{need} got #{elt[:type]}" if need != :any && !need.include?( elt[:type] )
-
-        args << elt
+      def precision
+        @precision or 12
       end
 
-      [stack, args]
-    end
+      def precision=( value )
+        @precision = value
+      end
 
-    def __todo( stack )
-      puts '__NOT IMPLEMENTED__'
-      stack
+      def stack_extract( stack, needs )
+        raise 'Not enough elements' if stack.size < needs.size
+
+        args = []
+        needs.each do |need|
+          elt = stack.pop
+
+          raise "Type Error, needed #{need} got #{elt[:type]}" if need != :any && !need.include?( elt[:type] )
+
+          args << elt
+        end
+
+        [stack, args]
+      end
+
+      def __todo( stack )
+        puts '__NOT IMPLEMENTED__'
+        stack
+      end
     end
   end
 end

lib/core/branch.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rpl
+  module Lang
+    module Core
+      module_function
+
+      # similar to if-then-end, <test-instruction> <true-instruction> ift
+      def ift( stack, dictionary )
+        ifte( stack << { type: :word, value: 'nop' }, dictionary )
+      end
+
+      # similar to if-then-else-end, <test-instruction> <true-instruction> <false-instruction> ifte
+      def ifte( stack, dictionary )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[program word], %i[program word], %i[boolean]] )
+
+        stack << args[ args[2][:value] ? 1 : 0 ]
+
+        Rpl::Lang::Core.eval( stack, dictionary )
+      end
+    end
+  end
+end

lib/core/general.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rpl
+  module Lang
+    module Core
+      module_function
+
+      # no operation
+      def nop( stack )
+        stack
+      end
+    end
+  end
+end

lib/core/mode.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rpl
+  module Lang
+    module Core
+      module_function
+
+      # set float precision in bits. ex: 256 prec
+      def prec( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[numeric]] )
+
+        Rpl::Lang::Core.precision = args[0][:value]
+
+        stack
+      end
+
+      # set float representation and precision to default
+      def default( stack )
+        Rpl::Lang::Core.precision = 12
+
+        stack
+      end
+
+      # show type of stack first entry
+      def type( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [:any] )
+
+        stack << args[0]
+        stack << { type: :string,
+                   value: args[0][:type].to_s }
+        stack
+      end
+    end
+  end
+end

lib/core/operations.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Rpl
+  module Lang
+    module Core
+      module_function
+
+      # addition
+      def add( stack )
+        addable = %i[numeric string name]
+        stack, args = Rpl::Core.stack_extract( stack, [addable, addable] )
+
+        result = { type: case args[1][:type]
+                         when :name
+                           :name
+                         when :string
+                           :string
+                         when :numeric
+                           if args[0][:type] == :numeric
+                             :numeric
+                           else
+                             :string
+                           end
+                         end }
+
+        args.each do |elt|
+          elt[:value] = elt[:value][1..-2] unless elt[:type] == :numeric
+        end
+
+        result[:value] = case result[:type]
+                         when :name
+                           "'#{args[1][:value]}#{args[0][:value]}'"
+                         when :string
+                           "\"#{args[1][:value]}#{args[0][:value]}\""
+                         when :numeric
+                           args[1][:value] + args[0][:value]
+                         end
+
+        result[:base] = 10 if result[:type] == :numeric # TODO: what if operands have other bases ?
+
+        stack << result
+      end
+
+      # substraction
+      def subtract( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
+
+        stack << { type: :numeric, base: 10,
+                   value: args[1][:value] - args[0][:value] }
+      end
+
+      # negation
+      def negate( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
+
+        stack << { type: :numeric, base: 10,
+                   value: args[0][:value] * -1 }
+      end
+
+      # multiplication
+      def multiply( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
+
+        stack << { type: :numeric, base: 10,
+                   value: args[1][:value] * args[0][:value] }
+      end
+
+      # division
+      def divide( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
+
+        raise 'Division by 0' if args[0][:value].zero?
+
+        stack << { type: :numeric, base: 10,
+                   value: args[1][:value] / args[0][:value] }
+      end
+
+      # inverse
+      def inverse( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
+
+        raise 'Division by 0' if args[0][:value].zero?
+
+        stack << { type: :numeric, base: 10,
+                   value: 1.0 / args[0][:value] }
+      end
+
+      # power
+      def power( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
+
+        stack << { type: :numeric, base: 10,
+                   value: args[1][:value]**args[0][:value] }
+      end
+
+      # rpn_square root
+      def sqrt( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
+
+        stack << { type: :numeric, base: 10,
+                   value: BigMath.sqrt( BigDecimal( args[0][:value] ), Rpl::Core.precision ) }
+      end
+
+      # rpn_square
+      def sq( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
+
+        stack << { type: :numeric, base: 10,
+                   value: args[0][:value] * args[0][:value] }
+      end
+
+      # absolute value
+      def abs( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
+
+        stack << { type: :numeric, base: 10,
+                   value: args[0][:value].abs }
+      end
+
+      # decimal representation
+      def dec( stack )
+        base( stack << { type: :numeric, base: 10, value: 10 } )
+      end
+
+      # hexadecimal representation
+      def hex( stack )
+        base( stack << { type: :numeric, base: 10, value: 16 } )
+      end
+
+      # binary representation
+      def bin( stack )
+        base( stack << { type: :numeric, base: 10, value: 2 } )
+      end
+
+      # arbitrary base representation
+      def base( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
+
+        args[1][:base] = args[0][:value]
+
+        stack << args[1]
+      end
+
+      # 1 if number at stack level 1 is > 0, 0 if == 0, -1 if <= 0
+      def sign( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
+        value = if args[0][:value].positive?
+                  1
+                elsif args[0][:value].negative?
+                  -1
+                else
+                  0
+                end
+
+        stack << { type: :numeric, base: 10,
+                   value: value }
+      end
+
+      # OPERATIONS ON REALS
+
+      # percent
+      def percent( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
+
+        stack << { type: :numeric,
+                   base: 10,
+                   value: args[0][:value] * ( args[1][:value] / 100.0 ) }
+
+        stack
+      end
+
+      # inverse percent
+      def inverse_percent( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
+
+        stack << { type: :numeric,
+                   base: 10,
+                   value: 100.0 * ( args[0][:value] / args[1][:value] ) }
+
+        stack
+      end
+
+      # modulo
+      def mod( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
+
+        stack << { type: :numeric,
+                   base: 10,
+                   value: args[1][:value] % args[0][:value] }
+
+        stack
+      end
+
+      # n! for integer n or Gamma(x+1) for fractional x
+      def fact( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
+
+        stack << { type: :numeric,
+                   base: 10,
+                   value: Math.gamma( args[0][:value] ) }
+
+        stack
+      end
+
+      # largest number <=
+      def floor( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
+
+        stack << { type: :numeric,
+                   base: 10,
+                   value: args[0][:value].floor }
+
+        stack
+      end
+
+      # smallest number >=
+      def ceil( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
+
+        stack << { type: :numeric,
+                   base: 10,
+                   value: args[0][:value].ceil }
+
+        stack
+      end
+
+      # min of 2 real numbers
+      def min( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
+
+        stack << ( args[0][:value] < args[1][:value] ? args[0] : args[1] )
+
+        stack
+      end
+
+      # max of 2 real numbers
+      def max( stack )
+        stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
+
+        stack << ( args[0][:value] > args[1][:value] ? args[0] : args[1] )
+
+        stack
+      end
+    end
+  end
+end

lib/core/program.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rpl
+  module Lang
+    module Core
+      module_function
+
+      # evaluate (run) a program, or recall a variable. ex: 'my_prog' eval
+      def eval( stack, dictionary )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[program word name]] )
+
+        # we trim enclosing «»
+        preparsed_input = args[0][:type] == :word ? args[0][:value] : args[0][:value][1..-2]
+        parsed_input = Rpl::Lang::Parser.new.parse_input( preparsed_input )
+
+        stack, _dictionary = Rpl::Lang::Runner.new.run_input( parsed_input,
+                                                              stack, dictionary )
+        # TODO: check that STO actually updates dictionary
+
+        stack
+      end
+    end
+  end
+end

lib/core/stack.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Rpl
+  module Lang
+    module Core
+      module_function
+
+      # swap 2 first stack entries
+      def swap( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any any] )
+
+        stack << args[0] << args[1]
+      end
+
+      # drop first stack entry
+      def drop( stack )
+        dropn( stack << { type: :numeric, base: 10, value: 1 } )
+      end
+
+      # drop 2 first stack entries
+      def drop2( stack )
+        dropn( stack << { type: :numeric, base: 10, value: 2 } )
+      end
+
+      # drop n first stack entries
+      def dropn( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[numeric]] )
+        stack, _args = Rpl::Lang::Core.stack_extract( stack, %i[any] * args[0][:value] )
+
+        stack
+      end
+
+      # drop all stack entries
+      def del( _stack )
+        []
+      end
+
+      # rotate 3 first stack entries
+      def rot( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any any any] )
+
+        stack << args[1] << args[0] << args[2]
+      end
+
+      # duplicate first stack entry
+      def dup( stack )
+        dupn( stack << { type: :numeric, base: 10, value: 1 } )
+      end
+
+      # duplicate 2 first stack entries
+      def dup2( stack )
+        dupn( stack << { type: :numeric, base: 10, value: 2 } )
+      end
+
+      # duplicate n first stack entries
+      def dupn( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[numeric]] )
+        n = args[0][:value]
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any] * args[0][:value] )
+
+        args.reverse!
+
+        2.times do
+          n.times.each do |i|
+            stack << args[ i ]
+          end
+        end
+
+        stack
+      end
+
+      # push a copy of the given stack level onto the stack
+      def pick( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[numeric]] )
+        n = args[0][:value]
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any] * args[0][:value] )
+
+        args.reverse!
+
+        n.times.each do |i|
+          stack << args[ i ]
+        end
+        stack << args[0]
+
+        stack
+      end
+
+      # give stack depth
+      def depth( stack )
+        stack << { type: :numeric, base: 10, value: stack.size }
+      end
+
+      # move a stack entry to the top of the stack
+      def roll( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[numeric]] )
+        n = args[0][:value]
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any] * args[0][:value] )
+
+        args.reverse!
+
+        (1..(n - 1)).each do |i|
+          stack << args[ i ]
+        end
+        stack << args[0]
+
+        stack
+      end
+
+      # move the element on top of the stack to a higher stack position
+      def rolld( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[numeric]] )
+        n = args[0][:value]
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any] * args[0][:value] )
+
+        args.reverse!
+
+        stack << args[n - 1]
+
+        (0..(n - 2)).each do |i|
+          stack << args[ i ]
+        end
+
+        stack
+      end
+
+      # push a copy of the element in stack level 2 onto the stack
+      def over( stack )
+        pick( stack << { type: :numeric, base: 10, value: 2 } )
+      end
+    end
+  end
+end

lib/core/string.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Rpl
+  module Lang
+    module Core
+      module_function
+
+      # convert an object into a string
+      def to_string( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [:any] )
+
+        stack << { type: :string,
+                   value: args[0][:value].to_s }
+      end
+
+      # convert a string into an object
+      def from_string( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[string]] )
+
+        parsed_input = Rpl::Lang::Parser.new.parse_input( args[0][:value] )
+
+        stack + parsed_input
+      end
+
+      # convert ASCII character code in stack level 1 into a string
+      def chr( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[numeric]] )
+
+        stack << { type: :string,
+                   value: args[0][:value].chr }
+      end
+
+      # return ASCII code of the first character of the string in stack level 1 as a real number
+      def num( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[string]] )
+
+        stack << { type: :numeric,
+                   base: 10,
+                   value: args[0][:value].ord }
+      end
+
+      # return the length of the string
+      def size( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[string]] )
+
+        stack << { type: :numeric,
+                   base: 10,
+                   value: args[0][:value].length }
+      end
+
+      # search for the string in level 1 within the string in level 2
+      def pos( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[string], %i[string]] )
+
+        stack << { type: :numeric,
+                   base: 10,
+                   value: args[1][:value].index( args[0][:value] ) }
+      end
+
+      # return a substring of the string in level 3
+      def sub( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[numeric], %i[numeric], %i[string]] )
+
+        stack << { type: :string,
+                   value: args[2][:value][args[1][:value]..args[0][:value]] }
+      end
+    end
+  end
+end

lib/core/test.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Rpl
+  module Lang
+    module Core
+      module_function
+
+      # binary operator >
+      def greater_than( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any any] )
+
+        stack << { type: :boolean,
+                   value: args[1][:value] > args[0][:value] }
+        stack
+      end
+
+      # binary operator >=
+      def greater_or_equal_than( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any any] )
+
+        stack << { type: :boolean,
+                   value: args[1][:value] >= args[0][:value] }
+        stack
+      end
+
+      # binary operator <
+      def less_than( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any any] )
+
+        stack << { type: :boolean,
+                   value: args[1][:value] < args[0][:value] }
+        stack
+      end
+
+      # binary operator <=
+      def less_or_equal_than( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any any] )
+
+        stack << { type: :boolean,
+                   value: args[1][:value] <= args[0][:value] }
+        stack
+      end
+
+      # boolean operator != (different)
+      def different( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any any] )
+
+        stack << { type: :boolean,
+                   value: args[1][:value] != args[0][:value] }
+        stack
+      end
+
+      # boolean operator and
+      def and( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[boolean], %i[boolean]] )
+
+        stack << { type: :boolean,
+                   value: args[1][:value] && args[0][:value] }
+        stack
+      end
+
+      # boolean operator or
+      def or( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[boolean], %i[boolean]] )
+
+        stack << { type: :boolean,
+                   value: args[1][:value] || args[0][:value] }
+        stack
+      end
+
+      # boolean operator xor
+      def xor( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[boolean], %i[boolean]] )
+
+        stack << { type: :boolean,
+                   value: args[1][:value] ^ args[0][:value] }
+        stack
+      end
+
+      # boolean operator not
+      def not( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, [%i[boolean]] )
+
+        stack << { type: :boolean,
+                   value: !args[0][:value] }
+        stack
+      end
+
+      # boolean operator same (equal)
+      def same( stack )
+        stack, args = Rpl::Lang::Core.stack_extract( stack, %i[any any] )
+
+        stack << { type: :boolean,
+                   value: args[1][:value] == args[0][:value] }
+        stack
+      end
+
+      # true boolean
+      def true( stack )
+        stack << { type: :boolean,
+                   value: true }
+        stack
+      end
+
+      # false boolean
+      def false( stack )
+        stack << { type: :boolean,
+                   value: false }
+        stack
+      end
+    end
+  end
+end

lib/core/time-date.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Rpl
+  module Lang
+    module Core
+      module_function
+
+      # time in local format
+      def time( stack )
+        stack << { type: :string,
+                   value: Time.now.to_s }
+      end
+
+      # date in local format
+      def date( stack )
+        stack << { type: :string,
+                   value: Date.today.to_s }
+      end
+
+      # system tick in µs
+      def ticks( stack )
+        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

lib/dictionary.rb

@@ -1,202 +1,204 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Rpl
-  class Dictionary
-    def initialize
-      @parser = Parser.new
-      @words = {}
+  module Lang
+    class Dictionary
+      def initialize
+        @parser = Parser.new
+        @words = {}
 
-      # GENERAL
-      add( 'nop',     proc { |stack| Rpl::Core.nop( stack ) } )
-      add( 'help',    proc { |stack| Rpl::Core.__todo( stack ) } ) # this help message
-      add( 'quit',    proc { |stack| Rpl::Core.__todo( stack ) } ) # quit software
-      add( 'version', proc { |stack| Rpl::Core.__todo( stack ) } ) # show rpn version
-      add( 'uname',   proc { |stack| Rpl::Core.__todo( stack ) } ) # show rpn complete identification string
-      add( 'history', proc { |stack| Rpl::Core.__todo( stack ) } ) # see commands history
+        # GENERAL
+        add( 'nop',     proc { |stack| Rpl::Lang::Core.nop( stack ) } )
+        add( 'help',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # this help message
+        add( 'quit',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # quit software
+        add( 'version', proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # show rpn version
+        add( 'uname',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # show rpn complete identification string
+        add( 'history', proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # see commands history
 
-      # STACK
-      add( 'swap',    proc { |stack| Rpl::Core.swap( stack ) } )
-      add( 'drop',    proc { |stack| Rpl::Core.drop( stack ) } )
-      add( 'drop2',   proc { |stack| Rpl::Core.drop2( stack ) } )
-      add( 'dropn',   proc { |stack| Rpl::Core.dropn( stack ) } )
-      add( 'del',     proc { |stack| Rpl::Core.del( stack ) } )
-      add( 'rot',     proc { |stack| Rpl::Core.rot( stack ) } )
-      add( 'dup',     proc { |stack| Rpl::Core.dup( stack ) } )
-      add( 'dup2',    proc { |stack| Rpl::Core.dup2( stack ) } )
-      add( 'dupn',    proc { |stack| Rpl::Core.dupn( stack ) } )
-      add( 'pick',    proc { |stack| Rpl::Core.pick( stack ) } )
-      add( 'depth',   proc { |stack| Rpl::Core.depth( stack ) } )
-      add( 'roll',    proc { |stack| Rpl::Core.roll( stack ) } )
-      add( 'rolld',   proc { |stack| Rpl::Core.rolld( stack ) } )
-      add( 'over',    proc { |stack| Rpl::Core.over( stack ) } )
+        # STACK
+        add( 'swap',    proc { |stack| Rpl::Lang::Core.swap( stack ) } )
+        add( 'drop',    proc { |stack| Rpl::Lang::Core.drop( stack ) } )
+        add( 'drop2',   proc { |stack| Rpl::Lang::Core.drop2( stack ) } )
+        add( 'dropn',   proc { |stack| Rpl::Lang::Core.dropn( stack ) } )
+        add( 'del',     proc { |stack| Rpl::Lang::Core.del( stack ) } )
+        add( 'rot',     proc { |stack| Rpl::Lang::Core.rot( stack ) } )
+        add( 'dup',     proc { |stack| Rpl::Lang::Core.dup( stack ) } )
+        add( 'dup2',    proc { |stack| Rpl::Lang::Core.dup2( stack ) } )
+        add( 'dupn',    proc { |stack| Rpl::Lang::Core.dupn( stack ) } )
+        add( 'pick',    proc { |stack| Rpl::Lang::Core.pick( stack ) } )
+        add( 'depth',   proc { |stack| Rpl::Lang::Core.depth( stack ) } )
+        add( 'roll',    proc { |stack| Rpl::Lang::Core.roll( stack ) } )
+        add( 'rolld',   proc { |stack| Rpl::Lang::Core.rolld( stack ) } )
+        add( 'over',    proc { |stack| Rpl::Lang::Core.over( stack ) } )
 
-      # USUAL OPERATIONS ON REALS AND COMPLEXES
-      add( '+',       proc { |stack| Rpl::Core.add( stack ) } )
-      add( '-',       proc { |stack| Rpl::Core.subtract( stack ) } )
-      add( 'chs',     proc { |stack| Rpl::Core.negate( stack ) } )
-      add( '*',       proc { |stack| Rpl::Core.multiply( stack ) } )
-      add( '×',       proc { |stack| Rpl::Core.multiply( stack ) } ) # alias
-      add( '/',       proc { |stack| Rpl::Core.divide( stack ) } )
-      add( '÷',       proc { |stack| Rpl::Core.divide( stack ) } ) # alias
-      add( 'inv',     proc { |stack| Rpl::Core.inverse( stack ) } )
-      add( '^',       proc { |stack| Rpl::Core.power( stack ) } )
-      add( 'sqrt',    proc { |stack| Rpl::Core.sqrt( stack ) } )
-      add( 'sq',      proc { |stack| Rpl::Core.sq( stack ) } )
-      add( 'abs',     proc { |stack| Rpl::Core.abs( stack ) } )
-      add( 'dec',     proc { |stack| Rpl::Core.dec( stack ) } )
-      add( 'hex',     proc { |stack| Rpl::Core.hex( stack ) } )
-      add( 'bin',     proc { |stack| Rpl::Core.bin( stack ) } )
-      add( 'base',    proc { |stack| Rpl::Core.base( stack ) } )
-      add( 'sign',    proc { |stack| Rpl::Core.sign( stack ) } )
+        # USUAL OPERATIONS ON REALS AND COMPLEXES
+        add( '+',       proc { |stack| Rpl::Lang::Core.add( stack ) } )
+        add( '-',       proc { |stack| Rpl::Lang::Core.subtract( stack ) } )
+        add( 'chs',     proc { |stack| Rpl::Lang::Core.negate( stack ) } )
+        add( '*',       proc { |stack| Rpl::Lang::Core.multiply( stack ) } )
+        add( '×',       proc { |stack| Rpl::Lang::Core.multiply( stack ) } ) # alias
+        add( '/',       proc { |stack| Rpl::Lang::Core.divide( stack ) } )
+        add( '÷',       proc { |stack| Rpl::Lang::Core.divide( stack ) } ) # alias
+        add( 'inv',     proc { |stack| Rpl::Lang::Core.inverse( stack ) } )
+        add( '^',       proc { |stack| Rpl::Lang::Core.power( stack ) } )
+        add( 'sqrt',    proc { |stack| Rpl::Lang::Core.sqrt( stack ) } )
+        add( 'sq',      proc { |stack| Rpl::Lang::Core.sq( stack ) } )
+        add( 'abs',     proc { |stack| Rpl::Lang::Core.abs( stack ) } )
+        add( 'dec',     proc { |stack| Rpl::Lang::Core.dec( stack ) } )
+        add( 'hex',     proc { |stack| Rpl::Lang::Core.hex( stack ) } )
+        add( 'bin',     proc { |stack| Rpl::Lang::Core.bin( stack ) } )
+        add( 'base',    proc { |stack| Rpl::Lang::Core.base( stack ) } )
+        add( 'sign',    proc { |stack| Rpl::Lang::Core.sign( stack ) } )
 
-      # OPERATIONS ON REALS
-      add( '%',       proc { |stack| Rpl::Core.percent( stack ) } )
-      add( '%CH',     proc { |stack| Rpl::Core.inverse_percent( stack ) } )
-      add( 'mod',     proc { |stack| Rpl::Core.mod( stack ) } )
-      add( 'fact',    proc { |stack| Rpl::Core.fact( stack ) } )
-      add( 'mant',    proc { |stack| Rpl::Core.__todo( stack ) } ) # mantissa of a real number
-      add( 'xpon',    proc { |stack| Rpl::Core.__todo( stack ) } ) # exponant of a real number
-      add( 'floor',   proc { |stack| Rpl::Core.floor( stack ) } )
-      add( 'ceil',    proc { |stack| Rpl::Core.ceil( stack ) } )
-      add( 'ip',      proc { |stack| Rpl::Core.__todo( stack ) } ) # integer part
-      add( 'fp',      proc { |stack| Rpl::Core.__todo( stack ) } ) # fractional part
-      add( 'min',     proc { |stack| Rpl::Core.min( stack ) } )
-      add( 'max',     proc { |stack| Rpl::Core.max( stack ) } )
+        # OPERATIONS ON REALS
+        add( '%',       proc { |stack| Rpl::Lang::Core.percent( stack ) } )
+        add( '%CH',     proc { |stack| Rpl::Lang::Core.inverse_percent( stack ) } )
+        add( 'mod',     proc { |stack| Rpl::Lang::Core.mod( stack ) } )
+        add( 'fact',    proc { |stack| Rpl::Lang::Core.fact( stack ) } )
+        add( 'mant',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # mantissa of a real number
+        add( 'xpon',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # exponant of a real number
+        add( 'floor',   proc { |stack| Rpl::Lang::Core.floor( stack ) } )
+        add( 'ceil',    proc { |stack| Rpl::Lang::Core.ceil( stack ) } )
+        add( 'ip',      proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # integer part
+        add( 'fp',      proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # fractional part
+        add( 'min',     proc { |stack| Rpl::Lang::Core.min( stack ) } )
+        add( 'max',     proc { |stack| Rpl::Lang::Core.max( stack ) } )
 
-      # OPERATIONS ON COMPLEXES
-      add( 're',      proc { |stack| Rpl::Core.__todo( stack ) } ) # complex real part
-      add( 'im',      proc { |stack| Rpl::Core.__todo( stack ) } ) # complex imaginary part
-      add( 'conj',    proc { |stack| Rpl::Core.__todo( stack ) } ) # complex conjugate
-      add( 'arg',     proc { |stack| Rpl::Core.__todo( stack ) } ) # complex argument in radians
-      add( 'c->r',    proc { |stack| Rpl::Core.__todo( stack ) } ) # transform a complex in 2 reals
-      add( 'c→r',     proc { |stack| Rpl::Core.__todo( stack ) } ) # alias
-      add( 'r->c',    proc { |stack| Rpl::Core.__todo( stack ) } ) # transform 2 reals in a complex
-      add( 'r→c',     proc { |stack| Rpl::Core.__todo( stack ) } ) # alias
-      add( 'p->r',    proc { |stack| Rpl::Core.__todo( stack ) } ) # cartesian to polar
-      add( 'p→r',     proc { |stack| Rpl::Core.__todo( stack ) } ) # alias
-      add( 'r->p',    proc { |stack| Rpl::Core.__todo( stack ) } ) # polar to cartesian
-      add( 'r→p',     proc { |stack| Rpl::Core.__todo( stack ) } ) # alias
+        # OPERATIONS ON COMPLEXES
+        add( 're',      proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # complex real part
+        add( 'im',      proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # complex imaginary part
+        add( 'conj',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # complex conjugate
+        add( 'arg',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # complex argument in radians
+        add( 'c->r',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # transform a complex in 2 reals
+        add( 'c→r',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # alias
+        add( 'r->c',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # transform 2 reals in a complex
+        add( 'r→c',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # alias
+        add( 'p->r',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # cartesian to polar
+        add( 'p→r',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # alias
+        add( 'r->p',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # polar to cartesian
+        add( 'r→p',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # alias
 
-      # MODE
-      add( 'std',     proc { |stack| Rpl::Core.__todo( stack ) } ) # standard floating numbers representation. ex: std
-      add( 'fix',     proc { |stack| Rpl::Core.__todo( stack ) } ) # fixed point representation. ex: 6 fix
-      add( 'sci',     proc { |stack| Rpl::Core.__todo( stack ) } ) # scientific floating point representation. ex: 20 sci
-      add( 'prec',    proc { |stack| Rpl::Core.prec( stack ) } )
-      add( 'round',   proc { |stack| Rpl::Core.__todo( stack ) } ) # set float rounding mode. ex: ["nearest", "toward zero", "toward +inf", "toward -inf", "away from zero"] round
-      add( 'default', proc { |stack| Rpl::Core.default( stack ) } )
-      add( 'type',    proc { |stack| Rpl::Core.type( stack ) } )
+        # MODE
+        add( 'std',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # standard floating numbers representation. ex: std
+        add( 'fix',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # fixed point representation. ex: 6 fix
+        add( 'sci',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # scientific floating point representation. ex: 20 sci
+        add( 'prec',    proc { |stack| Rpl::Lang::Core.prec( stack ) } )
+        add( 'round',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # set float rounding mode. ex: ["nearest", "toward zero", "toward +inf", "toward -inf", "away from zero"] round
+        add( 'default', proc { |stack| Rpl::Lang::Core.default( stack ) } )
+        add( 'type',    proc { |stack| Rpl::Lang::Core.type( stack ) } )
 
-      # TEST
-      add( '>',       proc { |stack| Rpl::Core.greater_than( stack ) } )
-      add( '>=',      proc { |stack| Rpl::Core.greater_or_equal_than( stack ) } )
-      add( '≥',       proc { |stack| Rpl::Core.greater_or_equal_than( stack ) } ) # alias
-      add( '<',       proc { |stack| Rpl::Core.less_than( stack ) } )
-      add( '<=',      proc { |stack| Rpl::Core.less_or_equal_than( stack ) } )
-      add( '≤',       proc { |stack| Rpl::Core.less_or_equal_than( stack ) } ) # alias
-      add( '!=',      proc { |stack| Rpl::Core.different( stack ) } )
-      add( '≠',       proc { |stack| Rpl::Core.different( stack ) } ) # alias
-      add( '==',      proc { |stack| Rpl::Core.same( stack ) } ) # alias
-      add( 'and',     proc { |stack| Rpl::Core.and( stack ) } )
-      add( 'or',      proc { |stack| Rpl::Core.or( stack ) } )
-      add( 'xor',     proc { |stack| Rpl::Core.xor( stack ) } )
-      add( 'not',     proc { |stack| Rpl::Core.not( stack ) } )
-      add( 'same',    proc { |stack| Rpl::Core.same( stack ) } )
-      add( 'true',    proc { |stack| Rpl::Core.true( stack ) } ) # specific
-      add( 'false',   proc { |stack| Rpl::Core.false( stack ) } ) # specific
+        # TEST
+        add( '>',       proc { |stack| Rpl::Lang::Core.greater_than( stack ) } )
+        add( '>=',      proc { |stack| Rpl::Lang::Core.greater_or_equal_than( stack ) } )
+        add( '≥',       proc { |stack| Rpl::Lang::Core.greater_or_equal_than( stack ) } ) # alias
+        add( '<',       proc { |stack| Rpl::Lang::Core.less_than( stack ) } )
+        add( '<=',      proc { |stack| Rpl::Lang::Core.less_or_equal_than( stack ) } )
+        add( '≤',       proc { |stack| Rpl::Lang::Core.less_or_equal_than( stack ) } ) # alias
+        add( '!=',      proc { |stack| Rpl::Lang::Core.different( stack ) } )
+        add( '≠',       proc { |stack| Rpl::Lang::Core.different( stack ) } ) # alias
+        add( '==',      proc { |stack| Rpl::Lang::Core.same( stack ) } ) # alias
+        add( 'and',     proc { |stack| Rpl::Lang::Core.and( stack ) } )
+        add( 'or',      proc { |stack| Rpl::Lang::Core.or( stack ) } )
+        add( 'xor',     proc { |stack| Rpl::Lang::Core.xor( stack ) } )
+        add( 'not',     proc { |stack| Rpl::Lang::Core.not( stack ) } )
+        add( 'same',    proc { |stack| Rpl::Lang::Core.same( stack ) } )
+        add( 'true',    proc { |stack| Rpl::Lang::Core.true( stack ) } ) # specific
+        add( 'false',   proc { |stack| Rpl::Lang::Core.false( stack ) } ) # specific
 
-      # STRING
-      add( '->str',   proc { |stack| Rpl::Core.to_string( stack ) } )
-      add( '→str',    proc { |stack| Rpl::Core.to_string( stack ) } ) # alias
-      add( 'str->',   proc { |stack| Rpl::Core.from_string( stack ) } )
-      add( 'str→',    proc { |stack| Rpl::Core.from_string( stack ) } ) # alias
-      add( 'chr',     proc { |stack| Rpl::Core.chr( stack ) } )
-      add( 'num',     proc { |stack| Rpl::Core.num( stack ) } )
-      add( 'size',    proc { |stack| Rpl::Core.size( stack ) } )
-      add( 'pos',     proc { |stack| Rpl::Core.pos( stack ) } )
-      add( 'sub',     proc { |stack| Rpl::Core.sub( stack ) } )
+        # STRING
+        add( '->str',   proc { |stack| Rpl::Lang::Core.to_string( stack ) } )
+        add( '→str',    proc { |stack| Rpl::Lang::Core.to_string( stack ) } ) # alias
+        add( 'str->',   proc { |stack| Rpl::Lang::Core.from_string( stack ) } )
+        add( 'str→',    proc { |stack| Rpl::Lang::Core.from_string( stack ) } ) # alias
+        add( 'chr',     proc { |stack| Rpl::Lang::Core.chr( stack ) } )
+        add( 'num',     proc { |stack| Rpl::Lang::Core.num( stack ) } )
+        add( 'size',    proc { |stack| Rpl::Lang::Core.size( stack ) } )
+        add( 'pos',     proc { |stack| Rpl::Lang::Core.pos( stack ) } )
+        add( 'sub',     proc { |stack| Rpl::Lang::Core.sub( stack ) } )
 
-      # BRANCH
-      add( 'if',      proc { |stack| Rpl::Core.__todo( stack ) } ) # if <test-instruction> then <true-instructions> else <false-instructions> end
-      add( 'then',    proc { |stack| Rpl::Core.__todo( stack ) } ) # used with if
-      add( 'else',    proc { |stack| Rpl::Core.__todo( stack ) } ) # used with if
-      add( 'end',     proc { |stack| Rpl::Core.__todo( stack ) } ) # used with various branch instructions
-      add( 'start',   proc { |stack| Rpl::Core.__todo( stack ) } ) # <start> <end> start <instructions> next|<step> step
-      add( 'for',     proc { |stack| Rpl::Core.__todo( stack ) } ) # <start> <end> for <variable> <instructions> next|<step> step
-      add( 'next',    proc { |stack| Rpl::Core.__todo( stack ) } ) # used with start and for
-      add( 'step',    proc { |stack| Rpl::Core.__todo( stack ) } ) # used with start and for
-      add( 'ift',     proc { |stack| Rpl::Core.ift( stack, self ) } )
-      add( 'ifte',    proc { |stack| Rpl::Core.ifte( stack, self ) } )
-      add( 'do',      proc { |stack| Rpl::Core.__todo( stack ) } ) # do <instructions> until <condition> end
-      add( 'until',   proc { |stack| Rpl::Core.__todo( stack ) } ) # used with do
-      add( 'while',   proc { |stack| Rpl::Core.__todo( stack ) } ) # while <test-instruction> repeat <loop-instructions> end
-      add( 'repeat',  proc { |stack| Rpl::Core.__todo( stack ) } ) # used with while
+        # BRANCH
+        add( 'if',      proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # if <test-instruction> then <true-instructions> else <false-instructions> end
+        add( 'then',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # used with if
+        add( 'else',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # used with if
+        add( 'end',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # used with various branch instructions
+        add( 'start',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # <start> <end> start <instructions> next|<step> step
+        add( 'for',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # <start> <end> for <variable> <instructions> next|<step> step
+        add( 'next',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # used with start and for
+        add( 'step',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # used with start and for
+        add( 'ift',     proc { |stack| Rpl::Lang::Core.ift( stack, self ) } )
+        add( 'ifte',    proc { |stack| Rpl::Lang::Core.ifte( stack, self ) } )
+        add( 'do',      proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # do <instructions> until <condition> end
+        add( 'until',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # used with do
+        add( 'while',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # while <test-instruction> repeat <loop-instructions> end
+        add( 'repeat',  proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # used with while
 
-      # STORE
-      add( 'sto',     proc { |stack| Rpl::Core.__todo( stack ) } ) # store a variable. ex: 1 'name' sto
-      add( '▶',       proc { |stack| Rpl::Core.sto( stack ) } ) # alias
-      add( 'rcl',     proc { |stack| Rpl::Core.__todo( stack ) } ) # recall a variable. ex: 'name' rcl
-      add( 'purge',   proc { |stack| Rpl::Core.__todo( stack ) } ) # delete a variable. ex: 'name' purge
-      add( 'vars',    proc { |stack| Rpl::Core.__todo( stack ) } ) # list all variables
-      add( 'clusr',   proc { |stack| Rpl::Core.__todo( stack ) } ) # erase all variables
-      add( 'edit',    proc { |stack| Rpl::Core.__todo( stack ) } ) # edit a variable content
-      add( 'sto+',    proc { |stack| Rpl::Core.__todo( stack ) } ) # add to a stored variable. ex: 1 'name' sto+ 'name' 2 sto+
-      add( 'sto-',    proc { |stack| Rpl::Core.__todo( stack ) } ) # substract to a stored variable. ex: 1 'name' sto- 'name' 2 sto-
-      add( 'sto*',    proc { |stack| Rpl::Core.__todo( stack ) } ) # multiply a stored variable. ex: 3 'name' sto* 'name' 2 sto*
-      add( 'sto/',    proc { |stack| Rpl::Core.__todo( stack ) } ) # divide a stored variable. ex: 3 'name' sto/ 'name' 2 sto/
-      add( 'sneg',    proc { |stack| Rpl::Core.__todo( stack ) } ) # negate a variable. ex: 'name' sneg
-      add( 'sinv',    proc { |stack| Rpl::Core.__todo( stack ) } ) # inverse a variable. ex: 1 'name' sinv
+        # STORE
+        add( 'sto',     proc { |stack| Rpl::Lang::Core.sto( stack ) } ) # store a variable. ex: 1 'name' sto
+        add( '▶',       proc { |stack| Rpl::Lang::Core.sto( stack ) } ) # alias
+        add( 'rcl',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # recall a variable. ex: 'name' rcl
+        add( 'purge',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # delete a variable. ex: 'name' purge
+        add( 'vars',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # list all variables
+        add( 'clusr',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # erase all variables
+        add( 'edit',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # edit a variable content
+        add( 'sto+',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # add to a stored variable. ex: 1 'name' sto+ 'name' 2 sto+
+        add( 'sto-',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # substract to a stored variable. ex: 1 'name' sto- 'name' 2 sto-
+        add( 'sto*',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # multiply a stored variable. ex: 3 'name' sto* 'name' 2 sto*
+        add( 'sto/',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # divide a stored variable. ex: 3 'name' sto/ 'name' 2 sto/
+        add( 'sneg',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # negate a variable. ex: 'name' sneg
+        add( 'sinv',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # inverse a variable. ex: 1 'name' sinv
 
-      # PROGRAM
-      add( 'eval',    proc { |stack| Rpl::Core.eval( stack, self ) } )
-      add( '->',      proc { |stack| Rpl::Core.__todo( stack ) } ) # load program local variables. ex: << -> n m << 0 n m for i i + next >> >>
-      add( '→',       proc { |stack| Rpl::Core.__todo( stack ) } ) # alias
+        # PROGRAM
+        add( 'eval',    proc { |stack| Rpl::Lang::Core.eval( stack, self ) } )
+        add( '->',      proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # load program local variables. ex: << -> n m << 0 n m for i i + next >> >>
+        add( '→',       proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # alias
 
-      # TRIG ON REALS AND COMPLEXES
-      add( 'pi',      proc { |stack| Rpl::Core.pi( stack ) } )
-      add( '𝛑',       proc { |stack| Rpl::Core.pi( stack ) } )     # alias
-      add( 'sin',     proc { |stack| Rpl::Core.__todo( stack ) } ) # sinus
-      add( 'asin',    proc { |stack| Rpl::Core.__todo( stack ) } ) # arg sinus
-      add( 'cos',     proc { |stack| Rpl::Core.__todo( stack ) } ) # cosinus
-      add( 'acos',    proc { |stack| Rpl::Core.__todo( stack ) } ) # arg cosinus
-      add( 'tan',     proc { |stack| Rpl::Core.__todo( stack ) } ) # tangent
-      add( 'atan',    proc { |stack| Rpl::Core.__todo( stack ) } ) # arg tangent
-      add( 'd->r',    proc { |stack| Rpl::Core.__todo( stack ) } ) # convert degrees to radians
-      add( 'd→r',     proc { |stack| Rpl::Core.__todo( stack ) } ) # alias
-      add( 'r->d',    proc { |stack| Rpl::Core.__todo( stack ) } ) # convert radians to degrees
-      add( 'r→d',     proc { |stack| Rpl::Core.__todo( stack ) } ) # alias
+        # TRIG ON REALS AND COMPLEXES
+        add( 'pi',      proc { |stack| Rpl::Lang::Core.pi( stack ) } )
+        add( '𝛑',       proc { |stack| Rpl::Lang::Core.pi( stack ) } )     # alias
+        add( 'sin',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # sinus
+        add( 'asin',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # arg sinus
+        add( 'cos',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # cosinus
+        add( 'acos',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # arg cosinus
+        add( 'tan',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # tangent
+        add( 'atan',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # arg tangent
+        add( 'd->r',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # convert degrees to radians
+        add( 'd→r',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # alias
+        add( 'r->d',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # convert radians to degrees
+        add( 'r→d',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # alias
 
-      # LOGS ON REALS AND COMPLEXES
-      add( 'e',       proc { |stack| Rpl::Core.e( stack ) } )
-      add( 'ℇ',       proc { |stack| Rpl::Core.e( stack ) } ) # alias
-      add( 'ln',      proc { |stack| Rpl::Core.__todo( stack ) } ) # logarithm base e
-      add( 'lnp1',    proc { |stack| Rpl::Core.__todo( stack ) } ) # ln(1+x) which is useful when x is close to 0
-      add( 'exp',     proc { |stack| Rpl::Core.__todo( stack ) } ) # exponential
-      add( 'expm',    proc { |stack| Rpl::Core.__todo( stack ) } ) # exp(x)-1 which is useful when x is close to 0
-      add( 'log10',   proc { |stack| Rpl::Core.__todo( stack ) } ) # logarithm base 10
-      add( 'alog10',  proc { |stack| Rpl::Core.__todo( stack ) } ) # exponential base 10
-      add( 'log2',    proc { |stack| Rpl::Core.__todo( stack ) } ) # logarithm base 2
-      add( 'alog2',   proc { |stack| Rpl::Core.__todo( stack ) } ) # exponential base 2
-      add( 'sinh',    proc { |stack| Rpl::Core.__todo( stack ) } ) # hyperbolic sine
-      add( 'asinh',   proc { |stack| Rpl::Core.__todo( stack ) } ) # inverse hyperbolic sine
-      add( 'cosh',    proc { |stack| Rpl::Core.__todo( stack ) } ) # hyperbolic cosine
-      add( 'acosh',   proc { |stack| Rpl::Core.__todo( stack ) } ) # inverse hyperbolic cosine
-      add( 'tanh',    proc { |stack| Rpl::Core.__todo( stack ) } ) # hyperbolic tangent
-      add( 'atanh',   proc { |stack| Rpl::Core.__todo( stack ) } ) # inverse hyperbolic tangent
+        # LOGS ON REALS AND COMPLEXES
+        add( 'e',       proc { |stack| Rpl::Lang::Core.e( stack ) } )
+        add( 'ℇ',       proc { |stack| Rpl::Lang::Core.e( stack ) } ) # alias
+        add( 'ln',      proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # logarithm base e
+        add( 'lnp1',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # ln(1+x) which is useful when x is close to 0
+        add( 'exp',     proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # exponential
+        add( 'expm',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # exp(x)-1 which is useful when x is close to 0
+        add( 'log10',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # logarithm base 10
+        add( 'alog10',  proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # exponential base 10
+        add( 'log2',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # logarithm base 2
+        add( 'alog2',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # exponential base 2
+        add( 'sinh',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # hyperbolic sine
+        add( 'asinh',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # inverse hyperbolic sine
+        add( 'cosh',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # hyperbolic cosine
+        add( 'acosh',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # inverse hyperbolic cosine
+        add( 'tanh',    proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # hyperbolic tangent
+        add( 'atanh',   proc { |stack| Rpl::Lang::Core.__todo( stack ) } ) # inverse hyperbolic tangent
 
-      # TIME AND DATE
-      add( 'time',    proc { |stack| Rpl::Core.time( stack ) } )
-      add( 'date',    proc { |stack| Rpl::Core.date( stack ) } )
-      add( 'ticks',   proc { |stack| Rpl::Core.ticks( stack ) } )
+        # TIME AND DATE
+        add( 'time',    proc { |stack| Rpl::Lang::Core.time( stack ) } )
+        add( 'date',    proc { |stack| Rpl::Lang::Core.date( stack ) } )
+        add( 'ticks',   proc { |stack| Rpl::Lang::Core.ticks( stack ) } )
+      end
+
+      def add( name, implementation )
+        @words[ name ] = implementation
+      end
+
+      def lookup( name )
+        @words[ name ] if @words.include?( name )
+      end
+
+      # TODO: alias
     end
-
-    def add( name, implementation )
-      @words[ name ] = implementation
-    end
-
-    def lookup( name )
-      @words[ name ] if @words.include?( name )
-    end
-
-    # TODO: alias
   end
 end

lib/language/branch.rb

@@ -1,19 +0,0 @@
-module Rpl
-  module Core
-    module_function
-
-    # similar to if-then-end, <test-instruction> <true-instruction> ift
-    def ift( stack, dictionary )
-      ifte( stack << { type: :word, value: 'nop' }, dictionary )
-    end
-
-    # similar to if-then-else-end, <test-instruction> <true-instruction> <false-instruction> ifte
-    def ifte( stack, dictionary )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[program word], %i[program word], %i[boolean]] )
-
-      stack << args[ args[2][:value] ? 1 : 0 ]
-
-      Rpl::Core.eval( stack, dictionary )
-    end
-  end
-end

lib/language/general.rb

@@ -1,10 +0,0 @@
-module Rpl
-  module Core
-    module_function
-
-    # no operation
-    def nop( stack )
-      stack
-    end
-  end
-end

lib/language/mode.rb

@@ -1,31 +0,0 @@
-module Rpl
-  module Core
-    module_function
-
-    # set float precision in bits. ex: 256 prec
-    def prec( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-
-      Rpl::Core.precision = args[0][:value]
-
-      stack
-    end
-
-    # set float representation and precision to default
-    def default( stack )
-      Rpl::Core.precision = 12
-
-      stack
-    end
-
-    # show type of stack first entry
-    def type( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [:any] )
-
-      stack << args[0]
-      stack << { type: :string,
-                 value: args[0][:type].to_s }
-      stack
-    end
-  end
-end

lib/language/operations.rb

@@ -1,242 +0,0 @@
-module Rpl
-  module Core
-    module_function
-
-    # addition
-    def add( stack )
-      addable = %i[numeric string name]
-      stack, args = Rpl::Core.stack_extract( stack, [addable, addable] )
-
-      result = { type: case args[1][:type]
-                       when :name
-                         :name
-                       when :string
-                         :string
-                       when :numeric
-                         if args[0][:type] == :numeric
-                           :numeric
-                         else
-                           :string
-                         end
-                       end }
-
-      args.each do |elt|
-        elt[:value] = elt[:value][1..-2] unless elt[:type] == :numeric
-      end
-
-      result[:value] = case result[:type]
-                       when :name
-                         "'#{args[1][:value]}#{args[0][:value]}'"
-                       when :string
-                         "\"#{args[1][:value]}#{args[0][:value]}\""
-                       when :numeric
-                         args[1][:value] + args[0][:value]
-                       end
-
-      result[:base] = 10 if result[:type] == :numeric # TODO: what if operands have other bases ?
-
-      stack << result
-    end
-
-    # substraction
-    def subtract( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
-
-      stack << { type: :numeric, base: 10,
-                 value: args[1][:value] - args[0][:value] }
-    end
-
-    # negation
-    def negate( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-
-      stack << { type: :numeric, base: 10,
-                 value: args[0][:value] * -1 }
-    end
-
-    # multiplication
-    def multiply( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
-
-      stack << { type: :numeric, base: 10,
-                 value: args[1][:value] * args[0][:value] }
-    end
-
-    # division
-    def divide( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
-
-      raise 'Division by 0' if args[0][:value].zero?
-
-      stack << { type: :numeric, base: 10,
-                 value: args[1][:value] / args[0][:value] }
-    end
-
-    # inverse
-    def inverse( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-
-      raise 'Division by 0' if args[0][:value].zero?
-
-      stack << { type: :numeric, base: 10,
-                 value: 1.0 / args[0][:value] }
-    end
-
-    # power
-    def power( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
-
-      stack << { type: :numeric, base: 10,
-                 value: args[1][:value]**args[0][:value] }
-    end
-
-    # rpn_square root
-    def sqrt( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-
-      stack << { type: :numeric, base: 10,
-                 value: BigMath.sqrt( BigDecimal( args[0][:value] ), Rpl::Core.precision ) }
-    end
-
-    # rpn_square
-    def sq( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-
-      stack << { type: :numeric, base: 10,
-                 value: args[0][:value] * args[0][:value] }
-    end
-
-    # absolute value
-    def abs( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-
-      stack << { type: :numeric, base: 10,
-                 value: args[0][:value].abs }
-    end
-
-    # decimal representation
-    def dec( stack )
-      base( stack << { type: :numeric, base: 10, value: 10 } )
-    end
-
-    # hexadecimal representation
-    def hex( stack )
-      base( stack << { type: :numeric, base: 10, value: 16 } )
-    end
-
-    # binary representation
-    def bin( stack )
-      base( stack << { type: :numeric, base: 10, value: 2 } )
-    end
-
-    # arbitrary base representation
-    def base( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
-
-      args[1][:base] = args[0][:value]
-
-      stack << args[1]
-    end
-
-    # 1 if number at stack level 1 is > 0, 0 if == 0, -1 if <= 0
-    def sign( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-      value = if args[0][:value].positive?
-                1
-              elsif args[0][:value].negative?
-                -1
-              else
-                0
-              end
-
-      stack << { type: :numeric, base: 10,
-                 value: value }
-    end
-
-    # OPERATIONS ON REALS
-
-    # percent
-    def percent( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
-
-      stack << { type: :numeric,
-                 base: 10,
-                 value: args[0][:value] * ( args[1][:value] / 100.0 ) }
-
-      stack
-    end
-
-    # inverse percent
-    def inverse_percent( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
-
-      stack << { type: :numeric,
-                 base: 10,
-                 value: 100.0 * ( args[0][:value] / args[1][:value] ) }
-
-      stack
-    end
-
-    # modulo
-    def mod( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
-
-      stack << { type: :numeric,
-                 base: 10,
-                 value: args[1][:value] % args[0][:value] }
-
-      stack
-    end
-
-    # n! for integer n or Gamma(x+1) for fractional x
-    def fact( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-
-      stack << { type: :numeric,
-                 base: 10,
-                 value: Math.gamma( args[0][:value] ) }
-
-      stack
-    end
-
-    # largest number <=
-    def floor( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-
-      stack << { type: :numeric,
-                 base: 10,
-                 value: args[0][:value].floor }
-
-      stack
-    end
-
-    # smallest number >=
-    def ceil( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-
-      stack << { type: :numeric,
-                 base: 10,
-                 value: args[0][:value].ceil }
-
-      stack
-    end
-
-    # min of 2 real numbers
-    def min( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
-
-      stack << ( args[0][:value] < args[1][:value] ? args[0] : args[1] )
-
-      stack
-    end
-
-    # max of 2 real numbers
-    def max( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric]] )
-
-      stack << ( args[0][:value] > args[1][:value] ? args[0] : args[1] )
-
-      stack
-    end
-  end
-end

lib/language/program.rb

@@ -1,19 +0,0 @@
-module Rpl
-  module Core
-    module_function
-
-    # evaluate (run) a program, or recall a variable. ex: 'my_prog' eval
-    def eval( stack, dictionary )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[program word name]] )
-
-      # we trim enclosing «»
-      preparsed_input = args[0][:type] == :word ? args[0][:value] : args[0][:value][1..-2]
-      parsed_input = Rpl::Parser.new.parse_input( preparsed_input )
-
-      stack, _dictionary = Rpl::Runner.new.run_input( stack, dictionary, parsed_input )
-      # TODO: check that STO actually updates dictionary
-
-      stack
-    end
-  end
-end

lib/language/stack.rb

@@ -1,128 +0,0 @@
-module Rpl
-  module Core
-    module_function
-
-    # swap 2 first stack entries
-    def swap( stack )
-      stack, args = Rpl::Core.stack_extract( stack, %i[any any] )
-
-      stack << args[0] << args[1]
-    end
-
-    # drop first stack entry
-    def drop( stack )
-      dropn( stack << { type: :numeric, base: 10, value: 1 } )
-    end
-
-    # drop 2 first stack entries
-    def drop2( stack )
-      dropn( stack << { type: :numeric, base: 10, value: 2 } )
-    end
-
-    # drop n first stack entries
-    def dropn( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-      stack, _args = Rpl::Core.stack_extract( stack, %i[any] * args[0][:value] )
-
-      stack
-    end
-
-    # drop all stack entries
-    def del( _stack )
-      []
-    end
-
-    # rotate 3 first stack entries
-    def rot( stack )
-      stack, args = Rpl::Core.stack_extract( stack, %i[any any any] )
-
-      stack << args[1] << args[0] << args[2]
-    end
-
-    # duplicate first stack entry
-    def dup( stack )
-      dupn( stack << { type: :numeric, base: 10, value: 1 } )
-    end
-
-    # duplicate 2 first stack entries
-    def dup2( stack )
-      dupn( stack << { type: :numeric, base: 10, value: 2 } )
-    end
-
-    # duplicate n first stack entries
-    def dupn( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-      n = args[0][:value]
-      stack, args = Rpl::Core.stack_extract( stack, %i[any] * args[0][:value] )
-
-      args.reverse!
-
-      2.times do
-        n.times.each do |i|
-          stack << args[ i ]
-        end
-      end
-
-      stack
-    end
-
-    # push a copy of the given stack level onto the stack
-    def pick( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-      n = args[0][:value]
-      stack, args = Rpl::Core.stack_extract( stack, %i[any] * args[0][:value] )
-
-      args.reverse!
-
-      n.times.each do |i|
-        stack << args[ i ]
-      end
-      stack << args[0]
-
-      stack
-    end
-
-    # give stack depth
-    def depth( stack )
-      stack << { type: :numeric, base: 10, value: stack.size }
-    end
-
-    # move a stack entry to the top of the stack
-    def roll( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-      n = args[0][:value]
-      stack, args = Rpl::Core.stack_extract( stack, %i[any] * args[0][:value] )
-
-      args.reverse!
-
-      (1..(n - 1)).each do |i|
-        stack << args[ i ]
-      end
-      stack << args[0]
-
-      stack
-    end
-
-    # move the element on top of the stack to a higher stack position
-    def rolld( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-      n = args[0][:value]
-      stack, args = Rpl::Core.stack_extract( stack, %i[any] * args[0][:value] )
-
-      args.reverse!
-
-      stack << args[n - 1]
-
-      (0..(n - 2)).each do |i|
-        stack << args[ i ]
-      end
-
-      stack
-    end
-
-    # push a copy of the element in stack level 2 onto the stack
-    def over( stack )
-      pick( stack << { type: :numeric, base: 10, value: 2 } )
-    end
-  end
-end

lib/language/string.rb

@@ -1,65 +0,0 @@
-module Rpl
-  module Core
-    module_function
-
-    # convert an object into a string
-    def to_string( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [:any] )
-
-      stack << { type: :string,
-                 value: args[0][:value].to_s }
-    end
-
-    # convert a string into an object
-    def from_string( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[string]] )
-
-      parsed_input = Rpl::Parser.new.parse_input( args[0][:value] )
-
-      stack + parsed_input
-    end
-
-    # convert ASCII character code in stack level 1 into a string
-    def chr( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric]] )
-
-      stack << { type: :string,
-                 value: args[0][:value].chr }
-    end
-
-    # return ASCII code of the first character of the string in stack level 1 as a real number
-    def num( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[string]] )
-
-      stack << { type: :numeric,
-                 base: 10,
-                 value: args[0][:value].ord }
-    end
-
-    # return the length of the string
-    def size( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[string]] )
-
-      stack << { type: :numeric,
-                 base: 10,
-                 value: args[0][:value].length }
-    end
-
-    # search for the string in level 1 within the string in level 2
-    def pos( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[string], %i[string]] )
-
-      stack << { type: :numeric,
-                 base: 10,
-                 value: args[1][:value].index( args[0][:value] ) }
-    end
-
-    # return a substring of the string in level 3
-    def sub( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[numeric], %i[numeric], %i[string]] )
-
-      stack << { type: :string,
-                 value: args[2][:value][args[1][:value]..args[0][:value]] }
-    end
-  end
-end

lib/language/test.rb

@@ -1,109 +0,0 @@
-module Rpl
-  module Core
-    module_function
-
-    # binary operator >
-    def greater_than( stack )
-      stack, args = Rpl::Core.stack_extract( stack, %i[any any] )
-
-      stack << { type: :boolean,
-                 value: args[1][:value] > args[0][:value] }
-      stack
-    end
-
-    # binary operator >=
-    def greater_or_equal_than( stack )
-      stack, args = Rpl::Core.stack_extract( stack, %i[any any] )
-
-      stack << { type: :boolean,
-                 value: args[1][:value] >= args[0][:value] }
-      stack
-    end
-
-    # binary operator <
-    def less_than( stack )
-      stack, args = Rpl::Core.stack_extract( stack, %i[any any] )
-
-      stack << { type: :boolean,
-                 value: args[1][:value] < args[0][:value] }
-      stack
-    end
-
-    # binary operator <=
-    def less_or_equal_than( stack )
-      stack, args = Rpl::Core.stack_extract( stack, %i[any any] )
-
-      stack << { type: :boolean,
-                 value: args[1][:value] <= args[0][:value] }
-      stack
-    end
-
-    # boolean operator != (different)
-    def different( stack )
-      stack, args = Rpl::Core.stack_extract( stack, %i[any any] )
-
-      stack << { type: :boolean,
-                 value: args[1][:value] != args[0][:value] }
-      stack
-    end
-
-    # boolean operator and
-    def and( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[boolean], %i[boolean]] )
-
-      stack << { type: :boolean,
-                 value: args[1][:value] && args[0][:value] }
-      stack
-    end
-
-    # boolean operator or
-    def or( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[boolean], %i[boolean]] )
-
-      stack << { type: :boolean,
-                 value: args[1][:value] || args[0][:value] }
-      stack
-    end
-
-    # boolean operator xor
-    def xor( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[boolean], %i[boolean]] )
-
-      stack << { type: :boolean,
-                 value: args[1][:value] ^ args[0][:value] }
-      stack
-    end
-
-    # boolean operator not
-    def not( stack )
-      stack, args = Rpl::Core.stack_extract( stack, [%i[boolean]] )
-
-      stack << { type: :boolean,
-                 value: !args[0][:value] }
-      stack
-    end
-
-    # boolean operator same (equal)
-    def same( stack )
-      stack, args = Rpl::Core.stack_extract( stack, %i[any any] )
-
-      stack << { type: :boolean,
-                 value: args[1][:value] == args[0][:value] }
-      stack
-    end
-
-    # true boolean
-    def true( stack )
-      stack << { type: :boolean,
-                 value: true }
-      stack
-    end
-
-    # false boolean
-    def false( stack )
-      stack << { type: :boolean,
-                 value: false }
-      stack
-    end
-  end
-end

lib/language/time-date.rb

@@ -1,28 +0,0 @@
-require 'date'
-
-module Rpl
-  module Core
-    module_function
-
-    # time in local format
-    def time( stack )
-      stack << { type: :string,
-                 value: Time.now.to_s }
-    end
-
-    # date in local format
-    def date( stack )
-      stack << { type: :string,
-                 value: Date.today.to_s }
-    end
-
-    # system tick in µs
-    def ticks( stack )
-      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

lib/parser.rb

@@ -1,88 +1,90 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Rpl
-  class Parser
-    def initialize; end
+  module Lang
+    class Parser
+      def initialize; end
 
-    def numeric?( elt )
-      !Float(elt).nil?
-    rescue ArgumentError
-      begin
-        !Integer(elt).nil?
+      def numeric?( elt )
+        !Float(elt).nil?
       rescue ArgumentError
-        false
-      end
-    end
-
-    def parse_input( input )
-      splitted_input = input.split(' ')
-
-      # 2-passes:
-      # 1. regroup strings and programs
-      opened_programs = 0
-      closed_programs = 0
-      string_delimiters = 0
-      regrouping = false
-
-      regrouped_input = []
-      splitted_input.each do |elt|
-        # TODO: handle buried-in-elt « and » (surround by ' ' and re-split)
-        if elt[0] == '«'
-          opened_programs += 1
-          elt.gsub!( '«', '« ') if elt.length > 1 && elt[1] != ' '
+        begin
+          !Integer(elt).nil?
+        rescue ArgumentError
+          false
         end
-        string_delimiters += 1 if elt[0] == '"'
-
-        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.length > 1 && elt[-1] == '"'
-
-        regrouping = string_delimiters.odd? || (opened_programs > closed_programs )
       end
 
-      # 2. parse
-      parsed_tree = []
-      regrouped_input.each do |elt|
-        parsed_entry = { value: elt }
+      def parse_input( input )
+        splitted_input = input.split(' ')
 
-        opened_programs += 1 if elt[0] == '«'
-        string_delimiters += 1 if elt[0] == '"'
+        # 2-passes:
+        # 1. regroup strings and programs
+        opened_programs = 0
+        closed_programs = 0
+        string_delimiters = 0
+        regrouping = false
 
-        parsed_entry[:type] = case elt[0]
-                              when '«'
-                                :program
-                              when '"'
-                                :string
-                              when "'"
-                                :name # TODO: check for forbidden space
-                              else
-                                if numeric?( elt )
-                                  :numeric
-                                else
-                                  :word
-                                end
-                              end
-
-        if parsed_entry[:type] == :numeric
-          parsed_entry[:base] = 10 # TODO: parse others possible bases 0x...
-
-          begin
-            parsed_entry[:value] = Float( parsed_entry[:value] )
-          rescue ArgumentError
-            parsed_entry[:value] = Integer( parsed_entry[:value] )
+        regrouped_input = []
+        splitted_input.each do |elt|
+          # TODO: handle buried-in-elt « and » (surround by ' ' and re-split)
+          if elt[0] == '«'
+            opened_programs += 1
+            elt.gsub!( '«', '« ') if elt.length > 1 && elt[1] != ' '
           end
+          string_delimiters += 1 if elt[0] == '"'
+
+          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.length > 1 && elt[-1] == '"'
+
+          regrouping = string_delimiters.odd? || (opened_programs > closed_programs )
         end
 
-        parsed_tree << parsed_entry
-      end
+        # 2. parse
+        parsed_tree = []
+        regrouped_input.each do |elt|
+          parsed_entry = { value: elt }
 
-      parsed_tree
+          opened_programs += 1 if elt[0] == '«'
+          string_delimiters += 1 if elt[0] == '"'
+
+          parsed_entry[:type] = case elt[0]
+                                when '«'
+                                  :program
+                                when '"'
+                                  :string
+                                when "'"
+                                  :name # TODO: check for forbidden space
+                                else
+                                  if numeric?( elt )
+                                    :numeric
+                                  else
+                                    :word
+                                  end
+                                end
+
+          if parsed_entry[:type] == :numeric
+            parsed_entry[:base] = 10 # TODO: parse others possible bases 0x...
+
+            begin
+              parsed_entry[:value] = Float( parsed_entry[:value] )
+            rescue ArgumentError
+              parsed_entry[:value] = Integer( parsed_entry[:value] )
+            end
+          end
+
+          parsed_tree << parsed_entry
+        end
+
+        parsed_tree
+      end
     end
   end
 end

lib/runner.rb

@@ -1,26 +1,28 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 module Rpl
-  class Runner
-    def initialize; end
+  module Lang
+    class Runner
+      def initialize; end
 
-    def run_input( stack, dictionary, input )
-      input.each do |elt|
-        case elt[:type]
-        when :word
-          command = dictionary.lookup( elt[:value] )
+      def run_input( input, stack, dictionary )
+        input.each do |elt|
+          case elt[:type]
+          when :word
+            command = dictionary.lookup( elt[:value] )
 
-          if command.nil?
-            stack << { type: :name, value: "'#{elt[:value]}'" }
+            if command.nil?
+              stack << { type: :name, value: "'#{elt[:value]}'" }
+            else
+              stack = command.call( stack )
+            end
           else
-            stack = command.call( stack )
+            stack << elt
           end
-        else
-          stack << elt
         end
-      end
 
-      [stack, dictionary]
+        [stack, dictionary]
+      end
     end
   end
 end

repl.rb

@@ -1,72 +1,62 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 require 'readline'
 
-require './lib/core'
-require './lib/dictionary'
-require './lib/parser'
-require './lib/runner'
+require './language'
 
-module Rpl
-  class Repl
-    def initialize
-      @stack = []
-      @dictionary = Dictionary.new
-      @parser = Parser.new
-      @runner = Runner.new
+class RplRepl
+  def initialize
+    @lang = Rpl::Language.new
+  end
+
+  def run
+    Readline.completion_proc = proc do |s|
+      Readline::HISTORY.grep(/^#{Regexp.escape(s)}/)
+    end
+    Readline.completion_append_character = ' '
+
+    loop do
+      input = Readline.readline( ' ', true )
+      break if input.nil? || input == 'quit'
+
+      pp Readline::HISTORY if input == 'history'
+
+      input = '"rpn.rb version 0.0"' if %w[version uname].include?( input )
+
+      # Remove blank lines from history
+      Readline::HISTORY.pop if input.empty?
+
+      @lang.run( input )
+
+      print_stack
+    end
+  end
+
+  def format_element( elt )
+    if elt[:type] == :numeric && elt[:base] != 10
+      prefix = case elt[:base]
+               when 2
+                 '0b'
+               when 8
+                 '0o'
+               when 16
+                 '0x'
+               else
+                 "0#{elt[:base]}_"
+               end
+      return "#{prefix}#{elt[:value].to_s( elt[:base] )}"
     end
 
-    def run
-      Readline.completion_proc = proc do |s|
-        Readline::HISTORY.grep(/^#{Regexp.escape(s)}/)
-      end
-      Readline.completion_append_character = ' '
+    elt[:value]
+  end
 
-      loop do
-        input = Readline.readline( ' ', true )
-        break if input.nil? || input == 'quit'
+  def print_stack
+    stack_size = @lang.stack.size
 
-        pp Readline::HISTORY if input == 'history'
-
-        input = '"rpn.rb version 0.0"' if %w[version uname].include?( input )
-
-        # Remove blank lines from history
-        Readline::HISTORY.pop if input.empty?
-
-        @stack, @dictionary = @runner.run_input( @stack, @dictionary,
-                                                 @parser.parse_input( input ) )
-
-        print_stack
-      end
-    end
-
-    def format_element( elt )
-      if elt[:type] == :numeric && elt[:base] != 10
-        prefix = case elt[:base]
-                 when 2
-                   '0b'
-                 when 8
-                   '0o'
-                 when 16
-                   '0x'
-                 else
-                   "0#{elt[:base]}_"
-                 end
-        return "#{prefix}#{elt[:value].to_s( elt[:base] )}"
-      end
-
-      elt[:value]
-    end
-
-    def print_stack
-      stack_size = @stack.size
-
-      @stack.each_with_index do |elt, i|
-        puts "#{stack_size - i}: #{format_element( elt )}"
-      end
+    @lang.stack.each_with_index do |elt, i|
+      puts "#{stack_size - i}: #{format_element( elt )}"
     end
   end
 end
 
-Rpl::Repl.new.run
+RplRepl.new.run

spec/core_spec.rb

@@ -7,17 +7,17 @@ require_relative '../lib/core'
 
 class TestParser < Test::Unit::TestCase
   def test_stack_extract
-    stack, args = Rpl::Core.stack_extract [{ value: 1, type: :numeric },
-                                           { value: 2, type: :numeric }],
-                                          [:any]
+    stack, args = Rpl::Lang::Core.stack_extract [{ value: 1, type: :numeric },
+                                                 { value: 2, type: :numeric }],
+                                                [:any]
     assert_equal [{ value: 1, type: :numeric }],
                  stack
     assert_equal [{ value: 2, type: :numeric }],
                  args
 
-    stack, args = Rpl::Core.stack_extract [{ value: 'test', type: :string },
-                                           { value: 2, type: :numeric }],
-                                          [[:numeric], :any]
+    stack, args = Rpl::Lang::Core.stack_extract [{ value: 'test', type: :string },
+                                                 { value: 2, type: :numeric }],
+                                                [[:numeric], :any]
     assert_equal [],
                  stack
     assert_equal [{ value: 2, type: :numeric },

spec/language_branch_spec.rb

@@ -10,18 +10,18 @@ require_relative '../lib/runner'
 
 class TestLanguageBranch < Test::Unit::TestCase
   def test_ifte
-    stack = Rpl::Core.ifte( [{ type: :boolean, value: true },
-                             { type: :program, value: '« 2 3 + »' },
-                             { type: :program, value: '« 2 3 - »' }],
-                            Rpl::Dictionary.new )
+    stack = Rpl::Lang::Core.ifte( [{ type: :boolean, value: true },
+                                   { type: :program, value: '« 2 3 + »' },
+                                   { type: :program, value: '« 2 3 - »' }],
+                                  Rpl::Lang::Dictionary.new )
 
     assert_equal [{ value: 5, type: :numeric, base: 10 }],
                  stack
 
-    stack = Rpl::Core.ifte( [{ type: :boolean, value: false },
-                             { type: :program, value: '« 2 3 + »' },
-                             { type: :program, value: '« 2 3 - »' }],
-                            Rpl::Dictionary.new )
+    stack = Rpl::Lang::Core.ifte( [{ type: :boolean, value: false },
+                                   { type: :program, value: '« 2 3 + »' },
+                                   { type: :program, value: '« 2 3 - »' }],
+                                  Rpl::Lang::Dictionary.new )
 
     assert_equal [{ value: -1, type: :numeric, base: 10 }],
                  stack

spec/language_operations_spec.rb

@@ -7,172 +7,172 @@ require_relative '../lib/core'
 
 class TesttLanguageOperations < Test::Unit::TestCase
   def test_add
-    stack = Rpl::Core.add [{ value: 1, type: :numeric, base: 10 },
-                           { value: 2, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.add [{ value: 1, type: :numeric, base: 10 },
+                                 { value: 2, type: :numeric, base: 10 }]
     assert_equal [{ value: 3, type: :numeric, base: 10 }],
                  stack
 
-    stack = Rpl::Core.add [{ value: 1, type: :numeric, base: 10 },
-                           { value: '"a"', type: :string }]
+    stack = Rpl::Lang::Core.add [{ value: 1, type: :numeric, base: 10 },
+                                 { value: '"a"', type: :string }]
     assert_equal [{ value: '"1a"', type: :string }],
                  stack
 
-    stack = Rpl::Core.add [{ value: 1, type: :numeric, base: 10 },
-                           { value: "'a'", type: :name }]
+    stack = Rpl::Lang::Core.add [{ value: 1, type: :numeric, base: 10 },
+                                 { value: "'a'", type: :name }]
     assert_equal [{ value: '"1a"', type: :string }],
                  stack
 
-    stack = Rpl::Core.add [{ value: "'a'", type: :name },
-                           { value: 1, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.add [{ value: "'a'", type: :name },
+                                 { value: 1, type: :numeric, base: 10 }]
     assert_equal [{ value: "'a1'", type: :name }],
                  stack
 
-    stack = Rpl::Core.add [{ value: "'a'", type: :name },
-                           { value: '"b"', type: :string }]
+    stack = Rpl::Lang::Core.add [{ value: "'a'", type: :name },
+                                 { value: '"b"', type: :string }]
     assert_equal [{ value: "'ab'", type: :name }],
                  stack
 
-    stack = Rpl::Core.add [{ value: "'a'", type: :name },
-                           { value: "'b'", type: :name }]
+    stack = Rpl::Lang::Core.add [{ value: "'a'", type: :name },
+                                 { value: "'b'", type: :name }]
     assert_equal [{ value: "'ab'", type: :name }],
                  stack
 
-    stack = Rpl::Core.add [{ value: '"a"', type: :string },
-                           { value: '"b"', type: :string }]
+    stack = Rpl::Lang::Core.add [{ value: '"a"', type: :string },
+                                 { value: '"b"', type: :string }]
     assert_equal [{ value: '"ab"', type: :string }],
                  stack
 
-    stack = Rpl::Core.add [{ value: '"a"', type: :string },
-                           { value: "'b'", type: :name }]
+    stack = Rpl::Lang::Core.add [{ value: '"a"', type: :string },
+                                 { value: "'b'", type: :name }]
     assert_equal [{ value: '"ab"', type: :string }],
                  stack
 
-    stack = Rpl::Core.add [{ value: '"a"', type: :string },
-                           { value: 1, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.add [{ value: '"a"', type: :string },
+                                 { value: 1, type: :numeric, base: 10 }]
     assert_equal [{ value: '"a1"', type: :string }],
                  stack
   end
 
   def test_subtract
-    stack = Rpl::Core.subtract [{ value: 1, type: :numeric, base: 10 },
-                                { value: 2, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.subtract [{ value: 1, type: :numeric, base: 10 },
+                                      { value: 2, type: :numeric, base: 10 }]
     assert_equal [{ value: -1, type: :numeric, base: 10 }],
                  stack
 
-    stack = Rpl::Core.subtract [{ value: 2, type: :numeric, base: 10 },
-                                { value: 1, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.subtract [{ value: 2, type: :numeric, base: 10 },
+                                      { value: 1, type: :numeric, base: 10 }]
     assert_equal [{ value: 1, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_negate
-    stack = Rpl::Core.negate [{ value: -1, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.negate [{ value: -1, type: :numeric, base: 10 }]
 
     assert_equal [{ value: 1, type: :numeric, base: 10 }],
                  stack
 
-    stack = Rpl::Core.negate [{ value: 1, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.negate [{ value: 1, type: :numeric, base: 10 }]
 
     assert_equal [{ value: -1, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_multiply
-    stack = Rpl::Core.multiply [{ value: 3, type: :numeric, base: 10 },
-                                { value: 4, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.multiply [{ value: 3, type: :numeric, base: 10 },
+                                      { value: 4, type: :numeric, base: 10 }]
     assert_equal [{ value: 12, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_divide
-    stack = Rpl::Core.divide [{ value: 3.0, type: :numeric, base: 10 },
-                              { value: 4, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.divide [{ value: 3.0, type: :numeric, base: 10 },
+                                    { value: 4, type: :numeric, base: 10 }]
     assert_equal [{ value: 0.75, type: :numeric, base: 10 }],
                  stack
 
-    # stack = Rpl::Core.divide [{ value: 3, type: :numeric, base: 10 },
+    # stack = Rpl::Lang::Core.divide [{ value: 3, type: :numeric, base: 10 },
     #                                       { value: 4, type: :numeric, base: 10 }]
     # assert_equal [{ value: 0.75, type: :numeric, base: 10 }],
     #              stack
   end
 
   def test_inverse
-    stack = Rpl::Core.inverse [{ value: 4, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.inverse [{ value: 4, type: :numeric, base: 10 }]
     assert_equal [{ value: 0.25, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_power
-    stack = Rpl::Core.power [{ value: 3, type: :numeric, base: 10 },
-                             { value: 4, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.power [{ value: 3, type: :numeric, base: 10 },
+                                   { value: 4, type: :numeric, base: 10 }]
     assert_equal [{ value: 81, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_sqrt
-    stack = Rpl::Core.sqrt [{ value: 16, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.sqrt [{ value: 16, type: :numeric, base: 10 }]
     assert_equal [{ value: 4, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_sq
-    stack = Rpl::Core.sq [{ value: 4, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.sq [{ value: 4, type: :numeric, base: 10 }]
     assert_equal [{ value: 16, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_abs
-    stack = Rpl::Core.abs [{ value: -1, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.abs [{ value: -1, type: :numeric, base: 10 }]
 
     assert_equal [{ value: 1, type: :numeric, base: 10 }],
                  stack
 
-    stack = Rpl::Core.abs [{ value: 1, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.abs [{ value: 1, type: :numeric, base: 10 }]
 
     assert_equal [{ value: 1, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_dec
-    stack = Rpl::Core.dec [{ value: 1, type: :numeric, base: 16 }]
+    stack = Rpl::Lang::Core.dec [{ value: 1, type: :numeric, base: 16 }]
 
     assert_equal [{ value: 1, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_hex
-    stack = Rpl::Core.hex [{ value: 1, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.hex [{ value: 1, type: :numeric, base: 10 }]
 
     assert_equal [{ value: 1, type: :numeric, base: 16 }],
                  stack
   end
 
   def test_bin
-    stack = Rpl::Core.bin [{ value: 1, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.bin [{ value: 1, type: :numeric, base: 10 }]
 
     assert_equal [{ value: 1, type: :numeric, base: 2 }],
                  stack
   end
 
   def test_base
-    stack = Rpl::Core.base [{ value: 1, type: :numeric, base: 10 },
-                            { value: 31, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.base [{ value: 1, type: :numeric, base: 10 },
+                                  { value: 31, type: :numeric, base: 10 }]
 
     assert_equal [{ value: 1, type: :numeric, base: 31 }],
                  stack
   end
 
   def test_sign
-    stack = Rpl::Core.sign [{ value: -10, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.sign [{ value: -10, type: :numeric, base: 10 }]
 
     assert_equal [{ value: -1, type: :numeric, base: 10 }],
                  stack
 
-    stack = Rpl::Core.sign [{ value: 10, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.sign [{ value: 10, type: :numeric, base: 10 }]
 
     assert_equal [{ value: 1, type: :numeric, base: 10 }],
                  stack
-    stack = Rpl::Core.sign [{ value: 0, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.sign [{ value: 0, type: :numeric, base: 10 }]
 
     assert_equal [{ value: 0, type: :numeric, base: 10 }],
                  stack

spec/language_program_spec.rb

@@ -10,24 +10,31 @@ require_relative '../lib/runner'
 
 class TestLanguageProgram < Test::Unit::TestCase
   def test_eval
-    stack = Rpl::Core.eval( [{ value: '« 2 dup * dup »', type: :program }], Rpl::Dictionary.new )
+    stack = Rpl::Lang::Core.eval( [{ value: '« 2 dup * dup »', type: :program }], Rpl::Lang::Dictionary.new )
 
     assert_equal [{ value: 4, type: :numeric, base: 10 },
                   { value: 4, type: :numeric, base: 10 }],
                  stack
 
-    stack = Rpl::Core.eval( [{ value: 4, type: :numeric, base: 10 },
-                             { value: "'dup'", type: :name }], Rpl::Dictionary.new )
+    stack = Rpl::Lang::Core.eval( [{ value: 4, type: :numeric, base: 10 },
+                                   { value: "'dup'", type: :name }], Rpl::Lang::Dictionary.new )
 
     assert_equal [{ value: 4, type: :numeric, base: 10 },
                   { value: 4, type: :numeric, base: 10 }],
                  stack
 
-    stack = Rpl::Core.eval( [{ value: 4, type: :numeric, base: 10 },
-                             { value: 'dup', type: :word }], Rpl::Dictionary.new )
+    stack = Rpl::Lang::Core.eval( [{ value: 4, type: :numeric, base: 10 },
+                                   { value: 'dup', type: :word }], Rpl::Lang::Dictionary.new )
 
     assert_equal [{ value: 4, type: :numeric, base: 10 },
                   { value: 4, type: :numeric, base: 10 }],
                  stack
   end
+
+  def test_sto
+    stack = Rpl::Lang::Core.sto( [{ value: '« 2 dup  »', type: :program },
+                                  { value: "'quatre'", type: :name }], Rpl::Lang::Dictionary.new )
+
+    assert_equal [], stack
+  end
 end

spec/language_stack_spec.rb

@@ -7,48 +7,48 @@ require_relative '../lib/core'
 
 class TestLanguageStack < Test::Unit::TestCase
   def test_swap
-    stack = Rpl::Core.swap [{ value: 1, type: :numeric, base: 10 },
-                            { value: 2, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.swap [{ value: 1, type: :numeric, base: 10 },
+                                  { value: 2, type: :numeric, base: 10 }]
     assert_equal [{ value: 2, type: :numeric, base: 10 },
                   { value: 1, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_drop
-    stack = Rpl::Core.drop [{ value: 1, type: :numeric, base: 10 },
-                            { value: 2, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.drop [{ value: 1, type: :numeric, base: 10 },
+                                  { value: 2, type: :numeric, base: 10 }]
     assert_equal [{ value: 1, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_drop2
-    stack = Rpl::Core.drop2 [{ value: 1, type: :numeric, base: 10 },
-                             { value: 2, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.drop2 [{ value: 1, type: :numeric, base: 10 },
+                                   { value: 2, type: :numeric, base: 10 }]
     assert_equal [],
                  stack
   end
 
   def test_dropn
-    stack = Rpl::Core.dropn [{ value: 1, type: :numeric, base: 10 },
-                             { value: 2, type: :numeric, base: 10 },
-                             { value: 3, type: :numeric, base: 10 },
-                             { value: 4, type: :numeric, base: 10 },
-                             { value: 3, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.dropn [{ value: 1, type: :numeric, base: 10 },
+                                   { value: 2, type: :numeric, base: 10 },
+                                   { value: 3, type: :numeric, base: 10 },
+                                   { value: 4, type: :numeric, base: 10 },
+                                   { value: 3, type: :numeric, base: 10 }]
     assert_equal [{ value: 1, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_del
-    stack = Rpl::Core.del [{ value: 1, type: :numeric, base: 10 },
-                           { value: 2, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.del [{ value: 1, type: :numeric, base: 10 },
+                                 { value: 2, type: :numeric, base: 10 }]
     assert_equal [],
                  stack
   end
 
   def test_rot
-    stack = Rpl::Core.rot [{ value: 1, type: :numeric, base: 10 },
-                           { value: 2, type: :numeric, base: 10 },
-                           { value: 3, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.rot [{ value: 1, type: :numeric, base: 10 },
+                                 { value: 2, type: :numeric, base: 10 },
+                                 { value: 3, type: :numeric, base: 10 }]
     assert_equal [{ value: 2, type: :numeric, base: 10 },
                   { value: 3, type: :numeric, base: 10 },
                   { value: 1, type: :numeric, base: 10 }],
@@ -56,8 +56,8 @@ class TestLanguageStack < Test::Unit::TestCase
   end
 
   def test_dup
-    stack = Rpl::Core.dup [{ value: 1, type: :numeric, base: 10 },
-                           { value: 2, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.dup [{ value: 1, type: :numeric, base: 10 },
+                                 { value: 2, type: :numeric, base: 10 }]
     assert_equal [{ value: 1, type: :numeric, base: 10 },
                   { value: 2, type: :numeric, base: 10 },
                   { value: 2, type: :numeric, base: 10 }],
@@ -65,8 +65,8 @@ class TestLanguageStack < Test::Unit::TestCase
   end
 
   def test_dup2
-    stack = Rpl::Core.dup2 [{ value: 1, type: :numeric, base: 10 },
-                            { value: 2, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.dup2 [{ value: 1, type: :numeric, base: 10 },
+                                  { value: 2, type: :numeric, base: 10 }]
     assert_equal [{ value: 1, type: :numeric, base: 10 },
                   { value: 2, type: :numeric, base: 10 },
                   { value: 1, type: :numeric, base: 10 },
@@ -75,11 +75,11 @@ class TestLanguageStack < Test::Unit::TestCase
   end
 
   def test_dupn
-    stack = Rpl::Core.dupn [{ value: 1, type: :numeric, base: 10 },
-                            { value: 2, type: :numeric, base: 10 },
-                            { value: 3, type: :numeric, base: 10 },
-                            { value: 4, type: :numeric, base: 10 },
-                            { value: 3, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.dupn [{ value: 1, type: :numeric, base: 10 },
+                                  { value: 2, type: :numeric, base: 10 },
+                                  { value: 3, type: :numeric, base: 10 },
+                                  { value: 4, type: :numeric, base: 10 },
+                                  { value: 3, type: :numeric, base: 10 }]
     assert_equal [{ value: 1, type: :numeric, base: 10 },
                   { value: 2, type: :numeric, base: 10 },
                   { value: 3, type: :numeric, base: 10 },
@@ -91,11 +91,11 @@ class TestLanguageStack < Test::Unit::TestCase
   end
 
   def test_pick
-    stack = Rpl::Core.pick [{ value: 1, type: :numeric, base: 10 },
-                            { value: 2, type: :numeric, base: 10 },
-                            { value: 3, type: :numeric, base: 10 },
-                            { value: 4, type: :numeric, base: 10 },
-                            { value: 3, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.pick [{ value: 1, type: :numeric, base: 10 },
+                                  { value: 2, type: :numeric, base: 10 },
+                                  { value: 3, type: :numeric, base: 10 },
+                                  { value: 4, type: :numeric, base: 10 },
+                                  { value: 3, type: :numeric, base: 10 }]
     assert_equal [{ value: 1, type: :numeric, base: 10 },
                   { value: 2, type: :numeric, base: 10 },
                   { value: 3, type: :numeric, base: 10 },
@@ -105,12 +105,12 @@ class TestLanguageStack < Test::Unit::TestCase
   end
 
   def test_depth
-    stack = Rpl::Core.depth []
+    stack = Rpl::Lang::Core.depth []
     assert_equal [{ value: 0, type: :numeric, base: 10 }],
                  stack
 
-    stack = Rpl::Core.depth [{ value: 1, type: :numeric, base: 10 },
-                             { value: 2, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.depth [{ value: 1, type: :numeric, base: 10 },
+                                   { value: 2, type: :numeric, base: 10 }]
     assert_equal [{ value: 1, type: :numeric, base: 10 },
                   { value: 2, type: :numeric, base: 10 },
                   { value: 2, type: :numeric, base: 10 }],
@@ -118,11 +118,11 @@ class TestLanguageStack < Test::Unit::TestCase
   end
 
   def test_roll
-    stack = Rpl::Core.roll [{ value: 1, type: :numeric, base: 10 },
-                            { value: 2, type: :numeric, base: 10 },
-                            { value: 3, type: :numeric, base: 10 },
-                            { value: 4, type: :numeric, base: 10 },
-                            { value: 3, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.roll [{ value: 1, type: :numeric, base: 10 },
+                                  { value: 2, type: :numeric, base: 10 },
+                                  { value: 3, type: :numeric, base: 10 },
+                                  { value: 4, type: :numeric, base: 10 },
+                                  { value: 3, type: :numeric, base: 10 }]
     assert_equal [{ value: 1, type: :numeric, base: 10 },
                   { value: 3, type: :numeric, base: 10 },
                   { value: 4, type: :numeric, base: 10 },
@@ -131,11 +131,11 @@ class TestLanguageStack < Test::Unit::TestCase
   end
 
   def test_rolld
-    stack = Rpl::Core.rolld [{ value: 1, type: :numeric, base: 10 },
-                             { value: 2, type: :numeric, base: 10 },
-                             { value: 4, type: :numeric, base: 10 },
-                             { value: 3, type: :numeric, base: 10 },
-                             { value: 2, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.rolld [{ value: 1, type: :numeric, base: 10 },
+                                   { value: 2, type: :numeric, base: 10 },
+                                   { value: 4, type: :numeric, base: 10 },
+                                   { value: 3, type: :numeric, base: 10 },
+                                   { value: 2, type: :numeric, base: 10 }]
     assert_equal [{ value: 1, type: :numeric, base: 10 },
                   { value: 2, type: :numeric, base: 10 },
                   { value: 3, type: :numeric, base: 10 },
@@ -144,10 +144,10 @@ class TestLanguageStack < Test::Unit::TestCase
   end
 
   def test_over
-    stack = Rpl::Core.over [{ value: 1, type: :numeric, base: 10 },
-                            { value: 2, type: :numeric, base: 10 },
-                            { value: 3, type: :numeric, base: 10 },
-                            { value: 4, type: :numeric, base: 10 }]
+    stack = Rpl::Lang::Core.over [{ value: 1, type: :numeric, base: 10 },
+                                  { value: 2, type: :numeric, base: 10 },
+                                  { value: 3, type: :numeric, base: 10 },
+                                  { value: 4, type: :numeric, base: 10 }]
     assert_equal [{ value: 1, type: :numeric, base: 10 },
                   { value: 2, type: :numeric, base: 10 },
                   { value: 3, type: :numeric, base: 10 },

spec/language_string_spec.rb

@@ -8,19 +8,19 @@ require_relative '../lib/parser'
 
 class TestLanguageString < Test::Unit::TestCase
   def test_to_string
-    stack = Rpl::Core.to_string( [{ value: 2, type: :numeric, base: 10 }] )
+    stack = Rpl::Lang::Core.to_string( [{ value: 2, type: :numeric, base: 10 }] )
 
     assert_equal [{ value: '2', type: :string }],
                  stack
   end
 
   def test_from_string
-    stack = Rpl::Core.from_string( [{ value: '2', type: :string }] )
+    stack = Rpl::Lang::Core.from_string( [{ value: '2', type: :string }] )
 
     assert_equal [{ value: 2, type: :numeric, base: 10 }],
                  stack
 
-    stack = Rpl::Core.from_string( [{ value: "« 2 dup * » 'carré' sto", type: :string }] )
+    stack = Rpl::Lang::Core.from_string( [{ value: "« 2 dup * » 'carré' sto", type: :string }] )
 
     assert_equal [{ value: '« 2 dup * »', type: :program },
                   { value: "'carré'", type: :name },
@@ -29,38 +29,38 @@ class TestLanguageString < Test::Unit::TestCase
   end
 
   def test_chr
-    stack = Rpl::Core.chr( [{ value: 71, type: :numeric, base: 10 }] )
+    stack = Rpl::Lang::Core.chr( [{ value: 71, type: :numeric, base: 10 }] )
 
     assert_equal [{ value: 'G', type: :string }],
                  stack
   end
 
   def test_num
-    stack = Rpl::Core.num( [{ value: 'G', type: :string }] )
+    stack = Rpl::Lang::Core.num( [{ value: 'G', type: :string }] )
 
     assert_equal [{ value: 71, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_size
-    stack = Rpl::Core.size( [{ value: 'test', type: :string }] )
+    stack = Rpl::Lang::Core.size( [{ value: 'test', type: :string }] )
 
     assert_equal [{ value: 4, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_pos
-    stack = Rpl::Core.pos( [{ value: 'test of POS', type: :string },
-                            { value: 'of', type: :string }] )
+    stack = Rpl::Lang::Core.pos( [{ value: 'test of POS', type: :string },
+                                  { value: 'of', type: :string }] )
 
     assert_equal [{ value: 5, type: :numeric, base: 10 }],
                  stack
   end
 
   def test_sub
-    stack = Rpl::Core.sub( [{ value: 'test', type: :string },
-                            { value: 1, type: :numeric, base: 10 },
-                            { value: 2, type: :numeric, base: 10 }] )
+    stack = Rpl::Lang::Core.sub( [{ value: 'test', type: :string },
+                                  { value: 1, type: :numeric, base: 10 },
+                                  { value: 2, type: :numeric, base: 10 }] )
 
     assert_equal [{ value: 'es', type: :string }],
                  stack

spec/language_time-date_spec.rb

@@ -8,7 +8,7 @@ require_relative '../lib/core'
 class TestLanguageTimeDate < Test::Unit::TestCase
   def test_time
     now = Time.now.to_s
-    stack = Rpl::Core.time( [] )
+    stack = Rpl::Lang::Core.time( [] )
 
     assert_equal [{ value: now, type: :string }],
                  stack
@@ -16,14 +16,14 @@ class TestLanguageTimeDate < Test::Unit::TestCase
 
   def test_date
     now = Date.today.to_s
-    stack = Rpl::Core.date( [] )
+    stack = Rpl::Lang::Core.date( [] )
 
     assert_equal [{ value: now, type: :string }],
                  stack
   end
 
   def test_ticks
-    stack = Rpl::Core.ticks( [] )
+    stack = Rpl::Lang::Core.ticks( [] )
 
     # TODO: better test, but how?
     assert_equal :numeric,

spec/parser_spec.rb

@@ -7,76 +7,76 @@ require_relative '../lib/parser'
 
 class TestParser < Test::Unit::TestCase
   def test_number
-    result = Rpl::Parser.new.parse_input( '1' )
+    result = Rpl::Lang::Parser.new.parse_input( '1' )
     assert_equal [{ value: 1, type: :numeric, base: 10 }], result
   end
 
   def test_word
-    result = Rpl::Parser.new.parse_input( 'dup' )
+    result = Rpl::Lang::Parser.new.parse_input( 'dup' )
     assert_equal [{ value: 'dup', type: :word }], result
   end
 
   def test_string
-    result = Rpl::Parser.new.parse_input( '"test"' )
+    result = Rpl::Lang::Parser.new.parse_input( '"test"' )
     assert_equal [{ value: '"test"', type: :string }], result
 
-    result = Rpl::Parser.new.parse_input( '" test"' )
+    result = Rpl::Lang::Parser.new.parse_input( '" test"' )
     assert_equal [{ value: '" test"', type: :string }], result
 
-    result = Rpl::Parser.new.parse_input( '"test "' )
+    result = Rpl::Lang::Parser.new.parse_input( '"test "' )
     assert_equal [{ value: '"test "', type: :string }], result
 
-    result = Rpl::Parser.new.parse_input( '" test "' )
+    result = Rpl::Lang::Parser.new.parse_input( '" test "' )
     assert_equal [{ value: '" test "', type: :string }], result
   end
 
   def test_name
-    result = Rpl::Parser.new.parse_input( "'test'" )
+    result = Rpl::Lang::Parser.new.parse_input( "'test'" )
     assert_equal [{ value: "'test'", type: :name }], result
   end
 
   def test_program
-    result = Rpl::Parser.new.parse_input( '« test »' )
+    result = Rpl::Lang::Parser.new.parse_input( '« test »' )
     assert_equal [{ value: '« test »', type: :program }], result
 
-    result = Rpl::Parser.new.parse_input( '«test »' )
+    result = Rpl::Lang::Parser.new.parse_input( '«test »' )
     assert_equal [{ value: '« test »', type: :program }], result
 
-    result = Rpl::Parser.new.parse_input( '« test»' )
+    result = Rpl::Lang::Parser.new.parse_input( '« test»' )
     assert_equal [{ value: '« test »', type: :program }], result
 
-    result = Rpl::Parser.new.parse_input( '«test»' )
+    result = Rpl::Lang::Parser.new.parse_input( '«test»' )
     assert_equal [{ value: '« test »', type: :program }], result
 
-    result = Rpl::Parser.new.parse_input( '« test test »' )
+    result = Rpl::Lang::Parser.new.parse_input( '« test test »' )
     assert_equal [{ value: '« test test »', type: :program }], result
 
-    result = Rpl::Parser.new.parse_input( '« test « test » »' )
+    result = Rpl::Lang::Parser.new.parse_input( '« test « test » »' )
     assert_equal [{ value: '« test « test » »', type: :program }], result
 
-    result = Rpl::Parser.new.parse_input( '« test "test" test »' )
+    result = Rpl::Lang::Parser.new.parse_input( '« test "test" test »' )
     assert_equal [{ value: '« test "test" test »', type: :program }], result
   end
 
   def test_number_number
-    result = Rpl::Parser.new.parse_input( '2 3' )
+    result = Rpl::Lang::Parser.new.parse_input( '2 3' )
     assert_equal [{ value: 2, type: :numeric, base: 10 }, { value: 3, type: :numeric, base: 10 }], result
   end
 
   def test_number_number_word
-    result = Rpl::Parser.new.parse_input( '2 3 +' )
+    result = Rpl::Lang::Parser.new.parse_input( '2 3 +' )
     assert_equal [{ value: 2, type: :numeric, base: 10 },
                   { value: 3, type: :numeric, base: 10 },
                   { value: '+', type: :word }], result
   end
 
   def test_number_string
-    result = Rpl::Parser.new.parse_input( '4 "test"' )
+    result = Rpl::Lang::Parser.new.parse_input( '4 "test"' )
     assert_equal [{ value: 4, type: :numeric, base: 10 }, { value: '"test"', type: :string }], result
   end
 
   def test_program_name
-    result = Rpl::Parser.new.parse_input( "« 2 dup * » 'carré' sto" )
+    result = Rpl::Lang::Parser.new.parse_input( "« 2 dup * » 'carré' sto" )
 
     assert_equal [{ value: '« 2 dup * »', type: :program },
                   { value: "'carré'", type: :name },