alphalang 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9d0971b25f1f629686a4ca72899a014ab9dd0934b3021e1509faa46870e79fc
-  data.tar.gz: 7ff3c836669793b4b58deea30bd8e8c485ca7ce9465ab3ac6ef490b8a7508d04
+  metadata.gz: 1f69af7ab6e40605d9118d7125caf0c99ea961bd20108210a91d77ea790e0489
+  data.tar.gz: 0bd9593abf719ba7e5704a873f3d5d14aff15a20d424bcc858e7d9a7e45b22f4
 SHA512:
-  metadata.gz: 7a44e1156d6e59488c1891af9eaa3d9a304ddd812b54ad44656762d169d84a2c1df057a8030654aea52c791037dfc1620a551b0e72b4f8882b20ea8d9c45edc2
-  data.tar.gz: 1459484c62af5206acf1d9e657f25fae40cc8adfbb36838c59e1a37434034be283bdb48fbe4efb820eb0c6cb779e2a933925d4cbcc35796769df56e0bcce5f20
+  metadata.gz: 34c909f692a34e3eae601ec4eddcb6361e46480d74a857b277fdbe652d65b2cfa99b6c427661fea5c64720a2122b28e8644f079df2e76b267e53c9bf11c8d26f
+  data.tar.gz: 0aebab81771209c1f955abd3954e0ba7b9d4c8544fe2d308779d56d19669085b8cb925e6fbdda1cedd3c6b4a7755b95caa17b509bc9f948e85359025aefaf530

data/bin/alphalang

@@ -1,8 +1,9 @@
 #!/usr/bin/env ruby
 require 'optparse'
 require File.expand_path('../lib/alpha', __dir__)
+require_relative '../lib/rdparse'
 ALPHA_VER = '0.1.5'.freeze
-ABORT_ANSWERS = [' ', '', 'none', 'abort'].freeze # something here? Some cases empty means yes tho..
+ABORT_ANSWERS = [' ', '', 'none', 'abort'].freeze
 LOCALES_PATH = File.join(__dir__, '../lib/locales')
 PROTECTED_LOCALES = ['.', '..', 'locale_template', 'default', 'default.old', 'en', 'sv', 'de'].freeze
 
@@ -98,12 +99,6 @@ raise OptionParser::InvalidArgument, 'Too many files provided.
 Did you mean to use an --[option]? | alphalang -h' if ARGV.length > 1
 raise OptionParser::InvalidArgument, 'File must end with .alpha' unless verify_flag or ARGV[0].end_with?('.alpha')
 
-if verbose_flag
-  require_relative '../lib/rdparse'
-else
-  require_relative '../lib/rdparse_quiet'
-end
-
 if verify_flag
   unless ARGV.empty?
     puts 'Flag for verification found. Ignoring input file.'
@@ -111,5 +106,5 @@ if verify_flag
   end
   require_relative '../lib/tester/test_unit'
 else
-  LangParser.new(language_flag).parse_file(ARGV[0])
+  LangParser.new(language_flag, verbose_flag).parse_file(ARGV[0])
 end

data/lib/alpha.rb

@@ -1,8 +1,8 @@
 require_relative './nodes/scopemanager'
 
 class LangParser
-  def initialize(locale = 'default')
-    @langParser = Parser.new('lang parser', locale) do
+  def initialize(locale = 'default', debug_mode = false)
+    @langParser = Parser.new('lang parser', debug_mode, locale) do
       token(/;;.*$/)
       token(/while/) { |_| :WHILE }
       token(/print/) { |_| :PRINT }
@@ -23,7 +23,7 @@ class LangParser
       token(/./) { |m| m }
 
       start :program do
-        match(:comp_stmt) { |comp_stmt| comp_stmt }
+        match(:comp_stmt)
         match(:terminal)
       end
 
@@ -136,7 +136,8 @@ class LangParser
         match(/\d+/, '.', /\d+/) { |a, dot, b| NumberNode.new((a+dot+b)) }
         match('-', /\d+/) { |neg, a| NumberNode.new(neg + a) }
         match(/\d+/) { |a| NumberNode.new(a) }
-        match(/(false|true)/) { |a| BoolNode.new(a) }
+        match(ScopeManager.true_value) { |a| BoolNode.new(a) }
+        match(ScopeManager.false_value) { |a| BoolNode.new(a) }
         match(:PRINT, :member) { |_, a| PrintNode.new(a) }
         match(:PRINT, :expr) { |_, a| PrintNode.new(a) }
         match(:member)

