alphalang 0.2.9 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd90e0cc81ecac899602c5a173f188110fecd877428fcab72e8bc77076e75d00
-  data.tar.gz: 1b1e538edb038c95ccffcb50fb8f48f5081977701082164da879ab848af80edb
+  metadata.gz: c79a0fb156d98b42640f99526fcf8b6274828c07f8504b9d4b3563fdedb9078d
+  data.tar.gz: 9b0c5a2476e297ba4b78165608e43adb96cf4312e99f8530a1a6cb4d8d466a09
 SHA512:
-  metadata.gz: 95e31bbc359dc485d7e5e623164f2f3c636c68975e6c7bd1c83fcfe75c11cbe8b1fe6c4d35eeefae0bfcf7c0b668f673a8649cea39d9bfe6f7319d860947e87b
-  data.tar.gz: 15cd10c8ce16fea278f3d99f3c8caecf3e811249c6a1d933360433d22ca06c0816602555a1aa314ba720a00229e6401256520de7d664da884a98e1bff2e3d24e
+  metadata.gz: df72d6c52254c86ad8cd85000bf5e44a614d2909d1e55b1620cba8fdb2ba9a8b3552b27b8b034e4f5147752a21e51686c3613b36b237b2ced95fc4fcffafedc2
+  data.tar.gz: d8bc966079ac40acf1af38adf08654fd8b7961f4b79067d747d94b23f6e99cff5f7a0ee75a6829de8eb34679284b623fb6891e7f893d1eb8c655ecb7dac8ae84

data/bin/alphalang

@@ -45,7 +45,7 @@ OptionParser.new do |opts|
     options[:listlocale] = true
   end
 
-  opts.on('--printtree', 'Lists all keywords from a specific locale file from your locales directory.') do
+  opts.on('-p', '--printtree', 'Prints the abstract syntax tree in a simple form.') do
     options[:printtree] = true
   end
 end.parse!
@@ -61,6 +61,8 @@ list_locale_flag = options[:listlocale]
 PRINT_TREE_FLAG = options[:printtree]
 TREE_ARRAY = []
 
+raise Errno::EBADR, "Don't use --logger and --printtree together." if PRINT_TREE_FLAG and verbose_flag
+
 if create_locale_flag
   require_relative '../lib/locale_creator'
   create_locale_file

data/lib/alpha.rb

@@ -24,11 +24,6 @@ class LangParser
 
       start :program do
         match(:comp_stmt)
-        match(:terminal)
-      end
-
-      rule :terminal do
-        match(/\n|;/)
       end
 
       rule :comp_stmt do
@@ -64,12 +59,12 @@ class LangParser
 
       rule :if_comp_stmt do
         match(:if_stmt, :comp_elseif, :else_stmt, :STOP) { |a, b, c| IfCompStmtNode.new(a, b, c) }
+        match(:if_stmt, :comp_elseif, :STOP) { |a, b| IfCompStmtNode.new(a, b) }
         match(:if_stmt, :else_stmt, :STOP) { |a, b| IfCompStmtNode.new(a, b) }
         match(:if_stmt, :STOP) { |a| IfCompStmtNode.new(a) }
       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
 
@@ -165,15 +160,11 @@ class LangParser
       rule :atom do
         match(:number)
         match(:boolean)
+        match(:string)
         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) }
-      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) }
@@ -181,6 +172,25 @@ class LangParser
         match(/\d+/) { |a| NumberNode.new(a) }
       end
 
+      rule :boolean do
+        match(ScopeManager.true_value) { |a| BoolNode.new(a) }
+        match(ScopeManager.false_value) { |a| BoolNode.new(a) }
+      end
+
+      rule :string do
+        match('"', :comp_string, '"') { |_, str, _| StringNode.new(str) }
+      end
+
+      # TODO: Figure out if  this is possible with char without messing too much with lexer
+      rule :comp_string do
+        match(:word, :comp_string) { |a, b| [a, b].flatten }
+        match(:word)
+      end
+
+      rule :word do
+        match(/\w/) { |m| m }
+      end
+
       rule :call_member do
         match(:member, '(', :arg_list, ')') { |var, _, args, _| FuncCallNode.new(var, args) }
         match(:member, '(', ')') { |var, _, _| FuncCallNode.new(var, NilClass) }

data/lib/error_handler.rb

@@ -0,0 +1,68 @@
+# Error Handler, imported by RDParse.
+class ErrorHandler
+  class ParseError < RuntimeError
+  end
+
+  def self.convert_regex_sensitive_token(token, token_list)
+    token = token_list['end'] if token == :STOP
+    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 = '[(]' if token == '('
+    token = '[)]' if token == ')'
+    token = '[+]' if token == '+'
+    token = '[-]' if token == '-'
+    token = '[*]' if token == '*'
+    token = '[/]' if token == '/'
+    token
+  end
+
+  def self.translate_tokens_array(array, token_list)
+    result = []
+    array.each do |token|
+      token = convert_regex_sensitive_token(token, token_list)
+      result << token unless token.is_a?(Symbol)
+      result << token_list[token.to_s.downcase] if token.is_a?(Symbol)
+    end
+    result
+  end
+
+  def self.find_surrounding_code(problem_pos, tokens)
+    tokens_before_problem = []
+    temp = problem_pos
+    while temp >= 0
+      tokens_before_problem << tokens[temp]
+      temp -= 1
+    end
+    tokens_before_problem.reverse
+  end
+
+  def self.find_faulty_line(pos, file_string, tokens, token_list)
+    tokens_before_problem = find_surrounding_code(pos - 1, tokens)
+    file_as_array_without_whitespaces = translate_tokens_array(tokens_before_problem, token_list)
+
+    pattern = file_as_array_without_whitespaces.join('\s*')
+    regex = Regexp.new(pattern)
+
+    # Remove comments, replace entire comment lines with "\n" to perserve num_lines
+    cleaned_string = file_string.gsub(/^;;.*/, "\n")
+    cleaned_string = cleaned_string.gsub(/;;.*/, '')
+
+    match_data = regex.match(cleaned_string)
+    num_lines = match_data[0].count("\n") + 1 unless NilClass # TODO: Find out what causes these edge cases
+
+    problem = tokens[pos]
+    line_msg = "There is a problem on line #{num_lines}"
+    line_msg = "Couldn't precise the exact line" if num_lines.is_a?(NilClass) # TODO: Find out edge cases
+
+    if tokens_before_problem[-1] == :PRINT
+      raise ParseError, "#{line_msg} with the <#{token_list['print']}> statement, needs something to print."
+    elsif tokens_before_problem[-1] == :PAUSE
+      raise ParseError, "#{line_msg} with the <#{token_list['pause']}> statement, pause needs a numeric argument."
+    elsif problem == :STOP
+      raise ParseError, "#{line_msg}. Found <#{token_list['end']}>\nEmpty if-statements and functions are not allowed"
+    else
+      raise ParseError, "#{line_msg}. Found <#{problem}>"
+    end
+  end
+end

