turmali 0.0.1

data/lib/turmali/interpreter.rb

@@ -0,0 +1,156 @@
+require "turmali/parser"
+require "turmali/runtime/object"
+require "turmali/runtime/method"
+require "turmali/runtime/context"
+require "turmali/runtime/class"
+require "turmali/runtime/bootstrap"
+
+# First, we create an simple wrapper class to encapsulate the interpretation process.
+# All this does is parse the code and call `eval` on the node at the top of the AST.
+class Interpreter
+  def initialize
+    @parser = Parser.new
+  end
+  
+  def eval(code)
+    @parser.parse(code).eval(RootContext)
+  end
+end
+
+# The `Nodes` class will always be at the top of the AST. Its only purpose it to
+# contain other nodes. It correspond to a block of code or a series of expressions.
+# 
+# The `eval` method of every node is the "interpreter" part of our language.
+# All nodes know how to evalualte themselves and return the result of their evaluation.
+# The `context` variable is the `Context` in which the node is evaluated (local
+# variables, current self and current class).
+class Nodes
+  def eval(context)
+    return_value = nil
+    nodes.each do |node|
+      return_value = node.eval(context)
+    end
+    return_value || Constants["nil"] # Last result is return value (or nil if none).
+  end
+end
+
+# We're using `Constants` that we created before when bootstrapping the runtime to access
+# the objects and classes from inside the runtime.
+#
+# Next, we implement `eval` on other node types. Think of that `eval` method as how the
+# node bring itself to life inside the runtime.
+class NumberNode
+  def eval(context)
+    Constants["Number"].new_with_value(value)
+  end
+end
+
+class StringNode
+  def eval(context)
+    Constants["String"].new_with_value(value)
+  end
+end
+
+class TrueNode
+  def eval(context)
+    Constants["true"]
+  end
+end
+
+class FalseNode
+  def eval(context)
+    Constants["false"]
+  end
+end
+
+class NilNode
+  def eval(context)
+    Constants["nil"]
+  end
+end
+
+class GetConstantNode
+  def eval(context)
+    Constants[name]
+  end
+end
+
+class GetLocalNode
+  def eval(context)
+    context.locals[name]
+  end
+end
+
+# When setting the value of a constant or a local variable, the `value` attribute
+# is a node, created by the parser. We need to evaluate the node first, to convert
+# it to an object, before storing it into a variable or constant.
+class SetConstantNode
+  def eval(context)
+    Constants[name] = value.eval(context)
+  end
+end
+
+class SetLocalNode
+  def eval(context)
+    context.locals[name] = value.eval(context)
+  end
+end
+
+# The `CallNode` for calling a method is a little more complex. It needs to set the receiver
+# first and then evaluate the arguments before calling the method.
+class CallNode
+  def eval(context)
+    if receiver
+      value = receiver.eval(context)
+    else
+      value = context.current_self # Default to `self` if no receiver.
+    end
+    
+    evaluated_arguments = arguments.map { |arg| arg.eval(context) }
+    value.call(method, evaluated_arguments)
+  end
+end
+
+# Defining a method, using the `def` keyword, is done by adding a method to the current class.
+class DefNode
+  def eval(context)
+    method = TurmaliMethod.new(params, body)
+    context.current_class.runtime_methods[name] = method
+  end
+end
+
+# Defining a class is done in three steps:
+#
+# 1. Reopen or define the class.
+# 2. Create a special context of evaluation (set `current_self` and `current_class` to the new class).
+# 3. Evaluate the body of the class inside that context.
+#
+# Check back how `DefNode` was implemented, adding methods to `context.current_class`. Here is
+# where we set the value of `current_class`.
+class ClassNode
+  def eval(context)
+    turmali_class = Constants[name] # Check if class is already defined
+    
+    unless turmali_class # Class doesn't exist yet
+      turmali_class = TurmaliClass.new
+      Constants[name] = turmali_class # Define the class in the runtime
+    end
+    
+    class_context = Context.new(turmali_class, turmali_class)
+    body.eval(class_context)
+    
+    turmali_class
+  end
+end
+
+# Finally, to implement `if` in our language,
+# we turn the condition node into a Ruby value to use Ruby's `if`.
+class IfNode
+  def eval(context)
+    if condition.eval(context).ruby_value
+      body.eval(context)
+    else # If no body is evaluated, we return nil.
+      Constants["nil"]
+    end
+  end
+end