data/lib/lang_creator.rb

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 require_relative 'locale_lister'
 
-# Function to read user input for translation
 def read_translation(line)
   puts "Enter the translation for: '#{line}'        <RET> to accept '#{line}'"
   translation = gets.chomp
@@ -73,21 +72,16 @@ def create_locale_file()
     return
   end
 
-  # prompt user for translations
   prompt_user(new_locale_file_path)
-
-  # Clear the screen
   system('clear')
 
-  # Display the contents of the translation file
   locale_as_array = clean_locale_file_to_array(new_locale_name)
   print_clean_locale_array(new_locale_name, locale_as_array)
 
-  # Ask user if the translation is correct
   puts 'Is this correct? [Y/n]'
   answer = gets.chomp
 
-  if answer.downcase == /y|Y/ or answer.empty?
+  if answer.downcase.match? /y|Y/ or answer.empty?
     puts "Locale is saved as #{new_locale_name} in #{LOCALES_PATH}"
   else
     puts 'Translation removed'

data/lib/locale_defaulter.rb

@@ -7,8 +7,7 @@ def set_default_locale(new_locale)
 
   available_locales.each do |locale|
     if locale == new_locale
-      File.rename("#{LOCALES_PATH}/default", "#{LOCALES_PATH}/default.old")
-      File.copy_stream("#{LOCALES_PATH}/#{new_locale}", "#{LOCALES_PATH}/default")
+      File.open("#{LOCALES_PATH}/default", 'w') { |f| f.write(new_locale)}
       puts "[alphalang] Default syntax locale is now set to #{locale}."
       return
     end

data/lib/locale_lister.rb

@@ -20,7 +20,7 @@ def clean_locale_file_to_array(locale_name)
 
   clean_locale_file_array = []
   locale_file.each do |line|
-    line.scan(/\b\p{Word}+\b/) do |word|
+    line.scan(/\p{Word}+[|]\p{Word}+|\p{Word}+/) do |word|
       clean_locale_file_array << word if word.size > 1
     end
   end
@@ -28,15 +28,18 @@ def clean_locale_file_to_array(locale_name)
 end
 
 def print_clean_locale_array(locale_name, clean_array)
-  header = "\n[alphalang] Syntax for locale <#{locale_name}>."
+  longest_word = clean_array.max_by(&:length).size
+  padding = ' ' * (longest_word/2-5)
+
+  header = "#{padding}[alphalang] Syntax for locale <#{locale_name}>.#{padding}"
   puts header
   puts '+' * (header.size - 2)
   clean_line = ''
   clean_array.each_with_index do |word, index|
     if index.even?
-      clean_line += "+        #{word}"
+      clean_line += "+ #{word}"
     else
-      clean_line += (' ' * (20 - clean_line.size)) + "#{word}"
+      clean_line += (' ' * (20 -clean_line.size)) + "#{word}"
       clean_line += (' ' * (header.size - clean_line.size - 3) + '+')
       puts clean_line
       clean_line = ''
@@ -49,6 +52,10 @@ def list_specific_locale_file()
   list_locale_files
   specific_locale = gets.chomp
 
+  if specific_locale == 'default'
+    specific_locale = File.read("#{LOCALES_PATH}/#{specific_locale}")
+  end
+
   return if ABORT_ANSWERS.include?(specific_locale)
 
   specific_locale_array = clean_locale_file_to_array(specific_locale)

data/lib/locales/default

@@ -1,18 +1 @@
-;;.*$ ;;.*$
-while while
-print print
-pause pause
-def def
-end end
-if if
-elseif elseif
-else else
-(false|true) (false|true)
-(==|<=|>=) (==|<=|>=)
-(not|!) (not|!)
-(and|&&) (and|&&)
-(or|\|\|) (or|\|\|)
-\s+ \s+
-\d+ \d+
-\w+ \w+
-. .
+en

data/lib/nodes/basenodes.rb

@@ -59,8 +59,8 @@ end
 class BoolNode < Node
   def initialize(value)
     @value = false
-    @value = true if value == "true"
-    @value = false if value == "false"
+    @value = true if value == ScopeManager.true_value
+    @value = false if value == ScopeManager.false_value
   end
 
   def evaluate
@@ -149,12 +149,13 @@ class CompStmtNode < Node
 
   def evaluate
     @comp_statements[0].evaluate
