alphalang 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03e9f2d6c36766c890ac954b41a9bf02f2fe70e1f4ac4a3d40843ff03c228b28
-  data.tar.gz: bd5b500b199a1e32964a311847a28f39ca3b6059c2f06e0e8fcbd608106a641a
+  metadata.gz: 3ab6d2758dc063b20d389b6933acbe56ab78fda4ba97f0520cc9cddb5b79701d
+  data.tar.gz: f14a27f54b3ab0885484ecc800bd64954bb0bce0c4740a4c1ee7113d47606a3a
 SHA512:
-  metadata.gz: 9ad4f5de676ecdd7afc6d630c4a3934aba3d45623a8b45e19196574b7453641b077c5c5ac3a2d1c4edad06cacfaa17b28d7abf778fd894c7c4494c01a9d56654
-  data.tar.gz: 39f631c8dff1ecd6879786cee70656cb6c6b018db070d49d8c7e5cc6fccf8de018ba0ccf0608cdf11c00670f36d63eb2dcce5780c4cd2122b5b0a4cbc6e1ab9a
+  metadata.gz: ceddb38213e3e95d0156a12e0fdd5461cf7880d0c517603ca2117276f5f5db22630598afa6e8d0d66aa4865b3eacc947b09edc78f3660c20e9e2c07e4a633b5b
+  data.tar.gz: 347feeb1bc8ec3fa97f4b1bbd529bb071894f604e9bd534749cd4ab198e83c20da0c02c0f3d4ba016d5e249937ccc3f9ee33235d538262bf3ae0279a705c60b3

data/lib/alpha.rb

@@ -36,31 +36,48 @@ class LangParser
         match(:stmt)
       end
 
+      ###################### Statement Rules
+
       rule :stmt do
         match(:if_comp_stmt)
+        match(:loop)
+        match(:declaration)
+        match(:builtin)
+        match(:expr_stmt)
+      end
+
+      rule :loop do
         match(:while_stmt)
+      end
+
+      rule :declaration do
         match(:func_dec)
         match(:ass_stmt)
+      end
+
+      rule :builtin do
         match(:pause_stmt)
-        match(:expr_stmt)
+        match(:print_stmt)
       end
 
+      ###################### If Statement Rules
+
       rule :if_comp_stmt do
         match(:if_stmt, :comp_elseif, :else_stmt, :STOP) { |a, b, c| IfCompStmtNode.new(a, b, c) }
         match(:if_stmt, :else_stmt, :STOP) { |a, b| IfCompStmtNode.new(a, b) }
         match(:if_stmt, :STOP) { |a| IfCompStmtNode.new(a) }
       end
 
-      rule :comp_elseif do
-        match(:elseif_stmt, :comp_elseif) { |a, b| [a, b] }
-        match(:elseif_stmt)
-      end
-
       rule :if_stmt do
         match(:IF, :expr_stmt, :and, :expr_stmt, :comp_stmt) { |_, a, b, c, d| IfCompactNode.new(a, b, c, d) }
         match(:IF, :expr_stmt, :comp_stmt) { |_, a, b| IfNode.new(a, b) }
       end
 
+      rule :comp_elseif do
+        match(:elseif_stmt, :comp_elseif) { |a, b| [a, b] }
+        match(:elseif_stmt)
+      end
+
       rule :elseif_stmt do
         match(:ELSEIF, :expr_stmt, :comp_stmt) { |_, a, b| ElseifNode.new(a, b) }
       end
@@ -69,12 +86,16 @@ class LangParser
         match(:ELSE, :comp_stmt) { |_, b| ElseNode.new(b) }
       end
 
+      ###################### Loop Rules
+
       rule :while_stmt do
         match(:WHILE, :expr_stmt, :comp_stmt, :STOP) { |_, a, b| WhileLoopNode.new(a, b) }
       end
 
+      ###################### Variable and Function Declare Rules
+
       rule :func_dec do
-        match(:DEF, :member, :comp_stmt, :STOP) { |_, name, value, _| FunctionDecNode.new(name, value) }
+        match(:DEF, :call_member, :comp_stmt, :STOP) { |_, name, value, _| FunctionDecNode.new(name, value) }
       end
 
       rule :ass_stmt do
@@ -82,10 +103,18 @@ class LangParser
         match(:member, '=', :array_stmt) { |var, _, value| VariableDecNode.new(var, value) }
       end
 
+      ###################### Built-In Function Rules
+
       rule :pause_stmt do
         match(:PAUSE, :expr) { |_, a| PauseNode.new(a) }
       end
 
