eleetscript 0.0.2a

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e792bada3731aaa44a090f809417bdecadce8872
+  data.tar.gz: aef6dd9deb080c59562f72ad574fed5d9bb7a345
+SHA512:
+  metadata.gz: c519caee6985956c60165f6d5f35f9c07c336249483c49ad46e171c50c5ffafcdc11780fe1ac2b8371e40608f11a4c9f1dcbde0dde28fbcd04684edcf2ab9935
+  data.tar.gz: b2c6387ce4f580c955a778d2810a755eb5ca2b4bd454b68976ef9723e421c649aeebf46d7457b96df62a1a29226a32fe38e8008c2d3e23cc34e78280172441dc

data/bin/eleet

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+require "readline"
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "lang/interpreter"
+
+def exit_repl
+  puts "\n\nExiting EleetScript REPL"
+  exit
+end
+
+Signal.trap("INT") do
+  exit_repl
+end
+
+interp = ES::Interpreter.new
+@lexer = ES::Lexer.new
+
+if ARGV.empty?
+  show_nodes = false
+  interp.memory.root_namespace["Object"].def :__repl_show_nodes do |receiver, arguments|
+    bool = !!arguments.first.ruby_value
+    show_nodes = bool
+    arguments.first
+  end
+
+  interp.memory.root_namespace["Object"].def :exit do |receiver, arguments|
+    exit_repl
+  end
+
+  def depth(code)
+    begin
+      tokens = @lexer.tokenize(code)
+    rescue
+      return 0
+    end
+    depth = 0
+    tokens.each do |token|
+      depth += 1 if ["class", "do", "while", "if",  "(", "namespace", "{"].include?(token[1])
+      depth -= 1 if ["end", ")", "}"].include?(token[1])
+    end
+    depth
+  end
+
+  line = 1
+  line_depth = 0
+  code = ""
+
+  while true
+    prompt = if line_depth > 0
+      spaces = "  " * line_depth
+      stars = line.to_s.gsub(/./, "*")
+      "#{stars} >> #{spaces}"
+    else
+      "#{line} >> "
+    end
+    input = Readline.readline(prompt, true)
+    if code.length > 0
+      input = code + "\n" + input
+    end
+    if depth(input) == 0
+      begin
+        value = interp.eval(input, show_nodes)
+      rescue => e
+        puts "Error: #{e.message}"
+        next
+      end
+      if value.kind_of?(ES::EleetScriptClass) || value.kind_of?(ES::EleetScriptClassInstance)
+        if ["Integer", "Float", "String", "TrueClass", "FalseClass", "NilClass"].include?(value.class_name)
+          puts " => #{value.ruby_value.inspect}"
+        else
+          puts " => #{value.call(:inspect).ruby_value}"
+        end
+      else
+        puts "Improper value returned"
+        p value
+      end
+      line_depth = 0
+      code = ""
+    else
+      line_depth = depth(input)
+      line_depth = 0 if line_depth < 0
+      code = input
+    end
+    line += 1
+  end
+elsif File.exists?(ARGV[0])
+  interp.eval(File.read(ARGV[0]))
+end

data/lib/eleetscript.rb

@@ -0,0 +1,18 @@
+module EleetScript
+  class LexicalError < RuntimeError
+    def initialize(char, line)
+      @char = char
+      @line = line
+    end
+
+    def message
+      "Unknown character encountered '#{@char}' on line ##{@line}"
+    end
+  end
+
+  class ParseError < RuntimeError; end
+end
+
+ES = EleetScript
+
+require "lang/interpreter"

data/lib/engine/eleet_engine.rb