-    @comp_statements[1].evaluate # kanske bör loopas osv??? Root blir nu sista evalueringen.
+    @comp_statements[1].evaluate
   end
 end
 
 ####################################################
 
+#Arraynoden är ofärdig, används inte korrekt
 class ArrayNode < Node
   attr_accessor :lhs, :rhs
 

data/lib/nodes/scopemanager.rb

@@ -2,52 +2,64 @@ require_relative 'stmtnodes'
 
 ####################################################
 
-$scopes = [{}]
-$scope_lvl = 0
 $test_nodes = false
 
-# Need to figure out how to move the scopes in here as class members in a sane way
 class ScopeManager
+  def initialize(true_value, false_value)
+    @@true_value = true_value
+    @@false_value = false_value
+    @@scopes = [{}]
+    @@scope_lvl = 0
+  end
+
+  def self.true_value
+    @@true_value
+  end
+
+  def self.false_value
+    @@false_value
+  end
+
   def self.scope_lvl
-    $scope_lvl
+    @@scope_lvl
   end
 
   def self.scope_lvl=(value)
-    $scope_lvl = value
+    @@scope_lvl = value
   end
 
   def self.lookup_var(name)
-    temp_scope_lvl = $scope_lvl
+    temp_scope_lvl = @@scope_lvl
     while temp_scope_lvl >= 0
-      if !$scopes[temp_scope_lvl].key?(name)
+      if !@@scopes[temp_scope_lvl].key?(name)
         temp_scope_lvl -= 1
       else
-        return $scopes[temp_scope_lvl][name]
+        return @@scopes[temp_scope_lvl][name]
       end
     end
     raise ArgumentError, "Variable '#{name}' is not defined" unless @value
   end
 
   def self.increment_scope_level
-    $scope_lvl += 1
-    $scopes.push({})
+    @@scope_lvl += 1
+    @@scopes.push({})
   end
 
   def self.decrement_scope_level
-    $scope_lvl -= 1
-    $scopes.pop
+    @@scope_lvl -= 1
+    @@scopes.pop
   end
 
   def self.lookup_func(name)
-    raise ArgumentError, "Function '#{name}' is not defined" if $scopes[0][name].is_a?(NilClass)
-    return $scopes[0][name]
+    raise ArgumentError, "Function '#{name}' is not defined" if @@scopes[0][name].is_a?(NilClass)
+    return @@scopes[0][name]
   end
 
   def self.add_to_current_scope(name, value)
-    $scopes[$scope_lvl][name.name] = value.evaluate
+    @@scopes[@@scope_lvl][name.name] = value.evaluate
   end
 
   def self.add_func_to_global_scope(name, value, args)
-    $scopes[0][name.name] = [value, args]
+    @@scopes[0][name.name] = [value, args]
   end
 end

data/lib/nodes/stmtnodes.rb

@@ -72,12 +72,14 @@ class FuncCallNode < Node
     ScopeManager.decrement_scope_level
 
     # If function return value is an "Assign" then we declare that variable in the global scope.
+    # This should be a ScopeManager method, add_variable_to_global_scope is missing.
     old_scope_lvl = ScopeManager.scope_lvl
     if func_return_value.is_a?(VariableDecNode)
       ScopeManager.scope_lvl = 0
       func_return_value.evaluate
       ScopeManager.scope_lvl = old_scope_lvl
     end
+
     return func_return_value
   end
 end
@@ -196,6 +198,7 @@ class PauseNode < Node
   end
 
   def evaluate
+    @value = 0 if @value.evaluate.negative?
     sleep @value.evaluate
   end
 end

data/lib/rdparse.rb

@@ -20,8 +20,9 @@ class Rule
 
   Match = Struct.new :pattern, :block
 
-  def initialize(name, parser)
+  def initialize(name, parser, debug_bool)
     @logger = parser.logger
+    @debug_mode = debug_bool
     # The name of the expressions this rule matches
     @name = name
     # We need the parser to recursively parse sub-expressions occurring
@@ -80,7 +81,7 @@ class Rule
             result = nil
             break
           end
-          @logger.debug("Matched '#{@name} = #{match.pattern[index..-1].inspect}'")
+          @logger.debug("Matched '#{@name} = #{match.pattern[index..-1].inspect}'") if @debug_mode
         else
           # Otherwise, we consume the token as part of applying this rule
           nt = @parser.expect(token)
@@ -91,7 +92,7 @@ class Rule
             else
               pattern = match.pattern
             end
