alphalang 0.2.6 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dbe6c0cb099f96c68feadb26492b409cdb71d2db52fd5e6436a6c142d273584
-  data.tar.gz: 215b6ea3d011610dbdb3d2021025c29361df8d6cc4dba74a7a8dabf0d7596fdb
+  metadata.gz: 3ab6d2758dc063b20d389b6933acbe56ab78fda4ba97f0520cc9cddb5b79701d
+  data.tar.gz: f14a27f54b3ab0885484ecc800bd64954bb0bce0c4740a4c1ee7113d47606a3a
 SHA512:
-  metadata.gz: c99ce78b496f2eb91ddb26c799fe51e18e5fb0f2d23d546fcadff0cc7a293c28af455ecad577d43b1e9c4e156f781d17b9ba4b4f7f856861158b68301c23ef77
-  data.tar.gz: d6fd552131866752356ce35a82c1ce032dc1863597b1ba618e9f9924fc1d9c2c86a8e595fe64358757156150125ba937350bd422e5818f77f453be9be0882a1a
+  metadata.gz: ceddb38213e3e95d0156a12e0fdd5461cf7880d0c517603ca2117276f5f5db22630598afa6e8d0d66aa4865b3eacc947b09edc78f3660c20e9e2c07e4a633b5b
+  data.tar.gz: 347feeb1bc8ec3fa97f4b1bbd529bb071894f604e9bd534749cd4ab198e83c20da0c02c0f3d4ba016d5e249937ccc3f9ee33235d538262bf3ae0279a705c60b3

data/bin/alphalang

@@ -56,7 +56,7 @@ list_locales_flag = options[:listlocales]
 list_locale_flag = options[:listlocale]
 
 if create_locale_flag
-  require_relative '../lib/lang_creator'
+  require_relative '../lib/locale_creator'
   create_locale_file
   return
 end
@@ -104,7 +104,9 @@ if verify_flag
     puts 'Flag for verification found. Ignoring input file.'
     sleep 1
   end
+  TEST_UNIT_ACTIVE = true
   require_relative '../lib/tester/test_unit'
 else
+  TEST_UNIT_ACTIVE = false
   LangParser.new(language_flag, verbose_flag).parse_file(ARGV[0])
 end

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/locale_defaulter.rb

@@ -5,11 +5,15 @@ require_relative 'locale_lister'
 def set_default_locale(new_locale)
   available_locales = get_locale_files
 
-  available_locales.each do |locale|
-    if locale == new_locale
-      File.open("#{LOCALES_PATH}/default", 'w') { |f| f.write(new_locale)}
-      puts "[alphalang] Default syntax locale is now set to #{locale}."
-      return
+  available_locales.each do |available_locale|
+    if available_locale == new_locale
+      begin
+        File.open("#{LOCALES_PATH}/default", 'w') { |f| f.write(new_locale) }
+        puts "[alphalang] Default syntax locale is now set to #{new_locale}."
+      rescue Errno::ENOENT
+        puts '[alphalang] Failed to change default locale. Likely permissions error on your machine.'
+        puts "Could not open #{LOCALES_PATH}/default}"
+      end
     end
   end
 end

data/lib/locale_lister.rb

@@ -30,22 +30,24 @@ end
 
 def print_clean_locale_array(locale_name, clean_array)
   longest_word = clean_array.max_by(&:length).size
-  padding = ' ' * (longest_word/2-5)
+  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}"
     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 = ''
     end
   end
+
   puts '+' * (header.size - 2)
 end
 
@@ -53,9 +55,7 @@ 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
+  specific_locale = File.read("#{LOCALES_PATH}/#{specific_locale}") if specific_locale == 'default'
 
   return if ABORT_ANSWERS.include?(specific_locale)
 

data/lib/nodes/basenodes.rb

@@ -1,6 +1,4 @@
-#!/usr/bin/env ruby
-
-####################################################
+###################### Base Nodes
 
 class Node
   attr_accessor :value
@@ -43,6 +41,8 @@ class BoolNode < Node
   end
 end
 
+###################### Logic Gate Nodes
+
 class AndNode < Node
   def initialize(lhs, rhs)
     @lhs, @rhs = lhs, rhs
@@ -83,7 +83,7 @@ class NotNode < Node
   end
 end
 
-####################################################
+###################### Operation Nodes
 
 class CompareNode < Node
   attr_accessor :lhs, :op, :rhs
@@ -119,7 +119,7 @@ class BinaryOperationNode < Node
     end
 
     if @rhs.evaluate.is_a?(ArrayNode) or @rhs.evaluate.is_a?(Array) and @lhs.evaluate.is_a?(Numeric)
-      raise SyntaxError, "You can't subtract and array from a number! #{@lhs.evaluate} #{@op} #{@rhs.name}"
+      raise SyntaxError, "You can't subtract an array from a number! #{@lhs.evaluate} #{@op} #{@rhs.name}"
     end
 
     if @op == '/'
@@ -130,21 +130,7 @@ class BinaryOperationNode < Node
   end
 end
 
-####################################################
-
-class CompStmtNode < Node
-  def initialize(stmt_compstmt)
-    super
-    @comp_statements = stmt_compstmt
-  end
-
-  def evaluate
-    @comp_statements[0].evaluate
-    @comp_statements[1].evaluate
-  end
-end
-
-####################################################
+###################### Array / Data Structure Nodes
 
 class ArrayNode < Node
   attr_accessor :lhs, :rhs