+      rule :print_stmt do
+        match(:PRINT, :expr) { |_, a| PrintNode.new(a) }
+      end
+
+      ###################### Expression Rules
+
       rule :expr_stmt do
         match(:or_stmt)
         match(:and_stmt)
@@ -105,15 +134,6 @@ class LangParser
         match(:NOT, :expr_stmt) { |_, b| NotNode.new(b) }
       end
 
-      rule :array_stmt do
-        match('[', :arg_list, ']') { |_, array, _| array }
-      end
-
-      rule :arg_list do
-        match(:expr, ',', :arg_list) { |a, _, b| ArrayNode.new(a, b) }
-        match(:expr) { |a| ArrayNode.new(a, NilClass) }
-      end
-
       rule :expr do
         match(:expr, /(<|>)/, :expr) { |a, op, b| CompareNode.new(a, op, b) }
         match(/(<|>)/, :expr) { |op, b| CompareNode.new(nil, op, b) }
@@ -131,25 +151,46 @@ class LangParser
         match(:atom)
       end
 
+      ###################### Data Types Rules
+
+      rule :array_stmt do
+        match('[', :arg_list, ']') { |_, array, _| array }
+      end
+
+      rule :arg_list do
+        match(:expr, ',', :arg_list) { |a, _, b| ArrayNode.new(a, b) }
+        match(:expr) { |a| ArrayNode.new(a, NilClass) }
+      end
+
       rule :atom do
-        match('-', /\d+/, '.', /\d+/) { |neg, a, dot, b| NumberNode.new((neg+a+dot+b)) }
-        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(:number)
+        match(:boolean)
+        match(:call_member)
+        match(:prio_stmt)
+      end
+
+      rule :boolean do
         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)
-        match(:prio_stmt)
+      end
+
+      rule :number do
+        match('-', /\d+/, '.', /\d+/) { |neg, a, dot, b| NumberNode.new(neg + a + dot + b) }
+        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) }
+      end
+
+      rule :call_member do
+        match(:member, '(', :arg_list, ')') { |var, _, args, _| FuncCallNode.new(var, args) }
+        match(:member, '(', ')') { |var, _, _| FuncCallNode.new(var, NilClass) }
+        match(:member, '[', '-', /\d+/, ']') { |var, _, neg, index, _| ArrayCallNode.new(var, (neg+index)) }
+        match(:member, '[', /\d+/, ']') { |var, _, index, _| ArrayCallNode.new(var, index) }
+        match(:member) { |var| VariableCallNode.new(var) }
       end
 
       rule :member do
-        match(/[a-z]/, '(', :arg_list, ')') { |var, _, args, _| FuncCallNode.new(var, args) }
-        match(/[a-z]/, '(', ')') { |var, _, _| FuncCallNode.new(var, NilClass) }
-        match(/[a-z]/, '[', '-', /\d+/, ']') { |var, _, neg, index, _| ArrayCallNode.new(var, (neg+index)) }
-        match(/[a-z]/, '[', /\d+/, ']') { |var, _, index, _| ArrayCallNode.new(var, index) }
-        match(/[a-z]/) { |var| VariableCallNode.new(var) }
+        match(/[a-z]/)
       end
 
       rule :prio_stmt do

data/lib/nodes/stmtnodes.rb

@@ -188,14 +188,7 @@ class PrintNode
       print "Array #{@value.name}: "     unless TEST_UNIT_ACTIVE
       puts @value.evaluate.join(', ')    unless TEST_UNIT_ACTIVE
     else
-      if @value.evaluate == PrintNode
-        if @value.value.is_a?(VariableCallNode)
-          raise SyntaxError, "You have a duplicate 'print' statement! Printing #{@value.value.name} twice."
-        else
-          raise SyntaxError, "You have a duplicate 'print' statement! Printing #{@value.value} twice."
-        end
-      end
-      puts @value.evaluate              unless TEST_UNIT_ACTIVE
+      puts @value.evaluate               unless TEST_UNIT_ACTIVE
     end
     self.class
   end

data/lib/rdparse.rb

@@ -187,81 +187,56 @@ class Parser
     end # until
   end
 