@@ -0,0 +1,58 @@
+require "lang/runtime/memory"
+require "lang/interpreter"
+require "engine/values"
+
+module EleetScript
+  class Engine
+    def initialize
+      @memory = Memory.new
+      @interpreter = Interpreter.new(@memory)
+    end
+
+    def execute(code)
+      to_ruby_value(@interpreter.eval(code))
+    end
+
+    def call(method, *args)
+      # TODO: Finish
+      to_ruby_value(@interpreter.eval("#{method.to_s}"))
+    end
+
+    def get(var, raw = false)
+      value = @memory.root_namespace[var]
+      if raw
+        value
+      else
+        to_ruby_value(value)
+      end
+    end
+
+    def set(var, value)
+      nesting = var.split("::")
+      ns = @memory.root_namespace
+      var = nesting.pop
+      nesting.each do |new_ns|
+        ns = ns.namespace(new_ns)
+      end
+      if var[0] =~ /[A-Z]/
+        if ns.constants.has_key?(var)
+          @memory.root_namespace["Errors"].call("<", [@memory.root_namespace["String"].new_with_value("Cannot reassign constant via the Engine.")])
+          return false
+        else
+          ns[var] = to_eleet_value(value)
+        end
+      else
+        ns[var] = to_eleet_value(value)
+      end
+      true
+    end
+
+    def to_eleet_value(value)
+      Values.to_eleet_value(value, self)
+    end
+
+    def to_ruby_value(value)
+      Values.to_ruby_value(value, self)
+    end
+  end
+end

data/lib/engine/eleet_to_ruby_wrapper.rb

@@ -0,0 +1,25 @@
+module EleetScript
+  class EleetToRubyWrapper
+    def initialize(eleet_obj, engine)
+      @eleet_obj = eleet_obj
+      @engine = engine
+    end
+
+    def call(method, *args)
+      eleet_args = args.map { |a| Values.to_eleet_value(a, @engine) }
+      Values.to_ruby_value(@eleet_obj.call(method, eleet_args), @engine)
+    end
+
+    def method_missing(name, *args)
+      if args && args.length > 0
+        call(name, *args)
+      else
+        call(name)
+      end
+    end
+
+    def raw
+      @eleet_obj
+    end
+  end
+end

data/lib/engine/ruby_to_eleet_wrapper.rb

@@ -0,0 +1,22 @@
+module EleetScript
+  class RubyToEleetWrapper
+    def initialize(ruby_obj, engine)
+      @ruby_obj = ruby_obj
+      @engine = engine
+    end
+
+    def call(method_name, args)
+      binding.pry
+      ruby_args = args.map { |arg| Values.to_ruby_value(arg, @engine) }
+      if @ruby_obj.respond_to?(method_name)
+        Values.to_eleet_value(@ruby_obj.send(method_name, *ruby_args), @engine)
+      else
+        Values.to_eleet_value(@engine.get("nil"), @engine)
+      end
+    end
+
+    def raw
+      @ruby_obj
+    end
+  end
+end

data/lib/engine/values.rb

@@ -0,0 +1,55 @@
+require "bigdecimal"
+require "engine/eleet_to_ruby_wrapper"
+require "engine/ruby_to_eleet_wrapper"
+
+module EleetScript
+  module Values
+    class << self
+      def to_eleet_value(ruby_obj, engine)
+        memory = if engine.kind_of?(Memory)
+          engine
+        else
+          engine.instance_variable_get("@memory")
+        end
+        if ruby_obj.kind_of?(EleetToRubyWrapper)
+          ruby_obj.instance_variable_get("@eleet_obj")
+        elsif ruby_obj.kind_of?(String)
+          memory.root_namespace["String"].new_with_value(ruby_obj)
+        elsif ruby_obj.kind_of?(Fixnum)
+          memory.root_namespace["Integer"].new_with_value(ruby_obj)
+        elsif ruby_obj.kind_of?(Float)
+          memory.root_namespace["Float"].new_with_value(ruby_obj)
+        elsif ruby_obj.kind_of?(BigDecimal)
+          memory.root_namespace["Integer"].new_with_value(ruby_obj.to_i)
+        elsif ruby_obj.kind_of?(Array)
+          eleet_arr = ruby_obj.map { |v| to_eleet_value(v, memory) }
+          memory.root_namespace["List"].new_with_value(eleet_arr)
+        elsif ruby_obj.kind_of?(Hash)
+          eleet_arr = ruby_obj.map do |k, v|
+            memory.root_namespace["Pair"].call(:new, to_eleet_value(k, memory), to_eleet_value(v, memory))
+          end
+          memory.root_namespace["List"].new_with_value(eleet_arr)
+        elsif ruby_obj.nil?
+          memory.root_namespace["nil"]
+        elsif ruby_obj == true
+          memory.root_namesapce["true"]
+        elsif ruby_obj == false
+          memory.root_namesapce["false"]
+        else
+          RubyToEleetWrapper.new(ruby_obj, engine)
+        end
+      end
+
+      def to_ruby_value(eleet_obj, engine)
+        ruby_values = ["TrueClass", "FalseClass", "NilClass", "String", "Integer", "Float"]
+        if eleet_obj.kind_of?(RubyToEleetWrapper)
+          eleet_obj.instance_variable_get("@ruby_obj")
+        elsif ruby_values.include?(eleet_obj.class_name)
+          eleet_obj.ruby_value
+        else
+          EleetToRubyWrapper.new(eleet_obj, engine)
+        end
+      end
+    end
+  end
+end