data/lib/turmali/lexer.rb

@@ -0,0 +1,129 @@
+# Our lexer will be used like so: `Lexer.new.tokenize("code")`,
+# and will return an array of tokens (a token being a tuple of `[TOKEN_TYPE, TOKEN_VALUE]`).
+class Lexer
+  # First we define the special keywords of our language in a constant.
+  # It will be used later on in the tokenizing process to disambiguate
+  # an identifier (method name, local variable, etc.) from a keyword.
+  KEYWORDS = ["def", "class", "if", "true", "false", "nil"]
+  
+  def tokenize(code)
+    code.chomp! # Remove extra line breaks
+    tokens = [] # This will hold the generated tokens
+    
+    # We need to know how deep we are in the indentation so
+    # we keep track of the current indentation level we are in, and previous ones in the stack
+    # so that when we dedent, we can check if we're on the correct level.
+    current_indent = 0 # number of spaces in the last indent
+    indent_stack = []
+    
+    # Here is how to implement a very simple scanner.
+    # Advance one character at the time until you find something to parse.
+    # We'll use regular expressions to scan from the current position (`i`)
+    # up to the end of the code.
+    i = 0 # Current character position
+    while i < code.size
+      chunk = code[i..-1]
+      
+      # Each of the following `if/elsif`s will test the current code chunk with
+      # a regular expression. The order is important as we want to match `if`
+      # as a keyword, and not a method name, we'll need to apply it first.
+      #
+      # First, we'll scan for names: method names and variable names, which we'll call identifiers.
+      # Also scanning for special reserved keywords such as `if`, `def`
+      # and `true`.
+      if identifier = chunk[/\A([a-z]\w*)/, 1]
+        if KEYWORDS.include?(identifier) # keywords will generate [:IF, "if"]
+          tokens << [identifier.upcase.to_sym, identifier]
+        else
+          tokens << [:IDENTIFIER, identifier]
+        end
+        i += identifier.size # skip what we just parsed
+      
+      # Now scanning for constants, names starting with a capital letter.
+      # Which means, class names are constants in our language.
+      elsif constant = chunk[/\A([A-Z]\w*)/, 1]
+        tokens << [:CONSTANT, constant]
+        i += constant.size
+        
+      # Next, matching numbers. Our language will only support integers. But to add support for floats,
+      # you'd simply need to add a similar rule and adapt the regular expression accordingly.
+      elsif number = chunk[/\A([0-9]+)/, 1]
+        tokens << [:NUMBER, number.to_i]
+        i += number.size
+        
+      # Of course, matching strings too. Anything between `"..."`.
+      elsif string = chunk[/\A"([^"]*)"/, 1]
+        tokens << [:STRING, string]
+        i += string.size + 2 # skip two more to exclude the `"`.
+      
+      # And here's the indentation magic! We have to take care of 3 cases:
+      # 
+      #     if true:  # 1) The block is created.
+      #       line 1
+      #       line 2  # 2) New line inside a block, at the same level.
+      #     continue  # 3) Dedent.
+      #
+      # This `elsif` takes care of the first case. The number of spaces will determine 
+      # the indent level.
+      elsif indent = chunk[/\A\:\n( +)/m, 1] # Matches ": <newline> <spaces>"
+        if indent.size <= current_indent # indent should go up when creating a block
+          raise "Bad indent level, got #{indent.size} indents, " +
+                "expected > #{current_indent}"
+        end
+        current_indent = indent.size
+        indent_stack.push(current_indent)
+        tokens << [:INDENT, indent.size]
+        i += indent.size + 2
+  
+      # The next `elsif` takes care of the two last cases:
+      #
+      # * Case 2: We stay in the same block if the indent level (number of spaces) is the
+      #   same as `current_indent`.
+      # * Case 3: Close the current block, if indent level is lower than `current_indent`.
+      elsif indent = chunk[/\A\n( *)/m, 1] # Matches "<newline> <spaces>"
+        if indent.size == current_indent # Case 2
+          tokens << [:NEWLINE, "\n"] # Nothing to do, we're still in the same block
+        elsif indent.size < current_indent # Case 3
+          while indent.size < current_indent
+            indent_stack.pop
+            current_indent = indent_stack.last || 0
+            tokens << [:DEDENT, indent.size]
+          end
+          tokens << [:NEWLINE, "\n"]
+        else # indent.size > current_indent, error!
+          raise "Missing ':'" # Cannot increase indent level without using ":"
+        end
+        i += indent.size + 1
+      
+      # Long operators such as `||`, `&&`, `==`, etc.
+      # will be matched by the following block.
+      # One character long operators are matched by the catch all `else` at the bottom.
+      elsif operator = chunk[/\A(\|\||&&|==|!=|<=|>=)/, 1]
+        tokens << [operator, operator]
+        i += operator.size
+      
+      # We're ignoring spaces. Contrary to line breaks, spaces are meaningless in our language.
+      # That's why we don't create tokens for them. They are only used to separate other tokens.
+      elsif chunk.match(/\A /)
+        i += 1
+      
+      # Finally, catch all single characters, mainly operators.
+      # We treat all other single characters as a token. Eg.: `( ) , . ! + - <`.
+      else
+        value = chunk[0,1]
+        tokens << [value, value]
+        i += 1
+        
+      end
+      
+    end
+    
+    # Close all open blocks. If the code ends without dedenting, this will take care of
+    # balancing the `INDENT`...`DEDENT`s.
+    while indent = indent_stack.pop
+      tokens << [:DEDENT, indent_stack.first || 0]
+    end
+    
+    tokens
+  end
+end