data/lib/nodes/basenodes.rb

@@ -45,16 +45,57 @@ class BoolNode < Node
   end
 end
 
+# See ArrayNode for a more complete Data Structure
+class StringNode < Node
+  def initialize(value)
+    if value.is_a?(String)
+      super
+    else
+      super(value.join(' '))
+    end
+  end
+
+  def +(other)
+    raise NotImplementedError, 'Addition is not implemented for Strings.'
+  end
+
+  def -(other)
+    raise NotImplementedError, 'Subtraction is not implemented for Strings.'
+  end
+
+  def *(other)
+    raise NotImplementedError, 'Multiplication is not implemented for Strings.'
+  end
+
+  def /(other)
+    raise NotImplementedError, 'Division is not implemented for Strings.'
+  end
+
+  def to_i
+    @value.to_i
+  end
+
+  def to_f
+    @value.to_f
+  end
+
+  def contains?(other)
+    return if @value.include?(other)
+  end
+
+  def evaluate
+    self
+  end
+end
+
 ###################### Logic Gate Nodes
 
 class AndNode < Node
   def initialize(lhs, rhs)
     @lhs, @rhs = lhs, rhs
-    if @rhs.class.method_defined? (:lhs)
-      if @rhs.lhs == nil
-        @rhs.lhs = @lhs.lhs
-      end
-    end
+    return unless @rhs.class.method_defined?(:lhs)
+
+    @rhs.lhs = @lhs.lhs if @rhs.lhs == nil
   end
 
   def to_s
@@ -69,11 +110,9 @@ end
 class OrNode < Node
   def initialize(lhs, rhs)
     @lhs, @rhs = lhs, rhs
-    if @rhs.class.method_defined? (:lhs)
-      if @rhs.lhs == nil
-        @rhs.lhs = @lhs.lhs
-      end
-    end
+    return unless @rhs.class.method_defined?(:lhs)
+
+    @rhs.lhs = @lhs.lhs if @rhs.lhs == nil
   end
 
   def to_s

data/lib/nodes/stmtnodes.rb

@@ -306,6 +306,9 @@ class PauseNode < Node
   end
 
   def evaluate
+    # TODO: Create an Error Handler class... Needs to use rdparses functions here for a more helpful msg.
+    raise SyntaxError, 'Pause needs a numeric argument.' unless @value.evaluate.is_a?(Numeric)
+
     @value = 0 if @value.evaluate.negative?
     create_tree_entry if PRINT_TREE_FLAG
     sleep @value.evaluate

data/lib/rdparse.rb

@@ -8,6 +8,7 @@
 # 2014-02-16 New version that handles { false } blocks and :empty tokens.
 
 require 'logger'
+require_relative 'error_handler'
 
 class Rule
 
@@ -187,58 +188,6 @@ class Parser
     end # until
   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
-
-  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
-    result
-  end
-
-  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
-    tokens_before_problem = find_surrounding_code(@max_pos - 1)
-    file_as_array_without_whitespaces = translate_tokens_array(tokens_before_problem)
-
-    pattern = file_as_array_without_whitespaces.join('\s*')
-    regex = Regexp.new(pattern)
-
-    cleaned_string = @file_string.gsub(/;;.*/, '')
-
-    match_data = regex.match(cleaned_string)
-    num_lines = match_data[0].count("\n") + 1
-
-    problem = @tokens[@max_pos]
-    problem = @token_list[problem.to_s.downcase] unless @token_list[problem.to_s.downcase].is_a?(NilClass)
-
-    raise ParseError, "There is a problem around line #{num_lines}. Found <#{problem}>"
-  end
-
   def parse(string)
     # First, split the string according to the "token" instructions given.
     # Afterwards @tokens contains all tokens that are to be parsed.
@@ -259,8 +208,7 @@ class Parser
         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
+      return ErrorHandler.find_faulty_line(@max_pos, @file_string, @tokens, @token_list)
     end
     return result
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alphalang
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.3.0
 platform: ruby
 authors:
 - mattias, victor
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-12 00:00:00.000000000 Z
+date: 2024-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -60,6 +60,8 @@ extra_rdoc_files: []
 files:
 - bin/alphalang
 - lib/alpha.rb
+- lib/error_handler.rb
+- lib/error_handler.rb~
 - lib/locale_creator.rb
 - lib/locale_defaulter.rb
 - lib/locale_deleter.rb