data/lib/lang/grammar.y

@@ -0,0 +1,350 @@
+class Parser
+
+token DO END CLASS LOAD IF WHILE NAMESPACE ELSE ELSIF RETURN BREAK NEXT TRUE
+token YES ON FALSE NO OFF NIL SELF DEFINED PROPERTY RETURN
+token CONSTANT GLOBAL CLASS_IDENTIFIER INSTANCE_IDENTIFIER IDENTIFIER
+token FLOAT NUMBER STRING TERMINATOR EOF
+
+prechigh
+  left '.'
+  left '**'
+  left '*' '/' '%'
+  left '+' '-'
+  right '-'
+  left '>' '<' '>=' '<='
+  left 'is' 'isnt'
+  right 'not'
+  left 'and'
+  left 'or'
+  right '=' '*=' '/=' '%=' '+=' '-=' '**='
+preclow
+
+rule
+  Program:
+    /* nothing */                                          { result = Nodes.new([]) }
+  | Expressions EOF                                        { result = val[0] }
+  ;
+
+  Expressions:
+    Expression                                             { result = Nodes.new(val) }
+  | Expressions Terminator Expression                      { result = val[0] << val[2] }
+  | Expressions Terminator                                 { result = val[0] }
+  | Terminator                                             { result = Nodes.new([]) }
+  ;
+
+  Terminator:
+    TERMINATOR Terminator
+  | TERMINATOR
+  ;
+
+  Expression:
+    Literal
+  | AssignmentFunction
+  | Call
+  | SELF                                                   { result = SelfNode.new }
+  | NEXT                                                   { result = NextNode.new }
+  | KeyValExpression
+  | ListExpression
+  | NamespaceAccess
+  | Defined
+  | DefMethod
+  | Operation
+  | SetVariable
+  | GetVariable
+  | Namespace
+  | Class
+  | If
+  | While
+  | Return
+  | Property
+  | Lambda
+  | '(' Expression ')'                                     { result = val[1] }
+  ;
+
+  GetVariable:
+    CONSTANT                                               { result = GetConstantNode.new(val[0]) }
+  | GLOBAL                                                 { result = GetGlobalNode.new(val[0]) }
+  | CLASS_IDENTIFIER                                       { result = GetClassVarNode.new(val[0]) }
+  | INSTANCE_IDENTIFIER                                    { result = GetInstanceVarNode.new(val[0]) }
+  | IDENTIFIER                                             { result = GetLocalNode.new(val[0]) }
+  ;
+
+  Literal:
+    NUMBER                                                 { result = IntegerNode.new(val[0].to_i) }
+  | FLOAT                                                  { result = FloatNode.new(val[0].to_f) }
+  | STRING                                                 { result = StringNode.new(val[0]) }
+  | True                                                   { result = TrueNode.new }
+  | False                                                  { result = FalseNode.new }
+  | NIL                                                    { result = NilNode.new }
+  ;
+
+  ListExpression:
+    List
+  | Expression '[' Expression ']' '=' Expression           { result = CallNode.new(val[0], "[]=", [val[2], val[5]], nil) }
+  | Expression '[' Expression ']'                          { result = CallNode.new(val[0], "[]", [val[2]], nil) }
+  ;
+
+  List:
+    '[' ']'                                                { result = CallNode.new(GetConstantNode.new("List"), "new", [], nil) }
+  | '[' Terminator ExpressionList ']'                      { result = CallNode.new(GetConstantNode.new("List"), "new", val[2], nil) }
+  | '[' Terminator ExpressionList Terminator ']'           { result = CallNode.new(GetConstantNode.new("List"), "new", val[2], nil) }
+  | '[' ExpressionList ']'                                 { result = CallNode.new(GetConstantNode.new("List"), "new", val[1], nil) }
+  ;
+
+  ExpressionList:
+    Expression                                             { result = val }
+  | ExpressionList ',' Terminator Expression               { result = val[0] << val[3] }
+  | ExpressionList Terminator ',' Expression               { result = val[0] << val[3] }
+  | ExpressionList ',' Expression                          { result = val[0] << val[2] }
+  ;
+
+  KeyValExpression:
+    Expression '=>' Expression                             { result = CallNode.new(GetConstantNode.new("Pair"), "new", [val[0], val[2]], nil) }
+  ;
+
+  True:
+    TRUE
+  | YES
+  | ON
+  ;
+
+  False:
+    FALSE
+  | NO
+  | OFF
+  ;
+
+  AssignmentFunction
+    Expression '.' IDENTIFIER '=' Expression               { result = CallNode.new(val[0], "#{val[2]}=", [val[4]], nil) }
+  ;
+
+  Call:
+    IDENTIFIER Lambda                                      { result = CallNode.new(nil, val[0], [], val[1]) }
+  | IDENTIFIER Arguments Lambda                            { result = CallNode.new(nil, val[0], val[1], val[2]) }
+  | IDENTIFIER Arguments                                   { result = CallNode.new(nil, val[0], val[1], nil) }
+  | Expression '.' IDENTIFIER Arguments Lambda             { result = CallNode.new(val[0], val[2], val[3], val[4]) }
+  | Expression '.' IDENTIFIER Arguments                    { result = CallNode.new(val[0], val[2], val[3], nil) }
+  | Expression '.' IDENTIFIER Lambda                       { result = CallNode.new(val[0], val[2], [], val[3]) }
+  | Expression '.' IDENTIFIER                              { result = CallNode.new(val[0], val[2], [], nil) }
+  | Expression '.' Operator Arguments                      { result = CallNode.new(val[0], val[2], val[3], nil) }
+  | Expression '.' 'not'                                   { result = CallNode.new(val[0], val[2], [], nil) }
+  ;
+
+  Arguments:
+    '(' ')'                                                { result = [] }
+  | '(' ArgList ')'                                        { result = val[1] }
+  ;
+
+  ArgList:
+    Expression                                             { result = val }
+  | ArgList ',' Expression                                 { result = val[0] << val[2] }
+  ;
+
+  Lambda:
+   '->' '{' Parameters Expressions '}'                     { result = LambdaNode.new(val[2], val[3]) }
+  ;
+
+  Defined:
+    DEFINED '(' GetVariable ')'                            { result = DefinedNode.new(val[2]) }
+  ;
+
+  NamespaceAccess:
+    CONSTANT '::' Expression                               { result = NamespaceAccessNode.new(val[0], val[2]) }
+  | '::' Expression                                        { result = NamespaceAccessNode.new(nil, val[1]) }
+  ;
+
+  Operation:
+    Expression '+' Expression                              { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | Expression '-' Expression                              { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | '-' Expression                                         { result = CallNode.new(val[1], "negate", [], nil) }
+  | Expression '*' Expression                              { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | Expression '**' Expression                             { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | Expression '/' Expression                              { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | Expression '%' Expression                              { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | Expression '>' Expression                              { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | Expression '>=' Expression                             { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | Expression '<' Expression                              { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | Expression '<=' Expression                             { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | OperatorAssignment
+  | 'not' Expression                                       { result = CallNode.new(val[1], val[0], [], nil) }
+  | Expression 'and' Expression                            { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | Expression 'or' Expression                             { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | Expression 'is' Expression                             { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  | Expression 'isnt' Expression                           { result = CallNode.new(val[0], val[1], [val[2]], nil) }
+  ;
+
+  OperatorAssignment:
+    CONSTANT '+=' Expression                               { result = SetConstantNode.new(val[0], CallNode.new(GetConstantNode.new(val[0]), "+", [val[2]], nil)) }
+  | GLOBAL '+=' Expression                                 { result = SetGlobalNode.new(val[0], CallNode.new(GetGlobalNode.new(val[0]), "+", [val[2]], nil)) }
+  | CLASS_IDENTIFIER '+=' Expression                       { result = SetClassVarNode.new(val[0], CallNode.new(GetClassVarNode.new(val[0]), "+", [val[2]], nil)) }
+  | INSTANCE_IDENTIFIER '+=' Expression                    { result = SetInstanceVarNode.new(val[0], CallNode.new(GetInstanceVarNode.new(val[0]), "+", [val[2]], nil)) }
+  | IDENTIFIER '+=' Expression                             { result = SetLocalNode.new(val[0], CallNode.new(GetLocalNode.new(val[0]), "+", [val[2]], nil)) }
+  | CONSTANT '-=' Expression                               { result = SetConstantNode.new(val[0], CallNode.new(GetConstantNode.new(val[0]), "-", [val[2]], nil)) }
+  | GLOBAL '-=' Expression                                 { result = SetGlobalNode.new(val[0], CallNode.new(GetGlobalNode.new(val[0]), "-", [val[2]], nil)) }
+  | CLASS_IDENTIFIER '-=' Expression                       { result = SetClassVarNode.new(val[0], CallNode.new(GetClassVarNode.new(val[0]), "-", [val[2]], nil)) }
+  | INSTANCE_IDENTIFIER '-=' Expression                    { result = SetInstanceVarNode.new(val[0], CallNode.new(GetInstanceVarNode.new(val[0]), "-", [val[2]], nil)) }
+  | IDENTIFIER '-=' Expression                             { result = SetLocalNode.new(val[0], CallNode.new(GetLocalNode.new(val[0]), "-", [val[2]], nil)) }
+  | CONSTANT '*=' Expression                               { result = SetConstantNode.new(val[0], CallNode.new(GetConstantNode.new(val[0]), "*", [val[2]], nil)) }
+  | GLOBAL '*=' Expression                                 { result = SetGlobalNode.new(val[0], CallNode.new(GetGlobalNode.new(val[0]), "*", [val[2]], nil)) }
+  | CLASS_IDENTIFIER '*=' Expression                       { result = SetClassVarNode.new(val[0], CallNode.new(GetClassVarNode.new(val[0]), "*", [val[2]], nil)) }
+  | INSTANCE_IDENTIFIER '*=' Expression                    { result = SetInstanceVarNode.new(val[0], CallNode.new(GetInstanceVarNode.new(val[0]), "*", [val[2]], nil)) }
+  | IDENTIFIER '*=' Expression                             { result = SetLocalNode.new(val[0], CallNode.new(GetLocalNode.new(val[0]), "*", [val[2]], nil)) }
+  | CONSTANT '/=' Expression                               { result = SetConstantNode.new(val[0], CallNode.new(GetConstantNode.new(val[0]), "/", [val[2]], nil)) }
+  | GLOBAL '/=' Expression                                 { result = SetGlobalNode.new(val[0], CallNode.new(GetGlobalNode.new(val[0]), "/", [val[2]], nil)) }
+  | CLASS_IDENTIFIER '/=' Expression                       { result = SetClassVarNode.new(val[0], CallNode.new(GetClassVarNode.new(val[0]), "/", [val[2]], nil)) }
+  | INSTANCE_IDENTIFIER '/=' Expression                    { result = SetInstanceVarNode.new(val[0], CallNode.new(GetInstanceVarNode.new(val[0]), "/", [val[2]], nil)) }
+  | IDENTIFIER '/=' Expression                             { result = SetLocalNode.new(val[0], CallNode.new(GetLocalNode.new(val[0]), "/", [val[2]], nil)) }
+  | CONSTANT '%=' Expression                               { result = SetConstantNode.new(val[0], CallNode.new(GetConstantNode.new(val[0]), "%", [val[2]], nil)) }
+  | GLOBAL '%=' Expression                                 { result = SetGlobalNode.new(val[0], CallNode.new(GetGlobalNode.new(val[0]), "%", [val[2]], nil)) }
+  | CLASS_IDENTIFIER '%=' Expression                       { result = SetClassVarNode.new(val[0], CallNode.new(GetClassVarNode.new(val[0]), "%", [val[2]], nil)) }
+  | INSTANCE_IDENTIFIER '%=' Expression                    { result = SetInstanceVarNode.new(val[0], CallNode.new(GetInstanceVarNode.new(val[0]), "%", [val[2]], nil)) }
+  | IDENTIFIER '%=' Expression                             { result = SetLocalNode.new(val[0], CallNode.new(GetLocalNode.new(val[0]), "%", [val[2]], nil)) }
+  | CONSTANT '**=' Expression                              { result = SetConstantNode.new(val[0], CallNode.new(GetConstantNode.new(val[0]), "**", [val[2]], nil)) }
+  | GLOBAL '**=' Expression                                { result = SetGlobalNode.new(val[0], CallNode.new(GetGlobalNode.new(val[0]), "**", [val[2]], nil)) }
+  | CLASS_IDENTIFIER '**=' Expression                      { result = SetClassVarNode.new(val[0], CallNode.new(GetClassVarNode.new(val[0]), "**", [val[2]], nil)) }
+  | INSTANCE_IDENTIFIER '**=' Expression                   { result = SetInstanceVarNode.new(val[0], CallNode.new(GetInstanceVarNode.new(val[0]), "**", [val[2]], nil)) }
+  | IDENTIFIER '**=' Expression                            { result = SetLocalNode.new(val[0], CallNode.new(GetLocalNode.new(val[0]), "**", [val[2]], nil)) }
+  | IDENTIFIER '.=' IDENTIFIER Arguments Lambda            { result = SetLocalNode.new(val[0], CallNode.new(GetLocalNode.new(val[0]), val[2], val[3], val[4])) }
+  | IDENTIFIER '.=' IDENTIFIER Arguments                   { result = SetLocalNode.new(val[0], CallNode.new(GetLocalNode.new(val[0]), val[2], val[3], nil)) }
+  | IDENTIFIER '.=' IDENTIFIER                             { result = SetLocalNode.new(val[0], CallNode.new(GetLocalNode.new(val[0]), val[2], [], nil)) }
+  ;
+
+  SetVariable:
+    CONSTANT '=' Literal                                   { result = SetConstantNode.new(val[0], val[2]) }
+  | GLOBAL '=' Expression                                  { result = SetGlobalNode.new(val[0], val[2]) }
+  | CLASS_IDENTIFIER '=' Expression                        { result = SetClassVarNode.new(val[0], val[2]) }
+  | INSTANCE_IDENTIFIER '=' Expression                     { result = SetInstanceVarNode.new(val[0], val[2]) }
+  | IDENTIFIER '=' Expression                              { result = SetLocalNode.new(val[0], val[2]) }
+  ;
+
+  DefMethod:
+    IDENTIFIER MethodBlock                                 { result = DefMethodNode.new(val[0], val[1]) }
+  | CLASS_IDENTIFIER MethodBlock                           { result = DefMethodNode.new(val[0], val[1]) }
+  | Operator MethodBlock                                   { result = DefMethodNode.new(val[0], val[1]) }
+  | '[' ']' '=' MethodBlock                                { result = DefMethodNode.new("[]=", val[3]) }
+  | '[' ']' MethodBlock                                    { result = DefMethodNode.new("[]", val[2]) }
+  ;
+
+  MethodBlock:
+    DO Parameters Expressions END                          { result = MethodNode.new(val[1], val[2]) }
+  | DO Parameters END                                      { result = MethodNode.new(val[1], Nodes.new([])) }
+  ;
+
+  Operator:
+    '+'
+  | '-'
+  | '*'
+  | '/'
+  | '%'
+  | '**'
+  | '[]'
+  | '[]='
+  | 'and'
+  | 'or'
+  | 'not'
+  | 'is'
+  | 'isnt'
+  | '>'
+  | '>='
+  | '<='
+  | '<'
+  ;
+
+
+
+  Parameters:
+    /* nothing */                                          { result = [] }
+  | Terminator                                             { result = [] }
+  | '|' ParamList '|' Terminator                           { result = val[1] }
+  | '|' ParamList '|'                                      { result = val[1] }
+  ;
+
+  ParamList:
+    Parameter                                              { result = val }
+  | ParamList ',' Parameter                                { result = val[0] << val[2] }
+  ;
+
+  Parameter:
+    IDENTIFIER                                             { result = val[0] }
+  | INSTANCE_IDENTIFIER                                    { result = val[0] }
+  | CLASS_IDENTIFIER                                       { result = val[0] }
+  ;
+
+  Namespace:
+    NAMESPACE CONSTANT Expressions END                     { result = NamespaceNode.new(val[1], val[2]) }
+  | NAMESPACE CONSTANT Terminator Expressions END          { result = NamespaceNode.new(val[1], val[3]) }
+  | NAMESPACE CONSTANT END                                 { result = NamespaceNode.new(val[1], Nodes.new([])) }
+  ;
+
+  Class:
+    CLASS CONSTANT Expressions END                         { result = ClassNode.new(val[1], nil, val[2]) }
+  | CLASS CONSTANT Terminator Expressions END              { result = ClassNode.new(val[1], nil, val[3]) }
+  | CLASS CONSTANT END                                     { result = ClassNode.new(val[1], nil, Nodes.new([])) }
+  | CLASS CONSTANT Terminator END                          { result = ClassNode.new(val[1], nil, Nodes.new([])) }
+  | CLASS CONSTANT '<' CONSTANT Expressions END            { result = ClassNode.new(val[1], val[3], val[4]) }
+  | CLASS CONSTANT '<' CONSTANT Terminator Expressions END { result = ClassNode.new(val[1], val[3], val[5]) }
+  | CLASS CONSTANT '<' CONSTANT END                        { result = ClassNode.new(val[1], val[3], Nodes.new([])) }
+  | CLASS CONSTANT '<' CONSTANT Terminator END             { result = ClassNode.new(val[1], val[3], Nodes.new([])) }
+  ;
+
+  If:
+    IF Expression Terminator Expressions END               { result = IfNode.new(val[1], val[3], nil) }
+  | IF Expression Terminator Expressions Else              { result = IfNode.new(val[1], val[3], val[4]) }
+  ;
+
+  Else:
+    ELSE Terminator Expression Terminator END              { result = ElseNode.new(val[2]) }
+  | ELSE Terminator Expressions END                        { result = ElseNode.new(val[2]) }
+  | ElseIf
+  ;
+
+  ElseIf:
+    ELSIF Expression Terminator Expressions END            { result = ElseNode.new(IfNode.new(val[1], val[3], nil)) }
+  | ELSIF Expression Terminator Expressions Else           { result = ElseNode.new(IfNode.new(val[1], val[3], val[4])) }
+  ;
+
+  While:
+    WHILE Expression Terminator Expressions END            { result = WhileNode.new(val[1], val[3]) }
+  ;
+
+  Return:
+    RETURN Expression                                      { result = ReturnNode.new(val[1]) }
+  | RETURN                                                 { result = ReturnNode.new(nil) }
+  ;
+
+  Property:
+    PROPERTY IDENTIFIER                                    { result = PropertyNode.new([val[1]]) }
+  | PROPERTY PropertyList                                  { result = PropertyNode.new(val[1]) }
+  ;
+
+  PropertyList:
+    IDENTIFIER IDENTIFIER                                  { result = [val[0], val[1]] }
+  | PropertyList IDENTIFIER                                { result = val[0] << val[1] }
+  ;
+
+end
+
+---- header
+require "lang/lexer"
+require "lang/nodes"
+
+module EleetScript
+
+---- inner
+def debug
+  @yydebug = true
+end
+
+def parse(code, show_tokens = false)
+  debug
+  @tokens = Lexer.new.tokenize(code)
+  p @tokens if show_tokens
+  do_parse
+end
+
+def next_token
+  @tokens.shift
+end
+
+---- footer
+end # module EleetScript