rockit 0.7.1 → 0.7.2

data/tests/acceptance/packrat/minibasic/minibasic.rb

@@ -34,52 +34,6 @@
 require 'packrat/grammar'
 
 module MiniBasic
-  class Interpreter
-    def initialize
-      # For variables and their values. Default value is 0.
-      @vars = Hash.new(0)
-    end
-
-    def eval(sexpr)
-      case sexpr.first
-      when :Statements
-        sexpr.statements.each {|stmt| mb_eval(stmt)}
-      when "If"
-        if mb_eval(sexpr.condition) # What is true and false in basic?
-          mb_eval(sexpr.statements)
-        elsif sexpr.optelse
-          mb_eval(sexpr.optelse[2])
-        end
-      when "For"
-        for i in (mb_eval(sexpr.from)..mb_eval(sexpr.to))
-          $vars[sexpr.ident.id] = i
-          mb_eval(sexpr.statements)
-        end
-      when "Read"
-        print "? "; STDOUT.flush
-        $vars[sexpr.ident.id] = STDIN.gets.to_i   # Error catching?!
-      when "Print"
-        print mb_eval(sexpr.message); STDOUT.flush
-      when "PrintLn"
-        print "\n"; STDOUT.flush
-      when "Assignment"
-        $vars[sexpr.ident.id] = mb_eval(sexpr.expression)
-      when "Condition"
-        map = {">" => :>, "<" => :<, "=" => :==}
-        mb_eval(sexpr.left).send(map[sexpr.op], mb_eval(sexpr.right))
-      when "BinExpr"
-        map = {"+"=>:+, "-"=>:-, "*"=>:*, "/"=>"/".intern, "MOD"=>"%".intern }
-        mb_eval(sexpr.left).send(map[sexpr.op], mb_eval(sexpr.right))
-      when "String"
-        sexpr.value[1..-2] # Skip leading and trailing double quotes
-      when "Identifier"
-        $vars[sexpr.id]
-      when "Number"
-        sexpr.lexeme.to_i
-      end
-    end
-  end
-
   Grammar = Packrat::Grammar.new do
     start_symbol :Program
 
@@ -87,51 +41,115 @@ module MiniBasic
     S  = hidden(/\s*/)
     FS = hidden(/\s\s*/)
 
-    prod :Program, [S, :Statements, eos(), lift(0)]
+    prod :Program, [S, :Statements, eos(), lift(1)]
 
     prod :Statements, [plus(:Statement), lift(0)]
 
-    rule :Statement, [
-      ['IF', FS, :Condition, FS, 'THEN', FS,
-	:Statements, FS,
-	maybe(:OptElse), S,
-	'ENDIF', S, ast(:If)],
+    rule( :Statement,
+          ['IF', FS, :Condition, FS, 'THEN', FS,
+           :Statements, S,
+           maybe(:OptElse), S,
+           'ENDIF', S, ast(:If)],
 
-      ['FOR', FS, :Identifier, S, ':=', S, :Expr, FS, 'TO', FS, :Expr, S,
-	:Statements, S,
-	'NEXT', S, ast(:For)],
+          ['FOR', FS, :Identifier, S, ':=', S, :Expr, FS, 'TO', FS, :Expr, S,
+           :Statements, S,
+           'NEXT', S, ast(:For, :expr1 => :from, :expr2 => :to)],
 
-      ['READ', FS, :Identifier, S, ast(:Read)],
+          ['READ', FS, :Identifier, S, ast(:Read)],
 
-      ['PRINTLN', S, ast(:PrintLn)],
+          ['PRINTLN', S, ast(:PrintLn)],
 
-      ['PRINT', FS, any(:Expr, :String), S, ast(:Print)],
+          ['PRINT', FS, any(:Expr, :String), S, ast(:Print)],
 
-      [:Identifier, S, ':=', S, :Expr, S, ast(:Assign)],
-    ]
+          [:Identifier, S, ':=', S, :Expr, S, ast(:Assign)]
+          )
 