data/lib/turmali/nodes.rb

@@ -0,0 +1,88 @@
+# The first type is responsible for holding a collection of nodes,
+# each one representing an expression. You can think of it as the internal
+# representation of a block of code.
+#
+# Here we define nodes as Ruby classes that inherit from a `Struct`. This is a
+# simple way, in Ruby, to create a class that holds some attributes (values).
+# It is almost equivalent to:
+# 
+#     class Nodes
+#       def initialize(nodes)
+#         @nodes = nodes
+#       end
+#
+#       def nodes
+#         @nodes
+#       end
+#     end
+#
+#     n = Nodes.new("this is stored @nodes")
+#     n.nodes # => "this is stored @nodes"
+#
+# But Ruby's `Struct` takes care of overriding the `==` operator for us and a bunch of
+# other things that will make testing easier.
+class Nodes < Struct.new(:nodes)
+  def <<(node) # Useful method for adding a node on the fly.
+    nodes << node
+    self
+  end
+end
+
+# Literals are static values that have a Ruby representation. For example, a string, a number, 
+# `true`, `false`, `nil`, etc. We define a node for each one of those and store their Ruby
+# representation inside their `value` attribute.
+class LiteralNode < Struct.new(:value); end
+
+class NumberNode < LiteralNode; end
+
+class StringNode < LiteralNode; end
+
+class TrueNode < LiteralNode
+  def initialize
+    super(true)
+  end
+end
+
+class FalseNode < LiteralNode
+  def initialize
+    super(false)
+  end
+end
+
+class NilNode < LiteralNode
+  def initialize
+    super(nil)
+  end
+end
+
+# The node for a method call holds the `receiver`,
+# the object on which the method is called, the `method` name and its
+# arguments, which are other nodes.
+class CallNode < Struct.new(:receiver, :method, :arguments); end
+
+# Retrieving the value of a constant by its `name` is done by the following node.
+class GetConstantNode < Struct.new(:name); end
+
+# And setting its value is done by this one. The `value` will be a node. If we're
+# storing a number inside a constant, for example, `value` would contain an instance
+# of `NumberNode`.
+class SetConstantNode < Struct.new(:name, :value); end
+
+# Similar to the previous nodes, the next ones are for dealing with local variables.
+class GetLocalNode < Struct.new(:name); end
+
+class SetLocalNode < Struct.new(:name, :value); end
+
+# Each method definition will be stored into the following node. It holds the `name` of the method,
+# the name of its parameters (`params`) and the `body` to evaluate when the method is called, which
+# is a tree of node, the root one being a `Nodes` instance.
+class DefNode < Struct.new(:name, :params, :body); end
+
+# Class definitions are stored into the following node. Once again, the `name` of the class and
+# its `body`, a tree of nodes.
+class ClassNode < Struct.new(:name, :body); end
+
+# `if` control structures are stored in a node of their own. The `condition` and `body` will also
+# be nodes that need to be evaluated at some point.
+# Look at this node if you want to implement other control structures like `while`, `for`, `loop`, etc.
+class IfNode  < Struct.new(:condition, :body); end

