rpl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8843f4b55d77c8d3ec6c92cbe565ecb883361ba8cb47628097425b4b6f73da2
+  data.tar.gz: 430db66a68a4eeead6b16091e75aa9022a6a734004006067a38fb5283c3ec261
+SHA512:
+  metadata.gz: 7eff83ebc75b43ba473b913513590b82286932dd8b9628f9ae8970bb8d352ddd60a057e648d31fad7a5fefab974d2ddbcd9a03b18094c8c977e709bf1d910f56
+  data.tar.gz: 5fcd3aa9b3c9d918876fc5f69e3025a2f0339a4e0da8c2bc66432db11821ded06a149b3dcfe88d2d3d955c90ca42c86d0f2a4dc1257612bc5804380cf0638a4a

data/bin/rpl

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'readline'
+
+require 'rpl'
+
+class RplRepl
+  def initialize
+    @interpreter = Rpl.new
+  end
+
+  def run
+    Readline.completion_proc = proc do |s|
+      ( @interpreter.dictionary.words.keys + @interpreter.dictionary.vars.keys ).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'
+
+      # Remove blank lines from history
+      Readline::HISTORY.pop if input.empty?
+
+      begin
+        @interpreter.run( input )
+      rescue ArgumentError => e
+        p e
+      end
+
+      print_stack
+    end
+  end
+
+  def format_element( elt )
+    @interpreter.stringify( elt )
+  end
+
+  def print_stack
+    stack_size = @interpreter.stack.size
+
+    @interpreter.stack.each_with_index do |elt, i|
+      puts "#{stack_size - i}: #{format_element( elt )}"
+    end
+  end
+end
+
+RplRepl.new.run

data/lib/rpl/core/branch.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RplLang
+  module Core
+    module Branch
+      def populate_dictionary
+        super
+
+        @dictionary.add_word( ['ift'],
+                              'Branch',
+                              '( t pt -- … ) eval pt or not based on the value of boolean t',
+                              proc do
+                                run( '« nop » ifte' )
+                              end )
+
+        @dictionary.add_word( ['ifte'],
+                              'Branch',
+                              '( t pt pf -- … ) eval pt or pf based on the value of boolean t',
+                              proc do
+                                args = stack_extract( [:any, :any, %i[boolean]] )
+
+                                run( args[ args[2][:value] ? 1 : 0 ][:value] )
+                              end )
+
+        @dictionary.add_word( ['times'],
+                              'Branch',
+                              '( p n -- … ) eval p n times while pushing counter on stack before',
+                              proc do
+                                args = stack_extract( [%i[numeric], :any] )
+
+                                args[0][:value].to_i.times do |i|
+                                  counter = { value: BigDecimal( i, @precision ), type: :numeric, base: 10 }
+                                  @stack << counter
+
+                                  run( args[1][:value] )
+                                end
+                              end )
+
+        @dictionary.add_word( ['loop'],
+                              'Branch',
+                              '( p n1 n2 -- … ) eval p looping from n1 to n2 while pushing counter on stack before',
+                              proc do
+                                args = stack_extract( [%i[numeric], %i[numeric], :any] )
+
+                                ((args[1][:value].to_i)..(args[0][:value].to_i)).each do |i|
+                                  counter = { value: BigDecimal( i, @precision ), type: :numeric, base: 10 }
+                                  @stack << counter
+
+                                  run( args[2][:value] )
+                                end
+                              end )
+      end
+    end
+  end
+end

data/lib/rpl/core/filesystem.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RplLang
+  module Core
+    module FileSystem
+      def populate_dictionary
+        super
+
+        @dictionary.add_word( ['fread'],
+                              'Filesystem',
+                              '( filename -- content ) read file and put content on stack as string',
+                              proc do
+                                args = stack_extract( [%i[string]] )
+
+                                path = File.absolute_path( args[0][:value] )
+
+                                @stack << { type: :string,
+                                            value: File.read( path ) }
+                              end )
+
+        @dictionary.add_word( ['feval'],
+                              'Filesystem',
+                              '( filename -- … ) read and run file',
+                              proc do
+                                run( 'fread eval' )
+                              end )
+
+        @dictionary.add_word( ['fwrite'],
+                              'Filesystem',
+                              '( content filename -- ) write content into filename',
+                              proc do
+                                args = stack_extract( [%i[string], :any] )
+
+                                File.write( File.absolute_path( args[0][:value] ),
+                                            args[1][:value] )
+                              end )
+      end
+    end
+  end
+end