-    prod :OptElse, ['ELSE', FS, :Statements, lift(1)]
+    prod :OptElse, ['ELSE', FS, :Statements, lift(2)]
 
-    prod :Condition, [:Expr, S, any('<', '>', '='), S, :Expr, ast(:Cond)]
+    prod :Condition, [:Expr, S, any('<', '>', '='), S, :Expr, 
+                      ast(:Cond, :expr1 => :left, :expr2 => :right)]
 
     # This is crude! No precedence levels or handling of associativity.
-    rule :Expr, [
-      [:BaseExpr, S, any('+', '-', '*', '/', 'MOD'), S, :BaseExpr,
-       ast(:OpExpr)
-      ],
-      [:BaseExpr, lift(0)],
-    ]
-
-    rule :BaseExpr, [
-      [:Number, lift(0)],
-      [:Identifier, lift(0)],
-      ['(', S, :Expr, S, ')', lift(2)],
-    ]
-
-    prod :String, [/"[^"]*"/, lift(0)]
+    rule( :Expr,
+          [:BaseExpr, S, any('+', '-', '*', '/', 'MOD'), S, :BaseExpr,
+           ast(:BinExpr, :base_expr1 => :left, :base_expr2 => :right)],
+          [:BaseExpr, lift(0)]
+          )
+
+    rule( :BaseExpr,
+          [:Number, lift(0)],
+          [:Identifier, lift(0)],
+          [:String, lift(0)],
+          ['(', S, :Expr, S, ')', lift(2)]
+          )
+
+    prod :String, ['"', /[^"]*/, '"', lift(1)]          #"
     prod :Identifier, [/[A-Z]([A-Z0-9])*/, lift(0) {|r| r.intern}]
     prod :Number, [/[0-9]+/, lift(0) {|r| r.to_i}]
   end
 
   Parser = Grammar.interpreting_parser
+
+  class Interpreter
+    attr_reader :vars
+
+    def initialize(options = {})
+      # For variables and their values. Default value is 0.
+      @vars = Hash.new(0)
+      @stdout = options[:stdout] || STDOUT
+      @stdin = options[:stdin] || STDIN
+    end
+
+    include MiniBasic::Grammar::ASTs
+
+    def interpret_program(str)
+      ast = MiniBasic::Parser.parse_string(str)
+      interpret(ast)
+    end
+
+    def interpret(ast)
+      case ast
+      when Array
+        ast.each {|stmt| interpret(stmt)}
+      when If
+        if interpret(ast.condition) # What is true and false in basic?
+          interpret(ast.statements)
+        elsif ast[4]
+          interpret(ast[4])
+        end
+      when For
+        for i in (interpret(ast.from)..interpret(ast.to))
+          @vars[ast.identifier] = i
+          interpret(ast.statements)
+        end
+      when Read
+        @stdout.print "? "
+        @stdout.flush
+        @vars[ast.identifier] = @stdin.gets.to_i   # Error catching?!
+      when Print
+        @stdout.print(interpret(ast[1]).to_s)
+        @stdout.flush
+      when PrintLn
+        @stdout.print "\n"
+        @stdout.flush
+      when Assign
+        @vars[ast.identifier] = interpret(ast.expr)
+      when Cond
+        map = {">" => :>, "<" => :<, "=" => :==}
+        interpret(ast.left).send(map[ast[1]], interpret(ast.right))
+      when BinExpr
+        map = {"+"=>:+, "-"=>:-, "*"=>:*, "/"=>"/".intern, "MOD"=>"%".intern }
+        interpret(ast.left).send(map[ast[1]], interpret(ast.right))
+      when Symbol
+        @vars[ast]
+      else
+        ast # Return the value itself
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  prg = File.open(ARGV[0]) {|fh| fh.read}
+  MiniBasic::Interpreter.new.interpret_program(prg)
 end

data/tests/acceptance/packrat/minibasic/mult3.basic

@@ -0,0 +1,6 @@
+PRINT "What is your number"
+READ I
+PRINT I
+PRINT " * 3 = "
+PRINT I * 3
+PRINTLN

data/tests/acceptance/packrat/minibasic/sumeven.basic

@@ -0,0 +1,19 @@
+PRINT "I can sum even numbers."
+PRINTLN
+PRINT "At what number should I start summing"
+READ START
+PRINT "At what number should I stop"
+READ STOP
+SUM := 0
+FOR I := START TO STOP
+  IF (I MOD 2) = 0 THEN
+    SUM := (SUM + I)
+  ENDIF
+NEXT
+PRINT "The sum of all even numbers between (inclusive) "
+PRINT START
+PRINT " and "
+PRINT STOP
+PRINT " is = "
+PRINT SUM
+PRINTLN

data/tests/unit/packrat/test_ast.rb

@@ -0,0 +1,116 @@
+require 'test/unit'
+
+require 'packrat/grammar'
+include Packrat
+
+class TestAST < Test::Unit::TestCase
+  def setup
+    @g1 = Packrat::Grammar.new do
+      start_symbol :s
+
+      s  = hidden(/\s*/)
+      fs = hidden(/\s\s*/)
+
+      rule(:s, 
+           ["P",  ast(:P)],
+           ["S2a", :Num, :Num, ast(:S2a)],
+           ["S2b", :Num, :Num, ast(:S2b, :num1 => :n1)],
+           ["S2c", :Num, :Num, ast(:S2c, :num2 => :n2)],
+           ["S2d", :Num, :Num, ast(:S2d, :num1 => :n1, :num2 => :n2)],
+           ['FOR', fs, :Ident, s, ':=', s, :Expr, fs, 'TO', fs, :Expr, s,
+            :Statements, s,
+            'NEXT', s, ast(:For, :expr1 => :from, :expr2 => :to)],
+           [:Num, lift(0)],
+           [:Id,  lift(0)]
+           )
+
+      prod :Num, [/\d{1,2}/, ast(:Num)]
+      prod :Id,  ["ID", :Num, maybe("?"), ast(:Id)]
+
+      prod :Statements, [plus(:s), lift(0)]
+      prod :Ident, [/[A-Z]([A-Z0-9])*/, lift(0) {|r| r.intern}]
+      prod :Expr, [any(:Num, :Ident), lift(0)]
+    end
+
+    @ip = @g1.interpreting_parser
+    @mAst = @g1::ASTs
+  end
+  
+  def test_01_ast_module_and_classes_initialized_after_grammar_finalization
+    @g1.finalize!
+
+    assert(@g1.constants.include?("ASTs"))
+    assert_kind_of(Module, @mAst)    
+
+    expected_ast_names = ["P", "Num", "Id", "For", "S2a", "S2b", "S2c", "S2d"]
+    assert_equal(expected_ast_names.sort, @mAst.constants.sort)
+    expected_ast_names.each do |exp_ast_name|
+      ast = @mAst.const_get(exp_ast_name)
+      assert(Packrat::AST, ast.superclass)
+      assert_kind_of(ast, ast[])
+    end
+
+    assert_equal(["P"], @mAst::P.sig)
+    assert_equal([nil], @mAst::Num.sig)
+    assert_equal(["ID", :num, nil], @mAst::Id.sig)
+    assert_equal(["S2a", :num1, :num2], @mAst::S2a.sig)
+    assert_equal(["S2b", :n1, :num2], @mAst::S2b.sig)
+    assert_equal(["S2c", :num1, :n2], @mAst::S2c.sig)
+    assert_equal(["S2d", :n1, :n2], @mAst::S2d.sig)
+    assert_equal(["FOR", :ident, ":=", :from, "TO", :to,
+                  :statements, "NEXT"],
+                 @mAst::For.sig)
+  end
+
+  def test_02_ast_parsing_no_nonconst_children
+    r = @ip.parse_string("P")
+    assert_equal(@mAst::P[], r)
+    assert_equal("P", r[0])
+  end
+
+  def test_03_ast_parsing_single_nonconst_child
+    r = @ip.parse_string("1")
+    assert_equal(@mAst::Num["1"], r)
+    assert_equal("1", r[0])
+  end
+
+  def test_04_ast_parsing_multi_mixed_children_default_naming
+    r = @ip.parse_string("ID10")
+    assert_equal('Id["ID", Num["10"], nil]', r.inspect)
+    assert_equal(@mAst::Id[@mAst::Num["10"]], r)
+    assert_equal(@mAst::Num["10"], r[1])
+    assert_equal("ID", r[0])
+    assert_equal("10", r[1][0])
+    assert_equal(nil,  r[2])
+    assert_equal("10", r.num[0])
+  end
+
+  def test_05_multi_mixed_overlapping_symbol_names
+    r = @ip.parse_string("S2a112")
+    assert_equal(@mAst::S2a[@mAst::Num["11"], @mAst::Num["2"]], r)
+    assert_equal(@mAst::Num["11"], r[1])
+    assert_equal(@mAst::Num["2"], r[2])
+    assert_equal(@mAst::Num["11"], r.num1)
+    assert_equal(@mAst::Num["2"], r.num2)
+  end
+
+  def test_06_multi_mixed_overlapping_symbol_names_with_override
+    r = @ip.parse_string("S2b1134")
+    assert_equal(@mAst::Num["11"], r.n1)
+    assert_equal(@mAst::Num["34"], r.num2)
+
+    r = @ip.parse_string("S2c1134")
+    assert_equal(@mAst::Num["11"], r.num1)
+    assert_equal(@mAst::Num["34"], r.n2)
+
+    r = @ip.parse_string("S2d7465")
+    assert_equal(@mAst::Num["74"], r.n1)
+    assert_equal(@mAst::Num["65"], r.n2)
+  end
+
+  def test_07_complex_ast_parsing
+    r = @ip.parse_string("FOR A := 1 TO 3 P NEXT")
+    assert_equal(@mAst::For[:A, @mAst::Num["1"], @mAst::Num["3"],
+                            [@mAst::P[]]], r)
+  end
+end

data/tests/unit/packrat/test_interpreting_parser.rb

@@ -40,10 +40,10 @@ class TestInterpretingParser < Test::Unit::TestCase
   def test_03_grammar_with_single_rule_with_multi_prods
     g = Packrat::Grammar.new do
       start_symbol :s
-      rule :s, [
-        [/a+/, /b+/, /dc*/],
-        [/a+/, /d+/]
-      ]
+      rule(:s,
+           [/a+/, /b+/, /dc*/],
+           [/a+/, /d+/]
+           )
     end
     ip = g.interpreting_parser
 
@@ -60,10 +60,10 @@ class TestInterpretingParser < Test::Unit::TestCase
   def test_04_grammar_with_single_rule_and_ref_to_one_external_prod
     g = Packrat::Grammar.new do
       start_symbol :s
-      rule :s, [
-        [:a, /b+/, /dc*/],
-        [:a, /d+/]
-      ]
+      rule( :s, 
+            [:a, /b+/, /dc*/],
+            [:a, /d+/]
+            )
       prod :a, [/a+/]
     end
     ip = g.interpreting_parser
@@ -81,13 +81,13 @@ class TestInterpretingParser < Test::Unit::TestCase
   def test_05_grammar_with_multi_rules
     g = Packrat::Grammar.new do
       start_symbol :Constant
-      rule :Constant, [
-        [:DecimalInt], 
-        [:HexInt], 
-        [:OctalInt], 
-      ]
-      rule :DecimalInt, [[/[1-9][0-9]*[uUlL]?/]]
-      rule :HexInt,     [[/(0x|0X)[0-9a-fA-F]+[uUlL]?/]]
+      rule( :Constant,
+            [:DecimalInt], 
+            [:HexInt], 
+            [:OctalInt]
+            )
+      rule :DecimalInt, [/[1-9][0-9]*[uUlL]?/]
+      rule :HexInt,     [/(0x|0X)[0-9a-fA-F]+[uUlL]?/]
       prod :OctalInt,   [/0[0-7]*[uUlL]?/]
     end
     ip = g.interpreting_parser
@@ -253,44 +253,4 @@ class TestInterpretingParser < Test::Unit::TestCase
     r = ip.parse_string("7/18")
     assert_equal([:s, "7", "/", "18"], r)
   end
-
-  def test_14_ast
-    g = Packrat::Grammar.new do
-      start_symbol :s
-      rule :s, [
-        [:Num, lift(0)],
-        [:Id,  lift(0)],
-      ]
-      prod :Num, [/\d+/, ast(:Num)]
-      prod :Id,  ["ID", :Num, maybe("?"), ast(:Id)]
-    end
-    ip = g.interpreting_parser
-
-    mAst = g::ASTs
-    assert_kind_of(Module, mAst)
-    
-    r = ip.parse_string("1")
-
-    # The AST classes are added during the parse so now we can see
-    # that they are there.
-    assert_kind_of(Class, mAst.const_get("Num"))
-    assert(mAst::Num.ancestors.include?(Packrat::AST))
-
-    as = mAst::Num[]
-    assert_kind_of(mAst::Num, as)
-
-    assert_kind_of(Packrat::AST, r)
-    assert_equal('Num["1"]', r.inspect)
-    assert_equal("1", r[0])
-
-    r = ip.parse_string("ID10")
-    assert_kind_of(Class, mAst.const_get("Id"))
-    assert(mAst::Id.ancestors.include?(Packrat::AST))
-    assert_kind_of(Packrat::AST, r)
-    assert_equal('Id["ID", Num["10"], nil]', r.inspect)
-    assert_equal("ID", r[0])
-    assert_equal("10", r[1][0])
-    assert_equal(nil,  r[2])
-    assert_equal("10", r.num[0])
-  end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: rockit
 version: !ruby/object:Gem::Version 
-  version: 0.7.1
-date: 2006-03-23 00:00:00 +01:00
+  version: 0.7.2
+date: 2006-03-27 00:00:00 +02:00
 summary: Rockit is the Ruby Object-oriented Compiler construction toolKIT
 require_paths: 
 - lib
@@ -35,67 +35,30 @@ files:
 - VERSION
 - rakefile
 - lib/packrat/grammar.rb
-- lib/rockit/prettyprint/text_renderer.rb
-- lib/rockit/prettyprint/renderer.rb
-- lib/rockit/prettyprint/box.rb
-- lib/rockit/tree/visitor.rb
-- lib/rockit/tree/base.rb
-- lib/rockit/tree/graphviz.rb
-- lib/rockit/tree/enter_leave_visitor.rb
-- lib/util/array_alternatives.rb
-- lib/util/string_location.rb
-- lib/util/graphviz_dot.rb
-- lib/util/visitor.rb
-- lib/util/visitor_combinators.rb
-- lib/util/enter_leave_visitor.rb
-- tests/acceptance/rockit
-- tests/acceptance/packrat
-- tests/acceptance/rockit/dparser
-- tests/acceptance/rockit/dparser/atest_speculative_code_action.rb
-- tests/acceptance/rockit/dparser/atest_samples_calculator.rb
-- tests/acceptance/rockit/dparser/atest_plus_operator.rb
-- tests/acceptance/rockit/dparser/atest_arithmetic_grammar.rb
-- tests/acceptance/rockit/dparser/atest_simple_grammar.rb
-- tests/acceptance/rockit/dparser/atest_operator_grammar.rb
-- tests/acceptance/rockit/dparser/atest_any_operator.rb
-- tests/acceptance/rockit/dparser/atest_samples_minibasic.rb
-- tests/acceptance/rockit/dparser/atest_list_operator.rb
-- tests/acceptance/rockit/dparser/atest_samples_multifunccalculator.rb
-- tests/acceptance/rockit/dparser/atest_mult_operator.rb
-- tests/acceptance/rockit/dparser/calc_tests_common.rb
+- doc/rockit_paper.pdf
 - tests/acceptance/packrat/minibasic
+- tests/acceptance/packrat/java
 - tests/acceptance/packrat/minibasic/minibasic.rb
+- tests/acceptance/packrat/minibasic/mult3.basic
 - tests/acceptance/packrat/minibasic/atest_minibasic.rb
-- tests/unit/rockit
-- tests/unit/util
-- tests/unit/parse
-- tests/unit/packrat
-- tests/unit/rockit/tree
-- tests/unit/rockit/prettyprint
-- tests/unit/rockit/utest_grammar_symbol.rb
-- tests/unit/rockit/utest_string_terminal.rb
-- tests/unit/rockit/utest_repetition_operators.rb
-- tests/unit/rockit/utest_regexp_terminal.rb
-- tests/unit/rockit/utest_grammar.rb
-- tests/unit/rockit/utest_rule.rb
-- tests/unit/rockit/utest_maybe_operator.rb
-- tests/unit/rockit/assembler
-- tests/unit/rockit/tree/utest_tree_visitor.rb
-- tests/unit/rockit/tree/utest_tree_base.rb
-- tests/unit/rockit/tree/utest_tree_enter_leave_visitor.rb
-- tests/unit/rockit/prettyprint/utest_box.rb
-- tests/unit/rockit/assembler/llvm
-- tests/unit/rockit/assembler/llvm/utest_instructions.rb
-- tests/unit/rockit/assembler/llvm/utest_module.rb
-- tests/unit/util/utest_array_alternatives.rb
-- tests/unit/util/utest_string_location.rb
-- tests/unit/util/utest_visitor.rb
-- tests/unit/util/utest_visitor_combinators.rb
-- tests/unit/util/utest_enter_leave_visitor.rb
-- tests/unit/parse/utest_grammar.rb
-- tests/unit/parse/utest_expand_grammar.rb
-- tests/unit/parse/utest_ebnf_grammar.rb
+- tests/acceptance/packrat/minibasic/README
+- tests/acceptance/packrat/minibasic/sumeven.basic
+- tests/acceptance/packrat/java/xtc.lang.java
+- tests/acceptance/packrat/java/java.rb
+- tests/acceptance/packrat/java/todo
+- tests/acceptance/packrat/java/atest_java.rb
+- tests/acceptance/packrat/java/t.rb
+- tests/acceptance/packrat/java/xtc.lang.java/JavaConstant.rats
+- tests/acceptance/packrat/java/xtc.lang.java/JavaCore.rats
+- tests/acceptance/packrat/java/xtc.lang.java/JavaIdentifier.rats
+- tests/acceptance/packrat/java/xtc.lang.java/Spacing.rats
+- tests/acceptance/packrat/java/xtc.lang.java/Java.rats
+- tests/acceptance/packrat/java/xtc.lang.java/JavaSymbol.rats
+- tests/acceptance/packrat/java/xtc.lang.java/Symbol.rats
+- tests/acceptance/packrat/java/xtc.lang.java/JavaTree.rats
+- tests/acceptance/packrat/java/xtc.lang.java/JavaType.rats
 - tests/unit/packrat/test_interpreting_parser.rb
+- tests/unit/packrat/test_ast.rb
 test_files: []
 
 rdoc_options: []