@@ -205,3 +191,17 @@ class ArrayNode < Node
     self
   end
 end
+
+###################### Root Program Node
+
+class CompStmtNode < Node
+  def initialize(stmt_compstmt)
+    super
+    @comp_statements = stmt_compstmt
+  end
+
+  def evaluate
+    @comp_statements[0].evaluate
+    @comp_statements[1].evaluate
+  end
+end

data/lib/nodes/scopemanager.rb

@@ -2,8 +2,6 @@ require_relative 'stmtnodes'
 
 ####################################################
 
-$test_nodes = false
-
 class ScopeManager
   def initialize(true_value, false_value)
     @@true_value = true_value

data/lib/nodes/stmtnodes.rb

@@ -1,6 +1,6 @@
 require_relative 'basenodes'
 
-####################################################
+###################### Variable Nodes
 
 class VariableCallNode < Node
   attr_accessor :name
@@ -29,7 +29,22 @@ class VariableDecNode < Node
   end
 end
 
-####################################################
+class ArrayCallNode < Node
+  def initialize(array, index)
+    super(array)
+    @index = index.to_i
+  end
+
+  def evaluate
+    arr = ScopeManager.lookup_var(@value)
+    if @index > arr.size - 1
+      raise ArgumentError, "You are trying to access an out of bounds index. Here -> #{@value}[#{@index}]"
+    end
+    @value = arr[@index]
+  end
+end
+
+###################### Function Nodes
 
 class FunctionDecNode < Node
   def initialize(node, value)
@@ -84,7 +99,7 @@ class FuncCallNode < Node
   end
 end
 
-####################################################
+###################### If Statement Nodes
 
 class IfNode < Node
   attr_accessor :argument
@@ -138,7 +153,7 @@ class IfCompStmtNode < Node
   end
 end
 
-####################################################
+###################### Loop Nodes
 
 class WhileLoopNode < Node
   attr_accessor :condition
@@ -156,24 +171,7 @@ class WhileLoopNode < Node
   end
 end
 
-####################################################
-
-class ArrayCallNode < Node
-  def initialize(array, index)
-    super(array)
-    @index = index.to_i
-  end
-
-  def evaluate
-    arr = ScopeManager.lookup_var(@value)
-    if @index > arr.size - 1
-      raise ArgumentError, "You are trying to access an out of bounds index. Here -> #{@value}[#{@index}]"
-    end
-    @value = arr[@index]
-  end
-end
-
-####################################################
+###################### Built-in Functions
 
 class PrintNode
   attr_accessor :value
@@ -184,20 +182,13 @@ class PrintNode
 
   def evaluate
     if @value.evaluate.is_a?(ArrayNode)
-      print "Array #{@value.name}: "
-      puts @value.evaluate
+      print "Array #{@value.name}: "     unless TEST_UNIT_ACTIVE
+      puts @value.evaluate               unless TEST_UNIT_ACTIVE
     elsif @value.evaluate.is_a?(Array)
-      print "Array #{@value.name}: "
-      puts @value.evaluate.join(', ')
+      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
+      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)

data/lib/tester/fibonacci.alpha

@@ -1,7 +1,17 @@
 a = 1
 b = 1
-print b
+
 def fib(x)
+  if 2 < x
+
+    temp = a + b
+    a = b
+    b = temp
+
+    fib(x - 1)
+  else
+    b
+  end
 end
 
-fib(100)
+print fib(11)

data/lib/tester/test_unit.rb

@@ -239,3 +239,64 @@ class TesCompactIf < Test::Unit::TestCase
                                               #{$end}"))
   end
 end
+
+class TestPrograms < Test::Unit::TestCase
+  def test_fibonacci
+    program = "
+a = 1
+b = 1
+
+#{$def} fib(x)
+  #{$if} 2 < x
+
+    temp = a + b
+    a = b
+    b = temp
+
+    fib(x - 1)
+  #{$else}
+    b
+  #{$end}
+#{$end}
+
+fib(11)
+"
+    assert_equal(89, LangParser.new.calc_test(program))
+  end
+
+  def test_func_with_while
+    program = "
+x = 1
+
+#{$def} foo(bar)
+  #{$while} bar < 20
+    #{$print} bar
+    bar = bar + 1
+  #{$end}
+#{$end}
+
+foo(x)
+"
+    assert_equal(WhileLoopNode, LangParser.new.calc_test(program))
+  end
+
+  def test_func_with_while_return_value
+    program = "
+x = 1
+
+#{$def} foo(bar)
+  y = 0
+  #{$while} bar < 20
+    #{$print} bar
+    bar = bar + 1
+    y = bar
+  #{$end}
+  #{$print} y
+  y
+#{$end}
+
+foo(x)
+"
+    assert_equal(20, LangParser.new.calc_test(program))
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alphalang
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.8
 platform: ruby
 authors:
 - mattias, victor
@@ -60,7 +60,7 @@ extra_rdoc_files: []
 files:
 - bin/alphalang
 - lib/alpha.rb
-- lib/lang_creator.rb
+- lib/locale_creator.rb
 - lib/locale_defaulter.rb
 - lib/locale_deleter.rb
 - lib/locale_lister.rb