-            @logger.debug("Matched token '#{nt}' as part of rule '#{@name} <= #{pattern.inspect}'")
+            @logger.debug("Matched token '#{nt}' as part of rule '#{@name} <= #{pattern.inspect}'") if @debug_mode
           else
             result = nil
             break
@@ -104,7 +105,7 @@ class Rule
         else
           match_result = result[0]
         end
-        @logger.debug("'#{@parser.string[start..@parser.pos-1]}' matched '#{@name}' and generated '#{match_result.inspect}'") unless match_result.nil?
+        @logger.debug("'#{@parser.string[start..@parser.pos-1]}' matched '#{@name}' and generated '#{match_result.inspect}'") unless match_result.nil? if @debug_mode
         break
       else
         # If this rule did not match the current token list, move
@@ -118,28 +119,46 @@ class Rule
 end
 
 class Parser
-
   attr_accessor :pos
   attr_reader :rules, :string, :logger
 
   class ParseError < RuntimeError
   end
 
-  def initialize(language_name, locale = 'default', &block)
+  def initialize(language_name, debug_bool, locale, &block)
+    @debug_mode = debug_bool
+    @logger = Logger.new(STDOUT) if @debug_mode
+    @lex_tokens = []
+    @rules = {}
+    @start = nil
+    @language_name = language_name
+    @file_string = ''
+
+    create_tokens_from_locale(locale)
 
-    token_pairs = File.readlines("#{LOCALES_PATH}/#{locale}")
+    false_value = @token_list['(false|true)'].split('|')[0]# Hacky solution to convoluted tokens
+    true_value = @token_list['(false|true)'].split('|')[1]
+    true_value = true_value[0..-2]
+    false_value = false_value[1..]
+
+    ScopeManager.new(true_value, false_value) # Hacky solution to convoluted tokens
+
+    instance_eval(&block)
+  end
+
+  # Recreate the tokenlist using the chosen locale file
+  def create_tokens_from_locale(locale)
+    if locale == 'default'
+      lang_file = File.read("#{LOCALES_PATH}/#{locale}")
+      token_pairs = File.readlines("#{LOCALES_PATH}/#{lang_file}")
+    else
+      token_pairs = File.readlines("#{LOCALES_PATH}/#{locale}")
+    end
     @token_list = Hash.new
     token_pairs.each do |pair|
       default_value, locale_value = pair.split(' ')
       @token_list[default_value] = locale_value
     end
-
-    @logger = Logger.new(STDOUT)
-    @lex_tokens = []
-    @rules = {}
-    @start = nil
-    @language_name = language_name
-    instance_eval(&block)
   end
 
   # Tokenize the string into small pieces
@@ -153,7 +172,7 @@ class Parser
         match = tok.pattern.match(string)
         # The regular expression of a token has matched the beginning of 'string'
         if match
-          @logger.debug("Token #{match[0]} consumed as #{match[0]}")
+          @logger.debug("Token #{match[0]} consumed as #{match[0]}") if @debug_mode
           # Also, evaluate this expression by using the block
           # associated with the token
           @tokens << tok.block.call(match.to_s) if tok.block
@@ -168,9 +187,78 @@ class Parser
     end # until
   end
 
+  def find_faulty_expression_within_block(block_start_line, block_end_line, problematic_token)
+    index = 0
+    result = []
+    @file_string.each_line do |line|
+      if index > block_start_line and index < block_end_line
+
+        if line.match?(/;;.*$/)
+          line = line.split(';;')[0]
+        end
+
+        if line.match?(/#{problematic_token}\s+$/)
+          result << "ParseError, #{line.strip}() is missing an expression on line #{index + 1}"
+        end
+      end
+      index += 1
+    end
+    raise ParseError, result[-1]
+  end
+
+  def find_faulty_expression_within_ends
+    puts 'TODO: Implement search for faulty token between two of the same guides'
+    raise ParseError, "Most likely mismatched '#{@token_list['END'.downcase]}' token."
+  end
+
+  def find_faulty_line
+    problematic_token = "#{@tokens[@max_pos - 1].downcase}"
+    before_problem = "#{@tokens[@max_pos - 2].downcase}"
+    after_problem = "#{@tokens[@max_pos - 0].downcase}"
+
+    if @max_pos - 5 <= 0
+      puts 'problem in the beginning of file, figure it out'
+      return
+    elsif @max_pos + 5 < @max_pos
+      puts 'problem in the end of file, figure it out'
+      return
+    end
+
+    translated_problematic_token = @token_list[problematic_token]
+
+    if translated_problematic_token.is_a?(NilClass)
+      raise ParseError, "Faulty expression likely between two '#{@token_list['END'.downcase]}' tokens."
+    end
+
+    index = 0
+    problem_match_hash = {}
+    found_end = false
+    @file_string.each_line do |line|
+      if line.match?(before_problem) && found_end == false
+        problem_match_hash[before_problem] = index
+      end
+
+      if line.match?(after_problem) && index > problem_match_hash[before_problem]
+        problem_match_hash[after_problem] = index
+        found_end = true
+      end
+      index += 1
+    end
+
+    non_empty_line_before_problem = problem_match_hash[before_problem]
+    non_empty_line_after_problem = problem_match_hash[after_problem]
+
+    unless after_problem == before_problem
+      find_faulty_expression_within_block(non_empty_line_before_problem, non_empty_line_after_problem, problematic_token)
+    else
+      find_faulty_expression_within_ends
+    end
+  end
+
   def parse(string)
     # First, split the string according to the "token" instructions given.
     # Afterwards @tokens contains all tokens that are to be parsed.
+    @file_string = string
     tokenize(string)
 
     # These variables are used to match if the total number of tokens
@@ -182,7 +270,13 @@ class Parser
     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]}'"