-  def find_faulty_expression_within_block(block_start_line, block_end_line, problematic_token)
-    if block_start_line == nil || block_end_line == nil
-      raise ParseError, "Error with <#{problematic_token}> somewhere around line #{block_end_line}#{block_start_line}"
-    end
-    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
+  def convert_regex_sensitive_token(token)
+      token = @token_list['end'] if token == :STOP    # fulhack pga :END påstods inte funka för länge sen
+      token = '[(]' if token == '('
+      token = '[)]' if token == ')'
+      token = '[+]' if token == '+'
+      token = '[-]' if token == '-'
+      token = '[*]' if token == '*'
+      token = '[/]' if token == '/'
+      token = "#{@token_list['(not|!)'].split('|')[0][1..]}" if token == :NOT
+      token = "#{@token_list['(and|&&)'].split('|')[0][1..]}" if token == :AND
+      token = "#{@token_list['(or|\|\|)'].split('|')[0][1..]}" if token == :OR
+      token
+  end
 
-        if line.match?(/#{problematic_token}\s+$/)
-          result << "ParseError, #{line.strip}() is missing an expression on line #{index + 1}"
-        end
-      end
-      index += 1
+  def translate_tokens_array(array)
+    result = []
+    array.each do |token|
+      token = convert_regex_sensitive_token(token)
+      result << token unless token.is_a?(Symbol)
+      result << @token_list[token.to_s.downcase] if token.is_a?(Symbol)
     end
-    raise ParseError, result[-1]
+    result
   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."
+  def find_surrounding_code(problem_pos)
+    tokens_before_problem = []
+    temp = problem_pos
+    while temp >= 0
+      tokens_before_problem << @tokens[temp]
+      temp -= 1
+    end
+    tokens_before_problem.reverse
   end
 
   def find_faulty_line
-    if @tokens[@max_pos-0].is_a?(NilClass)
-      if @max_pos >= 3
-        puts "Problem is in the end of the file after:\n #{@tokens[@max_pos - 3]}#{@tokens[@max_pos - 2]}#{@tokens[@max_pos - 1]}"
-      else
-        puts "Problem is right in the beginning of the file."
-      end
-      raise ParseError
-    end
-
-    problematic_token = "#{@tokens[@max_pos - 1].downcase}"
-    before_problem = "#{@tokens[@max_pos - 2].downcase}"
-    after_problem = "#{@tokens[@max_pos - 0].downcase}"
-
-    after_problem = "[" + after_problem + "]" if !after_problem.match?(/[a-z]/)
-    before_problem = "[" + before_problem + "]" if !before_problem.match?(/[a-z]/)
+    tokens_before_problem = find_surrounding_code(@max_pos - 1)
+    file_as_array_without_whitespaces = translate_tokens_array(tokens_before_problem)
 
-    translated_problematic_token = @token_list[problematic_token]
+    pattern = file_as_array_without_whitespaces.join('\s*')
+    regex = Regexp.new(pattern)
 
-    if translated_problematic_token.is_a?(NilClass)
-      puts "The problem is #{before_problem}#{problematic_token}#{after_problem}"
-      raise ParseError, "Faulty expression, this is not completely implemented."
-    end
+    cleaned_string = @file_string.gsub(/;;.*/, '')
 
-    index = 0
-    problem_match_hash = {}
-    found_end = false
-    @file_string.each_line do |line|
+    match_data = regex.match(cleaned_string)
+    num_lines = match_data[0].count("\n") + 1
 
-      if line.match?(before_problem) && found_end == false
-        problem_match_hash[before_problem] = index
-      end
+    problem = @tokens[@max_pos]
+    problem = @token_list[problem.to_s.downcase] unless @token_list[problem.to_s.downcase].is_a?(NilClass)
 
-      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
+    raise ParseError, "There is a problem around line #{num_lines}. Found <#{problem}>"
   end
 
   def parse(string)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alphalang
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - mattias, victor
@@ -74,8 +74,6 @@ files:
 - lib/nodes/scopemanager.rb
 - lib/nodes/stmtnodes.rb
 - lib/rdparse.rb
-- lib/tester/assign.alpha
-- lib/tester/assign.alpha~
 - lib/tester/demo_de.alpha
 - lib/tester/demo_emoji.alpha
 - lib/tester/demo_emoji.alpha~

data/lib/tester/assign.alpha

@@ -1,14 +0,0 @@
-x = 1
-
-def foo(bar)
-  y = 0
-  while bar < 20
-    print bar
-    bar = bar + 1
-    y = bar
-  end
-  print y
-  y
-end
-
-foo(x)

data/lib/tester/assign.alpha~

@@ -1,5 +0,0 @@
-x = 1
-
-def foo(bar)
-  y = bar
-end