data/lib/turmali/parser.rb

@@ -0,0 +1,683 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.6
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+require "turmali/lexer"
+require "turmali/nodes"
+
+class Parser < Racc::Parser
+
+module_eval(<<'...end grammar.y/module_eval...', 'grammar.y', 220)
+  def parse(code, show_tokens=false)
+    @tokens = Lexer.new.tokenize(code) # Tokenize the code using our lexer
+    puts @tokens.inspect if show_tokens
+    do_parse # Kickoff the parsing process
+  end
+  
+  def next_token
+    @tokens.shift
+  end
+...end grammar.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    27,    25,    26,    16,    18,    19,    20,    21,    22,    23,
+    24,    27,    25,    26,    16,    18,    19,    20,    21,    22,
+    23,    24,    30,    72,    41,    42,    39,    40,    53,    15,
+    30,    17,    41,    42,    39,    40,    30,    16,    16,    30,
+    15,    74,    17,    27,    25,    26,    84,    18,    19,    20,
+    21,    22,    23,    24,    27,    25,    26,    45,    18,    19,
+    20,    21,    22,    23,    24,    17,    17,    30,    72,    41,
+    42,    47,    15,    68,    30,    82,    41,    42,    39,    40,
+    27,    25,    26,    15,    18,    19,    20,    21,    22,    23,
+    24,    27,    25,    26,    48,    18,    19,    20,    21,    22,
+    23,    24,    30,    28,    41,    42,    27,    25,    26,    15,
+    18,    19,    20,    21,    22,    23,    24,    27,    25,    26,
+    15,    18,    19,    20,    21,    22,    23,    24,    86,    79,
+    85,    78,    27,    25,    26,    15,    18,    19,    20,    21,
+    22,    23,    24,    27,    25,    26,    15,    18,    19,    20,
+    21,    22,    23,    24,    46,    49,    45,    51,    27,    25,
+    26,    15,    18,    19,    20,    21,    22,    23,    24,    27,
+    25,    26,    15,    18,    19,    20,    21,    22,    23,    24,
+    72,    88,   nil,   nil,    27,    25,    26,    15,    18,    19,
+    20,    21,    22,    23,    24,    27,    25,    26,    15,    18,
+    19,    20,    21,    22,    23,    24,   nil,   nil,   nil,   nil,
+    27,    25,    26,    15,    18,    19,    20,    21,    22,    23,
+    24,    27,    25,    26,    15,    18,    19,    20,    21,    22,
+    23,    24,   nil,   nil,   nil,   nil,    27,    25,    26,    15,
+    18,    19,    20,    21,    22,    23,    24,    27,    25,    26,
+    15,    18,    19,    20,    21,    22,    23,    24,   nil,   nil,
+   nil,   nil,    27,    25,    26,    15,    18,    19,    20,    21,
+    22,    23,    24,    27,    25,    26,    15,    18,    19,    20,
+    21,    22,    23,    24,   nil,   nil,   nil,   nil,    27,    25,
+    26,    15,    18,    19,    20,    21,    22,    23,    24,   nil,
+   nil,    30,    15,    41,    42,    39,    40,    35,    36,    37,
+    38,    33,    34,    32,    31,   nil,   nil,    15,    66,    72,
+   nil,    30,   nil,    41,    42,    39,    40,    35,    36,    37,
+    38,    33,    34,    32,    31,    30,   nil,    41,    42,    39,
+    40,    35,    36,    37,    38,    33,    34,    32,    31,    30,
+   nil,    41,    42,    39,    40,    35,    36,    37,    38,    33,
+    34,    32,    31,    30,   nil,    41,    42,    39,    40,    35,
+    36,    37,    38,    33,    34,    32,    31,    30,   nil,    41,
+    42,    39,    40,    35,    36,    37,    38,    33,    34,    32,
+    31,    30,   nil,    41,    42,    39,    40,    35,    36,    37,
+    38,    33,    34,    32,    31,    30,   nil,    41,    42,    39,
+    40,    35,    36,    37,    38,    33,    34,    32,    31,    30,
+   nil,    41,    42,    39,    40,    35,    36,    37,    38,    33,
+    34,    32,    30,   nil,    41,    42,    39,    40,    35,    36,
+    37,    38,    33,    34,    30,   nil,    41,    42,    39,    40,
+    35,    36,    37,    38,    30,   nil,    41,    42,    39,    40,
+    35,    36,    37,    38,    30,   nil,    41,    42,    39,    40 ]
+
+racc_action_check = [
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,    72,    72,    72,    72,    72,    72,    72,    72,    72,
+    72,    72,    61,    48,    61,    61,    61,    61,    30,     0,
+    60,     0,    60,    60,    60,    60,    64,    80,     2,    65,
+    72,    48,    72,    45,    45,    45,    80,    45,    45,    45,
+    45,    45,    45,    45,    29,    29,    29,    53,    29,    29,
+    29,    29,    29,    29,    29,    80,     2,    62,    49,    62,
+    62,    24,    45,    45,    58,    74,    58,    58,    58,    58,
+    15,    15,    15,    29,    15,    15,    15,    15,    15,    15,
+    15,    40,    40,    40,    25,    40,    40,    40,    40,    40,
+    40,    40,    63,     1,    63,    63,    41,    41,    41,    15,
+    41,    41,    41,    41,    41,    41,    41,    47,    47,    47,
+    40,    47,    47,    47,    47,    47,    47,    47,    81,    69,
+    81,    69,    46,    46,    46,    41,    46,    46,    46,    46,
+    46,    46,    46,    27,    27,    27,    47,    27,    27,    27,
+    27,    27,    27,    27,    23,    26,    23,    28,    39,    39,
+    39,    46,    39,    39,    39,    39,    39,    39,    39,    79,
+    79,    79,    27,    79,    79,    79,    79,    79,    79,    79,
+    85,    86,   nil,   nil,    42,    42,    42,    39,    42,    42,
+    42,    42,    42,    42,    42,    38,    38,    38,    79,    38,
+    38,    38,    38,    38,    38,    38,   nil,   nil,   nil,   nil,
+    32,    32,    32,    42,    32,    32,    32,    32,    32,    32,
+    32,    33,    33,    33,    38,    33,    33,    33,    33,    33,
+    33,    33,   nil,   nil,   nil,   nil,    34,    34,    34,    32,
+    34,    34,    34,    34,    34,    34,    34,    35,    35,    35,
+    33,    35,    35,    35,    35,    35,    35,    35,   nil,   nil,
+   nil,   nil,    36,    36,    36,    34,    36,    36,    36,    36,
+    36,    36,    36,    37,    37,    37,    35,    37,    37,    37,
+    37,    37,    37,    37,   nil,   nil,   nil,   nil,    31,    31,
+    31,    36,    31,    31,    31,    31,    31,    31,    31,   nil,
+   nil,    43,    37,    43,    43,    43,    43,    43,    43,    43,
+    43,    43,    43,    43,    43,   nil,   nil,    31,    43,    50,
+   nil,    50,   nil,    50,    50,    50,    50,    50,    50,    50,
+    50,    50,    50,    50,    50,     3,   nil,     3,     3,     3,
+     3,     3,     3,     3,     3,     3,     3,     3,     3,    52,
+   nil,    52,    52,    52,    52,    52,    52,    52,    52,    52,
+    52,    52,    52,    83,   nil,    83,    83,    83,    83,    83,
+    83,    83,    83,    83,    83,    83,    83,    70,   nil,    70,
+    70,    70,    70,    70,    70,    70,    70,    70,    70,    70,
+    70,    71,   nil,    71,    71,    71,    71,    71,    71,    71,
+    71,    71,    71,    71,    71,    67,   nil,    67,    67,    67,
+    67,    67,    67,    67,    67,    67,    67,    67,    67,    54,
+   nil,    54,    54,    54,    54,    54,    54,    54,    54,    54,
+    54,    54,    55,   nil,    55,    55,    55,    55,    55,    55,
+    55,    55,    55,    55,    57,   nil,    57,    57,    57,    57,
+    57,    57,    57,    57,    56,   nil,    56,    56,    56,    56,
+    56,    56,    56,    56,    59,   nil,    59,    59,    59,    59 ]
+
+racc_action_pointer = [
+    -2,   103,    33,   320,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,    78,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   125,    42,    83,   143,   141,   157,    52,
+    17,   286,   208,   219,   234,   245,   260,   271,   193,   156,
+    89,   104,   182,   286,   nil,    41,   130,   115,    10,    55,
+   306,   nil,   334,    26,   404,   417,   439,   429,    59,   449,
+    15,     7,    52,    87,    21,    24,   nil,   390,   nil,    99,
+   362,   376,     9,   nil,    64,   nil,   nil,   nil,   nil,   167,
+    32,    98,   nil,   348,   nil,   167,   170,   nil,   nil ]
+
+racc_action_default = [
+    -1,   -56,    -2,    -3,    -6,    -7,    -8,    -9,   -10,   -11,
+   -12,   -13,   -14,   -15,   -16,   -56,   -18,   -19,   -20,   -21,
+   -22,   -23,   -24,   -46,   -44,   -56,   -56,   -56,   -56,    -5,
+   -56,   -56,   -56,   -56,   -56,   -56,   -56,   -56,   -56,   -56,
+   -56,   -56,   -56,   -56,   -25,   -56,   -56,   -56,   -56,   -56,
+   -56,    89,    -4,   -27,   -32,   -33,   -34,   -35,   -36,   -37,
+   -38,   -39,   -40,   -41,   -42,   -43,   -17,   -30,   -28,   -56,
+   -47,   -45,   -56,   -49,   -51,   -54,   -55,   -26,   -29,   -56,
+   -56,   -56,   -52,   -31,   -48,   -56,   -56,   -50,   -53 ]
+
+racc_goto_table = [
+    29,     2,    43,    73,    75,    76,    44,     1,    69,    81,
+   nil,   nil,   nil,   nil,    50,   nil,    52,   nil,    54,    55,
+    56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
+   nil,   nil,    67,    70,    71,   nil,    77,   nil,   nil,   nil,
+    87,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,    83,   nil,   nil,   nil,
+   nil,   nil,   nil,    80,   nil,   nil,   nil,   nil,    29 ]
+
+racc_goto_check = [
+     4,     2,     3,    17,    17,    17,    15,     1,    16,    18,
+   nil,   nil,   nil,   nil,     3,   nil,     3,   nil,     3,     3,
+     3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+   nil,   nil,     3,     3,     3,   nil,    15,   nil,   nil,   nil,
+    17,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,     3,   nil,   nil,   nil,
+   nil,   nil,   nil,     2,   nil,   nil,   nil,   nil,     4 ]
+
+racc_goto_pointer = [
+   nil,     7,     1,   -13,    -2,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   -17,   -37,   -45,   -65 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,     3,     4,     5,     6,     7,     8,     9,
+    10,    11,    12,    13,    14,   nil,   nil,   nil,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  0, 35, :_reduce_1,
+  1, 35, :_reduce_2,
+  1, 36, :_reduce_3,
+  3, 36, :_reduce_4,
+  2, 36, :_reduce_5,
+  1, 36, :_reduce_6,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  3, 37, :_reduce_17,
+  1, 38, :_reduce_none,
+  1, 38, :_reduce_none,
+  1, 39, :_reduce_20,
+  1, 39, :_reduce_21,
+  1, 39, :_reduce_22,
+  1, 39, :_reduce_23,
+  1, 39, :_reduce_24,
+  2, 40, :_reduce_25,
+  4, 40, :_reduce_26,
+  3, 40, :_reduce_27,
+  2, 49, :_reduce_28,
+  3, 49, :_reduce_29,
+  1, 50, :_reduce_30,
+  3, 50, :_reduce_31,
+  3, 41, :_reduce_32,
+  3, 41, :_reduce_33,
+  3, 41, :_reduce_34,
+  3, 41, :_reduce_35,
+  3, 41, :_reduce_36,
+  3, 41, :_reduce_37,
+  3, 41, :_reduce_38,
+  3, 41, :_reduce_39,
+  3, 41, :_reduce_40,
+  3, 41, :_reduce_41,
+  3, 41, :_reduce_42,
+  3, 41, :_reduce_43,
+  1, 42, :_reduce_44,
+  3, 43, :_reduce_45,
+  1, 44, :_reduce_46,
+  3, 45, :_reduce_47,
+  3, 51, :_reduce_48,
+  3, 46, :_reduce_49,
+  6, 46, :_reduce_50,
+  0, 52, :_reduce_51,
+  1, 52, :_reduce_52,
+  3, 52, :_reduce_53,
+  3, 47, :_reduce_54,
+  3, 48, :_reduce_55 ]
+
+racc_reduce_n = 56
+
+racc_shift_n = 89
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :IF => 2,
+  :DEF => 3,
+  :CLASS => 4,
+  :NEWLINE => 5,
+  :NUMBER => 6,
+  :STRING => 7,
+  :TRUE => 8,
+  :FALSE => 9,
+  :NIL => 10,
+  :IDENTIFIER => 11,
+  :CONSTANT => 12,
+  :INDENT => 13,
+  :DEDENT => 14,
+  "." => 15,
+  "!" => 16,
+  "*" => 17,
+  "/" => 18,
+  "+" => 19,
+  "-" => 20,
+  ">" => 21,
+  ">=" => 22,
+  "<" => 23,
+  "<=" => 24,
+  "==" => 25,
+  "!=" => 26,
+  "&&" => 27,
+  "||" => 28,
+  "=" => 29,
+  "," => 30,
+  "(" => 31,
+  ")" => 32,
+  ";" => 33 }
+
+racc_nt_base = 34
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "IF",
+  "DEF",
+  "CLASS",
+  "NEWLINE",
+  "NUMBER",
+  "STRING",
+  "TRUE",
+  "FALSE",
+  "NIL",
+  "IDENTIFIER",
+  "CONSTANT",
+  "INDENT",
+  "DEDENT",
+  "\".\"",
+  "\"!\"",
+  "\"*\"",
+  "\"/\"",
+  "\"+\"",
+  "\"-\"",
+  "\">\"",
+  "\">=\"",
+  "\"<\"",
+  "\"<=\"",
+  "\"==\"",
+  "\"!=\"",
+  "\"&&\"",
+  "\"||\"",
+  "\"=\"",
+  "\",\"",
+  "\"(\"",
+  "\")\"",
+  "\";\"",
+  "$start",
+  "Program",
+  "Expressions",
+  "Expression",
+  "Terminator",
+  "Literal",
+  "Call",
+  "Operator",
+  "GetConstant",
+  "SetConstant",
+  "GetLocal",
+  "SetLocal",
+  "Def",
+  "Class",
+  "If",
+  "Arguments",
+  "ArgList",
+  "Block",
+  "ParamList" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'grammar.y', 49)
+  def _reduce_1(val, _values, result)
+     result = Nodes.new([]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 50)
+  def _reduce_2(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 67)
+  def _reduce_3(val, _values, result)
+     result = Nodes.new(val) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 68)
+  def _reduce_4(val, _values, result)
+     result = val[0] << val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 69)
+  def _reduce_5(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 70)
+  def _reduce_6(val, _values, result)
+     result = Nodes.new([]) 
+    result
+  end
+.,.,
+
+# reduce 7 omitted
+
+# reduce 8 omitted
+
+# reduce 9 omitted
+
+# reduce 10 omitted
+
+# reduce 11 omitted
+
+# reduce 12 omitted
+
+# reduce 13 omitted
+
+# reduce 14 omitted
+
+# reduce 15 omitted
+
+# reduce 16 omitted
+
+module_eval(<<'.,.,', 'grammar.y', 85)
+  def _reduce_17(val, _values, result)
+     result = val[1] 
+    result
+  end
+.,.,
+
+# reduce 18 omitted
+
+# reduce 19 omitted
+
+module_eval(<<'.,.,', 'grammar.y', 103)
+  def _reduce_20(val, _values, result)
+     result = NumberNode.new(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 104)
+  def _reduce_21(val, _values, result)
+     result = StringNode.new(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 105)
+  def _reduce_22(val, _values, result)
+     result = TrueNode.new 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 106)
+  def _reduce_23(val, _values, result)
+     result = FalseNode.new 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 107)
+  def _reduce_24(val, _values, result)
+     result = NilNode.new 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 119)
+  def _reduce_25(val, _values, result)
+     result = CallNode.new(nil, val[0], val[1]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 121)
+  def _reduce_26(val, _values, result)
+     result = CallNode.new(val[0], val[2], val[3]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 122)
+  def _reduce_27(val, _values, result)
+     result = CallNode.new(val[0], val[2], []) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 126)
+  def _reduce_28(val, _values, result)
+     result = [] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 127)
+  def _reduce_29(val, _values, result)
+     result = val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 131)
+  def _reduce_30(val, _values, result)
+     result = val 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 132)
+  def _reduce_31(val, _values, result)
+     result = val[0] << val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 143)
+  def _reduce_32(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 144)
+  def _reduce_33(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 145)
+  def _reduce_34(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 146)
+  def _reduce_35(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 147)
+  def _reduce_36(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 148)
+  def _reduce_37(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 149)
+  def _reduce_38(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 150)
+  def _reduce_39(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 151)
+  def _reduce_40(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 152)
+  def _reduce_41(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 153)
+  def _reduce_42(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 154)
+  def _reduce_43(val, _values, result)
+     result = CallNode.new(val[0], val[1], [val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 159)
+  def _reduce_44(val, _values, result)
+     result = GetConstantNode.new(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 163)
+  def _reduce_45(val, _values, result)
+     result = SetConstantNode.new(val[0], val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 167)
+  def _reduce_46(val, _values, result)
+     result = GetLocalNode.new(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 171)
+  def _reduce_47(val, _values, result)
+     result = SetLocalNode.new(val[0], val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 183)
+  def _reduce_48(val, _values, result)
+     result = val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 189)
+  def _reduce_49(val, _values, result)
+     result = DefNode.new(val[1], [], val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 191)
+  def _reduce_50(val, _values, result)
+     result = DefNode.new(val[1], val[3], val[5]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 195)
+  def _reduce_51(val, _values, result)
+     result = [] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 196)
+  def _reduce_52(val, _values, result)
+     result = val 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 197)
+  def _reduce_53(val, _values, result)
+     result = val[0] << val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 203)
+  def _reduce_54(val, _values, result)
+     result = ClassNode.new(val[1], val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 208)
+  def _reduce_55(val, _values, result)
+     result = IfNode.new(val[1], val[2]) 
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+end   # class Parser