+
+      if @tokens[@max_pos] == '(' || @tokens[@max_pos] == ')'
+        raise ParseError, 'Mismatched parenthesis! In Emacs: M-x check-parens RET'
+      end
+
+      # raise ParseError, "Parse error. expected: '#{@expected.join(', ')}', found '#{@tokens[@max_pos]}'"
+      return find_faulty_line
     end
     return result
   end
@@ -223,7 +317,7 @@ class Parser
   end
 
   def rule(name,&block)
-    @current_rule = Rule.new(name, self)
+    @current_rule = Rule.new(name, self, @debug_mode)
     @rules[name] = @current_rule
     instance_eval &block # In practise, calls match 1..N times
     @current_rule = nil

data/lib/tester/test_unit.rb

@@ -1,217 +1,241 @@
-require 'test/unit'
+require "test/unit"
+require_relative "../locale_lister"
+
+locale_used = File.read("#{LOCALES_PATH}/#{"default"}")
+words_array = clean_locale_file_to_array(locale_used)
+word_pair_hash = {}
+words_array.each_with_index do |word, index|
+  if index.even?
+    word_pair_hash[word] = words_array[index + 1]
+  end
+end
+
+$while = word_pair_hash["while"]
+$print = word_pair_hash["print"]
+$pause = word_pair_hash["pause"]
+$def = word_pair_hash["def"]
+$end = word_pair_hash["end"]
+$if = word_pair_hash["if"]
+$else_if = word_pair_hash["elseif"]
+$else = word_pair_hash["else"]
+$false = word_pair_hash["false|true"].split("|")[0]
+$true = word_pair_hash["false|true"].split("|")[1]
+$not = word_pair_hash["not"]
+$and = word_pair_hash["and"]
+$or = word_pair_hash["or"]
 
 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))'))
