alphalang 0.1.1

data/lib/rdparse_quiet.rb

@@ -0,0 +1,237 @@
+# This file is called rdparse.rb because it implements a Recursive
+# Descent Parser. Read more about the theory on e.g.
+# http://en.wikipedia.org/wiki/Recursive_descent_parser
+
+# 2010-02-11 New version of this file for the 2010 instance of TDP007
+#   which handles false return values during parsing, and has an easy way
+#   of turning on and off debug messages.
+# 2014-02-16 New version that handles { false } blocks and :empty tokens.
+
+require 'logger'
+
+
+class Rule
+
+  # A rule is created through the rule method of the Parser class, like this:
+  #   rule :term do
+  #     match(:term, '*', :dice) {|a, _, b| a * b }
+  #     match(:term, '/', :dice) {|a, _, b| a / b }
+  #     match(:dice)
+  #   end
+
+  Match = Struct.new :pattern, :block
+
+  def initialize(name, parser)
+
+    # The name of the expressions this rule matches
+    @name = name
+    # We need the parser to recursively parse sub-expressions occurring
+    # within the pattern of the match objects associated with this rule
+    @parser = parser
+    @matches = []
+    # Left-recursive matches
+    @lrmatches = []
+  end
+
+  # Add a matching expression to this rule, as in this example:
+  #   match(:term, '*', :dice) {|a, _, b| a * b }
+  # The arguments to 'match' describe the constituents of this expression.
+  def match(*pattern, &block)
+    match = Match.new(pattern, block)
+    # If the pattern is left-recursive, then add it to the left-recursive set
+    if pattern[0] == @name
+      pattern.shift
+      @lrmatches << match
+    else
+      @matches << match
+    end
+  end
+
+  def parse
+    # Try non-left-recursive matches first, to avoid infinite recursion
+    match_result = try_matches(@matches)
+    return nil if match_result.nil?
+    loop do
+      result = try_matches(@lrmatches, match_result)
+      return match_result if result.nil?
+      match_result = result
+    end
+  end
+
+  private
+
+  # Try out all matching patterns of this rule
+  def try_matches(matches, pre_result = nil)
+    match_result = nil
+    # Begin at the current position in the input string of the parser
+    start = @parser.pos
+    matches.each do |match|
+      # pre_result is a previously available result from evaluating expressions
+      result = pre_result.nil? ? [] : [pre_result]
+
+      # We iterate through the parts of the pattern, which may be e.g.
+      #   [:expr,'*',:term]
+      match.pattern.each_with_index do |token,index|
+
+        # If this "token" is a compound term, add the result of
+        # parsing it to the "result" array
+        if @parser.rules[token]
+          result << @parser.rules[token].parse
+          if result.last.nil?
+            result = nil
+            break
+          end
+
+        else
+          # Otherwise, we consume the token as part of applying this rule
+          nt = @parser.expect(token)
+          if nt
+            result << nt
+            if @lrmatches.include?(match.pattern) then
+              pattern = [@name]+match.pattern
+            else
+              pattern = match.pattern
+            end
+
+          else
+            result = nil
+            break
+          end
+        end # pattern.each
+      end # matches.each
+      if result
+        if match.block
+          match_result = match.block.call(*result)
+        else
+          match_result = result[0]
+        end
+
+        break
+      else
+        # If this rule did not match the current token list, move
+        # back to the scan position of the last match
+        @parser.pos = start
+      end
+    end
+
+    return match_result
+  end
+end
+
+class Parser
+
+  attr_accessor :pos
+  attr_reader :rules, :string, :logger
+
+  class ParseError < RuntimeError
+  end
+
+  def initialize(language_name, locale='en', &block)
+
+    locales_path = File.join(__dir__, "locales", locale)
+    token_pairs = File.readlines(locales_path)
+    @token_list = Hash.new
+    token_pairs.each do |pair|
+      default_value, locale_value = pair.split(' ')
+      @token_list[default_value] = locale_value
+    end
+
+    @lex_tokens = []
+    @rules = {}
+    @start = nil
+    @language_name = language_name
+    instance_eval(&block)
+  end
+
+  # Tokenize the string into small pieces
+  def tokenize(string)
+    @tokens = []
+    @string = string.clone
+    until string.empty?
+      # Unless any of the valid tokens of our language are the prefix of
+      # 'string', we fail with an exception
+      raise ParseError, "unable to lex '#{string}" unless @lex_tokens.any? do |tok|
+        match = tok.pattern.match(string)
+        # The regular expression of a token has matched the beginning of 'string'
+        if match
+
+          # Also, evaluate this expression by using the block
+          # associated with the token
+          @tokens << tok.block.call(match.to_s) if tok.block
+          # consume the match and proceed with the rest of the string
+          string = match.post_match
+          true
+        else
+          # this token pattern did not match, try the next
+          false
+        end # if
+      end # raise
+    end # until
+  end
+
+  def parse(string)
+    # First, split the string according to the "token" instructions given.
+    # Afterwards @tokens contains all tokens that are to be parsed.
+    tokenize(string)
+
+    # These variables are used to match if the total number of tokens
+    # are consumed by the parser
+    @pos = 0
+    @max_pos = 0
+    @expected = []
+    # Parse (and evaluate) the tokens received
+    result = @start.parse
+    # If there are unparsed extra tokens, signal error
+    if @pos != @tokens.size
+      raise ParseError, "Parse error. expected: '#{@expected.join(', ')}', found '#{@tokens[@max_pos]}'"
+    end
+    return result
+  end
+
+  def next_token
+    @pos += 1
+    return @tokens[@pos - 1]
+  end
+
+  # Return the next token in the queue
+  def expect(tok)
+    return tok if tok == :empty
+    t = next_token
+    if @pos - 1 > @max_pos
+      @max_pos = @pos - 1
+      @expected = []
+    end
+    return t if tok === t
+    @expected << tok if @max_pos == @pos - 1 && !@expected.include?(tok)
+    return nil
+  end
+
+  def to_s
+    "Parser for #{@language_name}"
+  end
+
+  private
+
+  LexToken = Struct.new(:pattern, :block)
+
+  def token(pattern, &block)
+    @lex_tokens << LexToken.new(Regexp.new('\\A' + @token_list[pattern.source]), block)
+  end
+
+  def start(name, &block)
+    rule(name, &block)
+    @start = @rules[name]
+  end
+
+  def rule(name,&block)
+    @current_rule = Rule.new(name, self)
+    @rules[name] = @current_rule
+    instance_eval &block # In practise, calls match 1..N times
+    @current_rule = nil
+  end
+
+  def match(*pattern, &block)
+    # Basically calls memberfunction "match(*pattern, &block)
+    @current_rule.send(:match, *pattern, &block)
+  end
+end