data/lib/rpl/core/general.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RplLang
+  module Core
+    module General
+      def populate_dictionary
+        super
+
+        @dictionary.add_word( ['nop'],
+                              'General',
+                              '( -- ) no operation',
+                              proc {} )
+
+        @dictionary.add_word( ['help'],
+                              'General',
+                              '( w -- s ) pop help string of the given word',
+                              proc do
+                                args = stack_extract( [%i[name]] )
+
+                                word = @dictionary.words[ args[0][:value] ]
+
+                                @stack << { type: :string,
+                                            value: "#{args[0][:value]}: #{word.nil? ? 'not a core word' : word[:help]}" }
+                              end )
+
+        @dictionary.add_word( ['quit'],
+                              'General',
+                              '( -- ) Stop and quit interpreter',
+                              proc {} )
+
+        @dictionary.add_word( ['version'],
+                              'General',
+                              '( -- n ) Pop the interpreter\'s version number',
+                              proc do
+                                @stack += parse( @version.to_s )
+                              end )
+
+        @dictionary.add_word( ['uname'],
+                              'General',
+                              '( -- s ) Pop the interpreter\'s complete indentification string',
+                              proc do
+                                @stack += parse( "\"Rpl Interpreter version #{@version}\"" )
+                              end )
+
+        @dictionary.add_word( ['history'],
+                              'REPL',
+                              '',
+                              proc {} )
+
+        @dictionary.add_word( ['.s'],
+                              'REPL',
+                              'DEBUG',
+                              proc { pp @stack } )
+      end
+    end
+  end
+end

data/lib/rpl/core/list.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RplLang
+  module Core
+    module List
+      def populate_dictionary
+        super
+
+        @dictionary.add_word( ['→list', '->list'],
+                              'Lists',
+                              '( … x -- […] ) pack x stacks levels into a list',
+                              proc do
+                                args = stack_extract( [%i[numeric]] )
+                                args = stack_extract( %i[any] * args[0][:value] )
+
+                                @stack << { type: :list,
+                                            value: args.reverse }
+                              end )
+
+        @dictionary.add_word( ['list→', 'list->'],
+                              'Lists',
+                              '( […] -- … ) unpack list on stack',
+                              proc do
+                                args = stack_extract( [%i[list]] )
+
+                                args[0][:value].each do |elt|
+                                  @stack << elt
+                                end
+                              end )
+      end
+    end
+  end
+end

data/lib/rpl/core/logarithm.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RplLang
+  module Core
+    module Logarithm
+      def populate_dictionary
+        super
+
+        @dictionary.add_word( ['ℇ', 'e'],
+                              'Logs on reals and complexes',
+                              '( … -- ℇ ) push ℇ',
+                              proc do
+                                @stack << { type: :numeric,
+                                            base: 10,
+                                            value: BigMath.E( @precision ) }
+                              end )
+
+        # @dictionary.add_word( ['ln'],
+        #                       'Logs on reals and complexes',
+        #                       'logarithm base e',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['lnp1'],
+        #                       'Logs on reals and complexes',
+        #                       'ln(1+x) which is useful when x is close to 0',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['exp'],
+        #                       'Logs on reals and complexes',
+        #                       'exponential',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['expm'],
+        #                       'Logs on reals and complexes',
+        #                       'exp(x)-1 which is useful when x is close to 0',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['log10'],
+        #                       'Logs on reals and complexes',
+        #                       'logarithm base 10',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['alog10'],
+        #                       'Logs on reals and complexes',
+        #                       'exponential base 10',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['log2'],
+        #                       'Logs on reals and complexes',
+        #                       'logarithm base 2',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['alog2'],
+        #                       'Logs on reals and complexes',
+        #                       'exponential base 2',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['sinh'],
+        #                       'Logs on reals and complexes',
+        #                       'hyperbolic sine',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['asinh'],
+        #                       'Logs on reals and complexes',
+        #                       'inverse hyperbolic sine',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['cosh'],
+        #                       'Logs on reals and complexes',
+        #                       'hyperbolic cosine',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['acosh'],
+        #                       'Logs on reals and complexes',
+        #                       'inverse hyperbolic cosine',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['tanh'],
+        #                       'Logs on reals and complexes',
+        #                       'hyperbolic tangent',
+        #                       proc do
+
+        #                       end )
+
+        # @dictionary.add_word( ['atanh'],
+        #                       'Logs on reals and complexes',
+        #                       'inverse hyperbolic tangent',
+        #                       proc do
+
+        #                       end )
+      end
+    end
+  end
+end

data/lib/rpl/core/mode.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RplLang
+  module Core
+    module Mode
+      def populate_dictionary
+        super
+
+        @dictionary.add_word( ['prec'],
+                              'Mode',
+                              '( a -- ) set precision to a',
+                              proc do
+                                args = stack_extract( [%i[numeric]] )
+
+                                @precision = args[0][:value]
+                              end )
+        @dictionary.add_word( ['default'],
+                              'Mode',
+                              '( -- ) set default precision',
+                              proc do
+                                @precision = default_precision
+                              end )
+        @dictionary.add_word( ['type'],
+                              'Mode',
+                              '( a -- s ) type of a as a string',
+                              proc do
+                                args = stack_extract( [:any] )
+
+                                @stack << { type: :string,
+                                            value: args[0][:type].to_s }
+                              end )
+
+        # @dictionary.add_word( ['std'],
+        #                  proc { __todo } ) # standard floating numbers representation. ex: std
+        # @dictionary.add_word( ['fix'],
+        #                  proc { __todo } ) # fixed point representation. ex: 6 fix
+        # @dictionary.add_word( ['sci'],
+        #                  proc { __todo } ) # scientific floating point representation. ex: 20 sci
+        # @dictionary.add_word( ['round'],
+        #                  proc { __todo } ) # set float rounding mode. ex: ["nearest", "toward zero", "toward +inf", "toward -inf", "away from zero"] round
+      end
+    end
+  end
+end