+    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)'))
+    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)'))
+    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)'))
+    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(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(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'))
+    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'))
+    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
+    assert_equal(2, LangParser.new.calc_test("  #{$if} #{$true}
                                                   1+1
-                                                end'))
+                                                #{$end}"))
 
-    assert_equal(2, LangParser.new.calc_test('  if 3 == 3
+    assert_equal(2, LangParser.new.calc_test("  #{$if} 3 == 3
                                                   1+1
-                                                end'))
+                                                #{$end}"))
 
-    assert_equal(nil, LangParser.new.calc_test('if 3 == 2
+    assert_equal(nil, LangParser.new.calc_test("#{$if} 3 == 2
                                                   1+1
-                                                end'))
+                                                #{$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"))
 
-    assert_equal(1, LangParser.new.calc_test('x = 1
+    assert_equal(1, LangParser.new.calc_test("x = 1
                                               x
-                                              x'))
+                                              x"))
 
-    assert_equal(1, LangParser.new.calc_test('x = 1
+    assert_equal(1, LangParser.new.calc_test("x = 1
                                               x
                                               x + 1
-                                              x'))
+                                              x"))
 
-    assert_equal(3, LangParser.new.calc_test('x = 1
-                                              x + 2'))
+    assert_equal(3, LangParser.new.calc_test("x = 1
+                                              x + 2"))
 
-    assert_equal(2, LangParser.new.calc_test('x = 1
+    assert_equal(2, LangParser.new.calc_test("x = 1
                                               x = 2
-                                              x'))
+                                              x"))
 
-    assert_equal(5, LangParser.new.calc_test('x = 1 + 2
-                                              x + 2'))
+    assert_equal(5, LangParser.new.calc_test("x = 1 + 2
+                                              x + 2"))
 
-    assert_equal(5, LangParser.new.calc_test('x = 1 + 2
+    assert_equal(5, LangParser.new.calc_test("x = 1 + 2
                                               x = x + 2
-                                              x'))
+                                              x"))
   end
 end
 
 class TestFunction < Test::Unit::TestCase
   def test_function
-    assert_equal(nil, LangParser.new.calc_test(' def foo()
+    assert_equal(nil, LangParser.new.calc_test(" #{$def} foo()
                                                   5+5
-                                                end'))
+                                                #{$end}"))
 
-    assert_equal(10, LangParser.new.calc_test(' def foo()
+    assert_equal(10, LangParser.new.calc_test(" #{$def} foo()
                                                   5+5
-                                                end
-                                                foo()'))
+                                                #{$end}
+                                                foo()"))
 
-    assert_equal(10, LangParser.new.calc_test(' def boo()
+    assert_equal(10, LangParser.new.calc_test(" #{$def} boo()
                                                   a = 5
                                                   a
-                                                end
+                                                #{$end}
                                                 b = 5 + boo()
-                                                b'))
+                                                b"))
   end
 end
 
 class TestLoop < Test::Unit::TestCase
   def test_while
-    assert_equal(WhileLoopNode, LangParser.new.calc_test('x = 5
-                                                      while x < 10
+    assert_equal(WhileLoopNode, LangParser.new.calc_test("x = 5
+                                                      #{$while} x < 10
                                                           x = x + 1
-                                                      end'))
+                                                      #{$end}"))
 
-    assert_equal(10, LangParser.new.calc_test('x = 5
-                                                      while x < 10
+    assert_equal(10, LangParser.new.calc_test("x = 5
+                                                      #{$while} x < 10
                                                           x = x + 1
-                                                      end
-                                                      x'))
+                                                      #{$end}
+                                                      x"))
 
-    assert_equal(-10, LangParser.new.calc_test('x = 0
-                                                      while x > -10
+    assert_equal(-10, LangParser.new.calc_test("x = 0
+                                                      #{$while} x > -10
                                                           x = x - 1
-                                                      end
-                                                      x'))
+                                                      #{$end}
+                                                      x"))
 
-    # assert_equal(0, LangParser.new.calc_test('x = 10
-    #                                                   while -x < 0     # fundera på negering av variabler
+    # assert_equal(0, LangParser.new.calc_test("x = 10
+    #                                                   #{$while} -x < 0     # fundera på negering av variabler
     #                                                       x = x + 1
-    #                                                   end
-    #                                                   x'))
+    #                                                   #{$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
+    assert_equal(4, LangParser.new.calc_test("x = 4
+                                              #{$if} 7 <= 10 #{$and} > 5
                                                 x
-                                              end'))
+                                              #{$end}"))
 
-    assert_equal(8, LangParser.new.calc_test('x = 8
-                                              if x < 10 and > 5
+    assert_equal(8, LangParser.new.calc_test("x = 8
+                                              #{$if} x < 10 #{$and} > 5
                                                 x
-                                              end'))
+                                              #{$end}"))
 
-    assert_equal(nil, LangParser.new.calc_test('x = 2
-                                              if x <= 10 and >= 5
+    assert_equal(nil, LangParser.new.calc_test("x = 2
+                                              #{$if} x <= 10 #{$and} >= 5
                                                 x
-                                              end'))
+                                              #{$end}"))
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alphalang
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
-- mattias
+- mattias, victor
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-04 00:00:00.000000000 Z
+date: 2024-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -73,7 +73,6 @@ files:
 - lib/nodes/scopemanager.rb
 - lib/nodes/stmtnodes.rb
 - lib/rdparse.rb
-- lib/rdparse_quiet.rb
 - lib/tester/demo_de.alpha
 - lib/tester/demo_sv.alpha
 - lib/tester/fibonacci.alpha

data/lib/rdparse_quiet.rb

@@ -1,236 +0,0 @@
-# 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 = 'default', &block)
-
-    token_pairs = File.readlines("#{LOCALES_PATH}/#{locale}")
-    @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