data/lib/tester/fibonacci.alpha

@@ -0,0 +1,19 @@
+a = 1
+b = 1
+print b
+def fib(x)
+    f = 2
+    if f < x
+
+      print b
+      temp = a + b
+      a = b
+      b = temp
+      fib(x - 1)
+
+    else
+      b
+    end
+end
+
+fib(11)

data/lib/tester/test_unit.rb

@@ -0,0 +1,217 @@
+require 'test/unit'
+
+class TestArithmetic < Test::Unit::TestCase
+  def test_addition
+    assert_equal(3, LangParser.new.calc_test('1 + 2'))
+    assert_equal(3, LangParser.new.calc_test('(1 + 2)'))
+    assert_equal(3, LangParser.new.calc_test('((1 + 2))'))
+
+    assert_equal(6, LangParser.new.calc_test('1 + 2 + 3'))
+    assert_equal(6, LangParser.new.calc_test('(1 + 2) + 3'))
+    assert_equal(6, LangParser.new.calc_test('((1 + 2) + 3)'))
+    assert_equal(10, LangParser.new.calc_test('((1 + 2) + 3) + 4'))
+    assert_equal(10, LangParser.new.calc_test('4 + ((3) + (2 + 1))'))
+  end
+
+  def test_subtraction
+    assert_equal(1, LangParser.new.calc_test('2 - 1'))
+    assert_equal(-3, LangParser.new.calc_test('(-2) - 1'))
+    assert_equal(1, LangParser.new.calc_test('(2 - 1)'))
+    assert_equal(1, LangParser.new.calc_test('((2 - 1))'))
+
+    assert_equal(0, LangParser.new.calc_test('3 - 2 - 1'))
+    assert_equal(0, LangParser.new.calc_test('(3 - 2) - 1'))
+    assert_equal(0, LangParser.new.calc_test('((3 - 2)) - 1'))
+    assert_equal(2, LangParser.new.calc_test('(4 - (3 - 2)) - 1'))
+    assert_equal(2, LangParser.new.calc_test('(4 - ((3) - 2)) - 1'))
+    assert_equal(4, LangParser.new.calc_test('4 - (((3) - 2) - 1)'))
+  end
+
+  def test_multiply
+    assert_equal(2, LangParser.new.calc_test('2 * 1'))
+    assert_equal(2, LangParser.new.calc_test('1 * 2'))
+    assert_equal(2, LangParser.new.calc_test('1 * (2)'))
+    assert_equal(2, LangParser.new.calc_test('(1) * (2)'))
+
+    assert_equal(6, LangParser.new.calc_test('(1) * (2 * 3)'))
+    assert_equal(6, LangParser.new.calc_test('(1 * 2 * 3)'))
+    assert_equal(6, LangParser.new.calc_test('(1 * 2) * 3'))
+    assert_equal(18, LangParser.new.calc_test('(3) * 2 * (3)'))
+    assert_equal(-6, LangParser.new.calc_test('(3) * (0 - 2) * (1)'))
+  end
+
+  def test_division
+    assert_equal(2, LangParser.new.calc_test('2 / 1'))
+    assert_equal(1, LangParser.new.calc_test('2 / 2'))
+    assert_equal(0.5, LangParser.new.calc_test('1 / 2'))
+    assert_equal(-0.5, LangParser.new.calc_test('-1 / 2'))
+    assert_equal(-2.5, LangParser.new.calc_test('-5 / 2'))
+
+    assert_equal(0, LangParser.new.calc_test('(-1 + 1) / 2'))
+    assert_equal(1, LangParser.new.calc_test('(3 / (3 / 1)) / 1'))
+    assert_equal(1, LangParser.new.calc_test('(3 / (3 / 1)) / (1)'))
+    assert_equal(3, LangParser.new.calc_test('(3 / (3 / 1-1-1)) / (1)'))
+  end
+end
+
+class TestLogic < Test::Unit::TestCase
+  def test_logic
+    assert_equal(true, LangParser.new.calc_test('true'))
+    assert_equal(true, LangParser.new.calc_test('true and true'))
+    assert_equal(true, LangParser.new.calc_test('true or true'))
+    assert_equal(true, LangParser.new.calc_test('true or false'))
+    assert_equal(true, LangParser.new.calc_test(' not false'))
+
+    assert_equal(false, LangParser.new.calc_test('false'))
+    assert_equal(false, LangParser.new.calc_test('false and false'))
+    assert_equal(false, LangParser.new.calc_test('false and true'))
+    assert_equal(false, LangParser.new.calc_test('not true'))
+
+    assert_equal(true, LangParser.new.calc_test('(not false) and true'))
+    assert_equal(true, LangParser.new.calc_test('(not false) or false'))
+    assert_equal(true, LangParser.new.calc_test('true and true or false'))
+
+  end
+end
+
+class TestComparisons < Test::Unit::TestCase
+  def test_comparisons
+    assert_equal(true, LangParser.new.calc_test('1 < 2'))
+    assert_equal(false, LangParser.new.calc_test('1 > 2'))
+    assert_equal(true, LangParser.new.calc_test('1 < 2 and true'))
+    assert_equal(false, LangParser.new.calc_test('1 > 2 and true'))
+    assert_equal(false, LangParser.new.calc_test('1 > 2 + 3 and true'))
+    assert_equal(true, LangParser.new.calc_test('1+2 < 2+2 and true'))
+    assert_equal(true, LangParser.new.calc_test(' not 1 > 2 and true'))
+    assert_equal(true, LangParser.new.calc_test(' true and not 1 > 2'))
+    assert_equal(true, LangParser.new.calc_test(' not 1 > 2 and true'))
+
+    assert_equal(true, LangParser.new.calc_test(' not 1 > 2 and true or false'))
+    assert_equal(true, LangParser.new.calc_test(' not 1 > 2 and (true or false)'))
+    assert_equal(true, LangParser.new.calc_test(' not 1 > 2 and false or true and true'))
+
+    assert_equal(true, LangParser.new.calc_test(' 1 == 1'))
+    assert_equal(false, LangParser.new.calc_test(' 1 == 2'))
+    assert_equal(true, LangParser.new.calc_test(' not 1 == 2'))
+    assert_equal(false, LangParser.new.calc_test(' not 1 == 1'))
+
+    assert_equal(true, LangParser.new.calc_test(' 1 <= 1'))
+    assert_equal(false, LangParser.new.calc_test(' 3 <= 2'))
+    assert_equal(true, LangParser.new.calc_test(' 1 <= 2'))
+
+    assert_equal(true, LangParser.new.calc_test(' 1 >= 1'))
+    assert_equal(true, LangParser.new.calc_test(' 3 >= 2'))
+    assert_equal(false, LangParser.new.calc_test(' 1 >= 2'))
+  end
+end
+
+class TestIf < Test::Unit::TestCase
+  def test_if
+    assert_equal(2, LangParser.new.calc_test('  if true
+                                                  1+1
+                                                end'))
+
+    assert_equal(2, LangParser.new.calc_test('  if 3 == 3
+                                                  1+1
+                                                end'))
+
+    assert_equal(nil, LangParser.new.calc_test('if 3 == 2
+                                                  1+1
+                                                end'))
+  end
+end
+class TestVariables < Test::Unit::TestCase
+  def test_variables
+    assert_equal(1, LangParser.new.calc_test('x = 1
+                                              x'))
+
+    assert_equal(1, LangParser.new.calc_test('x = 1
+                                              x
+                                              x'))
+
+    assert_equal(1, LangParser.new.calc_test('x = 1
+                                              x
+                                              x + 1
+                                              x'))
+
+    assert_equal(3, LangParser.new.calc_test('x = 1
+                                              x + 2'))
+
+    assert_equal(2, LangParser.new.calc_test('x = 1
+                                              x = 2
+                                              x'))
+
+    assert_equal(5, LangParser.new.calc_test('x = 1 + 2
+                                              x + 2'))
+
+    assert_equal(5, LangParser.new.calc_test('x = 1 + 2
+                                              x = x + 2
+                                              x'))
+  end
+end
+
+class TestFunction < Test::Unit::TestCase
+  def test_function
+    assert_equal(nil, LangParser.new.calc_test(' def foo()
+                                                  5+5
+                                                end'))
+
+    assert_equal(10, LangParser.new.calc_test(' def foo()
+                                                  5+5
+                                                end
+                                                foo()'))
+
+    assert_equal(10, LangParser.new.calc_test(' def boo()
+                                                  a = 5
+                                                  a
+                                                end
+                                                b = 5 + boo()
+                                                b'))
+  end
+end
+
+class TestLoop < Test::Unit::TestCase
+  def test_while
+    assert_equal(WhileLoopNode, LangParser.new.calc_test('x = 5
+                                                      while x < 10
+                                                          x = x + 1
+                                                      end'))
+
+    assert_equal(10, LangParser.new.calc_test('x = 5
+                                                      while x < 10
+                                                          x = x + 1
+                                                      end
+                                                      x'))
+
+    assert_equal(-10, LangParser.new.calc_test('x = 0
+                                                      while x > -10
+                                                          x = x - 1
+                                                      end
+                                                      x'))
+
+    # assert_equal(0, LangParser.new.calc_test('x = 10
+    #                                                   while -x < 0     # fundera på negering av variabler
+    #                                                       x = x + 1
+    #                                                   end
+    #                                                   x'))
+  end
+end
+
+class TesCompactIf < Test::Unit::TestCase
+  def test_CompactIf
+    assert_equal(4, LangParser.new.calc_test('x = 4
+                                              if 7 <= 10 and > 5
+                                                x
+                                              end'))
+
+    assert_equal(8, LangParser.new.calc_test('x = 8
+                                              if x < 10 and > 5
+                                                x
+                                              end'))
+
+    assert_equal(nil, LangParser.new.calc_test('x = 2
+                                              if x <= 10 and >= 5
+                                                x
+                                              end'))
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: alphalang
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- mattias
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-05-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: optparse
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+description: Abstract Syntax Tree building language with a recursive descent parser
+email:
+- mattiasreuterskiold@gmail.com
+executables:
+- alphalang
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/alphalang
+- lib/alpha.rb
+- lib/lang_creator.rb
+- lib/locales/de
+- lib/locales/en
+- lib/locales/locale_template
+- lib/locales/sv
+- lib/nodes/#stmtnodes.rb#
+- lib/nodes/basenodes.rb
+- lib/nodes/stmtnodes.rb
+- lib/rdparse.rb
+- lib/rdparse_quiet.rb
+- lib/tester/fibonacci.alpha
+- lib/tester/test_unit.rb
+homepage: https://portfolio.reuterskiold.dev
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.4
+signing_key:
+specification_version: 4
+summary: alphalanguage
+test_files: []