alphalang 0.1.1

data/lib/nodes/basenodes.rb

@@ -0,0 +1,195 @@
+#!/usr/bin/env ruby
+####################################################
+
+$scopes = [{}]
+$scope_lvl = 0
+$test_nodes = false
+
+####################################################
+
+class TrueClass
+  def evaluate
+    self
+  end
+end
+
+class FalseClass
+  def evaluate
+    self
+  end
+end
+
+class String
+  def name
+    self
+  end
+
+  def evaluate
+    self
+  end
+end
+
+####################################################
+
+class Node
+  attr_accessor :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def evaluate
+    @value.evaluate
+  end
+end
+
+class NumberNode < Node
+  def initialize(value)
+    super(value)
+  end
+
+  def evaluate
+    if @value.include?('.')
+      @value.to_f
+    else
+      @value.to_i
+    end
+  end
+end
+
+class BoolNode < Node
+  def initialize(value)
+    @value = false
+    @value = true if value == "true"
+    @value = false if value == "false"
+  end
+
+  def evaluate
+    @value
+  end
+end
+
+class AndNode < Node
+  def initialize(node1, node2)
+    @node1, @node2 = node1, node2
+    if @node2.class.method_defined? (:lhs)
+      if @node2.lhs == nil
+        @node2.lhs = @node1.lhs
+      end
+    end
+  end
+
+  def evaluate
+    @node1.evaluate && @node2.evaluate
+  end
+end
+
+class OrNode < Node
+  def initialize(node1, node2)
+    @node1, @node2 = node1, node2
+    if @node2.class.method_defined? (:lhs)
+      if @node2.lhs == nil
+        @node2.lhs = @node1.lhs
+      end
+    end
+  end
+
+  def evaluate
+    @node1.evaluate || @node2.evaluate
+  end
+end
+
+class NotNode < Node
+  def initialize(node)
+    @node = node
+  end
+
+  def evaluate
+    not @node.evaluate
+  end
+end
+
+####################################################
+
+class CompareNode < Node
+  attr_accessor :lhs, :op, :rhs
+
+  def initialize(node1, op, node2)
+    @lhs, @op, @rhs = node1, op, node2
+  end
+
+  def evaluate
+    @value = @lhs.evaluate.send(@op, @rhs.evaluate)
+  end
+end
+
+class BinaryOperationNode < Node
+  attr_accessor :lhs, :op, :rhs
+
+  def initialize(lhs, op, rhs)
+    super(op)
+    @lhs, @op, @rhs = lhs, op, rhs
+  end
+
+  def evaluate
+    if @op == '/'
+      @value = @lhs.evaluate.to_f.send(@op, @rhs.evaluate)
+    else
+      @value = @lhs.evaluate.send(@op, @rhs.evaluate)
+    end
+  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 # kanske bör loopas osv??? Root blir nu sista evalueringen.
+  end
+end
+
+
+####################################################
+
+class ArgListNode < Node
+  attr_accessor :lhs, :rhs
+
+  def initialize(lhs, rhs)
+    @lhs, @rhs = lhs, rhs
+
+    if @rhs == NilClass
+      @value = [@lhs]
+    else
+      result = [@lhs]
+      @rhs.each do |element|
+        result << element
+      end
+      @value = result
+    end
+  end
+
+  def [](index)
+    @value[index]
+  end
+
+  def []=(index, value)
+    @value[index] = value
+  end
+
+  def each
+    @value.each_with_index do |val, index|
+      yield val, index
+    end
+  end
+
+  def evaluate
+    @value
+  end
+end

data/lib/nodes/stmtnodes.rb

@@ -0,0 +1,200 @@
+require_relative 'basenodes'
+
+####################################################
+class VariableCallNode < Node
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def lookup_var(name)
+    temp_scope_lvl = $scope_lvl
+    while temp_scope_lvl >= 0
+      if not $scopes[temp_scope_lvl].has_key?(name)
+        temp_scope_lvl -= 1
+      else
+        return $scopes[temp_scope_lvl][name]
+      end
+    end
+  end
+
+  def evaluate
+    return @value = lookup_var(@name)
+  end
+end
+
+class VariableDecNode < Node
+  attr_accessor :name
+
+  def initialize(name, value)
+    super(value)
+    @name = name
+  end
+
+  def evaluate
+    $scopes[$scope_lvl][@name.name] = @value.evaluate
+    self
+    # return nil
+  end
+end
+
+####################################################
+
+class FunctionDecNode < Node
+  def initialize(node, value)
+    super(value)
+    @name = node
+    @args = node.args
+  end
+
+  def evaluate
+    $scopes[0][@name.name] = [@value, @args]
+    return nil
+  end
+end
+
+class FuncCallNode < Node
+  attr_accessor :name, :args
+
+  def initialize(name, args)
+    @name = name
+    @args = args
+  end
+
+  def lookup_var(name)
+    return $scopes[0][name]
+  end
+
+  def evaluate
+    $scopes.push({})
+    func = lookup_var(@name)
+    function_body = func[0]
+    function_param = func[1]
+
+    return nil if func.is_a?(NilClass)
+
+    $scope_lvl += 1
+
+    if function_param.is_a?(ArgListNode)
+      function_param.each do |val, index|
+        function_param[index] = VariableDecNode.new(function_param[index].name, @args[index])
+        function_param[index].evaluate
+      end
+    end
+
+    func_result = function_body.evaluate
+    old_scope_lvl = $scope_lvl
+    # Om en assign är returnvärde så declareras variablen i globalt scope
+    if func_result.is_a?(VariableDecNode)
+      $scope_lvl = 0
+      func_result.evaluate
+      $scope_lvl = old_scope_lvl
+    end
+
+    $scope_lvl -= 1
+    $scopes.pop
+    return func_result
+  end
+end
+
+####################################################
+
+class IfNode < Node
+  attr_accessor :argument
+
+  def initialize(argument, node)
+    @argument, @node = argument, node
+  end
+
+  def evaluate
+    if @argument.evaluate
+      @value = @node.evaluate
+    else
+      @value = nil
+    end
+    @value
+  end
+end
+
+class ElseifNode < Node
+  attr_accessor :argument
+  def initialize(argument, node)
+    @argument, @node = argument, node
+  end
+  def evaluate
+    if @argument.evaluate
+      @value = @node.evaluate
+    end
+  end
+end
+
+class ElseNode < Node
+  attr_accessor :argument, :node
+  def initialize(node)
+    @node = node
+    @argument = true
+  end
+
+  def evaluate
+    @value = @node.evaluate
+  end
+end
+
+class IfCompStmtNode < Node
+  def initialize(*nodes)
+    @nodes = nodes.flatten
+  end
+
+  def evaluate
+    @nodes.each do |node|
+      if node.argument.evaluate
+        return node.evaluate
+      end
+    end
+    return nil
+  end
+end
+
+####################################################
+
+class WhileLoopNode < Node
+  attr_accessor :condition
+
+  def initialize(condition, statement)
+    @condition = condition
+    super(statement)
+  end
+
+  def evaluate
+    while @condition.evaluate
+      @value.evaluate
+    end
+    self.class
+  end
+end
+
+####################################################
+
+class PrintNode
+  attr_accessor :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def evaluate
+    puts @value.evaluate
+    self.class # detta kanske är trevligare än nil, åter igen den diskussionen.
+  end
+end
+
+class PauseNode < Node
+  def initialize(value)
+    super(value)
+  end
+
+  def evaluate
+    sleep @value.evaluate
+  end
+end

data/lib/rdparse.rb

@@ -0,0 +1,238 @@
+# 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)
+    @logger = parser.logger
+    # 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
+          @logger.debug("Matched '#{@name} = #{match.pattern[index..-1].inspect}'")
+        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
+            @logger.debug("Matched token '#{nt}' as part of rule '#{@name} <= #{pattern.inspect}'")
+          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
+        @logger.debug("'#{@parser.string[start..@parser.pos-1]}' matched '#{@name}' and generated '#{match_result.inspect}'") unless match_result.nil?
+        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
+
+    @logger = Logger.new(STDOUT)
+    @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
+          @logger.debug("Token #{match[0]} consumed as #{match[0]}")
+          # 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