llip 0.1.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.1.0 / 2007-06-09
+
+* 1 major enhancement
+  * Initial release with 100% coverage.

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2005-2007 Matteo Collina
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Manifest.txt

@@ -0,0 +1,45 @@
+History.txt
+MIT-LICENSE
+Manifest.txt
+README.txt
+Rakefile
+examples/ariteval
+examples/ariteval/ariteval.rb
+examples/ariteval/evaluator.rb
+examples/ariteval/exp.rb
+lib/llip
+lib/llip.rb
+lib/llip/abstract_parser.rb
+lib/llip/abstract_scanner.rb
+lib/llip/buffer.rb
+lib/llip/llip_error.rb
+lib/llip/parser.rb
+lib/llip/production_compiler.rb
+lib/llip/production_specification.rb
+lib/llip/recursive_production_compiler.rb
+lib/llip/regexp_abstract_scanner.rb
+lib/llip/regexp_parser.rb
+lib/llip/regexp_scanner.rb
+lib/llip/regexp_specification.rb
+lib/llip/token.rb
+lib/llip/visitable.rb
+spec/ariteval
+spec/ariteval/ariteval_spec.rb
+spec/ariteval/evaluator_spec.rb
+spec/ariteval/exp_spec.rb
+spec/llip
+spec/llip/abstract_parser_spec.rb
+spec/llip/abstract_scanner_spec.rb
+spec/llip/buffer_spec.rb
+spec/llip/llip_error_spec.rb
+spec/llip/parser_spec.rb
+spec/llip/production_compiler_spec.rb
+spec/llip/production_specification_spec.rb
+spec/llip/recursive_production_compiler_spec.rb
+spec/llip/regexp_abstract_scanner_spec.rb
+spec/llip/regexp_parser_spec.rb
+spec/llip/regexp_scanner_spec.rb
+spec/llip/regexp_specification_spec.rb
+spec/llip/token_spec.rb
+spec/llip/visitable_spec.rb
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,148 @@
+= LLInterpretedParser
+
+The LL(k) Interpreted Parser (llip) is an automated tool to easily create an LL(k) parser and the related scanner without the need of generating anything.
+Everything is done on the fly through a simple DSL.
+
+== A Little comparrison against other tools
+
+Tools like JavaCC, ANTLR, Coco/R and others use an external description file which they compile into the destination code.
+This file it's usually written using a complex product related language. Using Ruby metaprogramming, a parser generator can go one step further.
+In fact, the llip gem gives you the possibility to write a parser writing only Ruby code.
+
+== Don't compile anything
+
+This tool is based on a simple and powerful DSL that can be used to specify:
+* some tokens to be recognized in the form of regular expressions, as defined in LLIP::RegexpParser,
+* some productions using LLIP::ProductionSpecification,
+* some LL(K) related behaviour like lookaheads.
+
+Everything specified is automatically translated into live objects which can be used to do LL(K) parsing.
+
+== The LLIP Library
+
+The LLIP::Parser is a facade of the entire library. In fact it handles all the wiring to make it work.
+It also takes care of generating the right LLIP::TokenSpecification starting from its definition,
+which is a simple string written as defined in LLIP::RegexpParser.
+
+To use this library it's necessary to subclass LLIP:Parser and so it's possible to specify all the needed behaviours.
+An instance of that subclass gains the +parse+ method, which parses a string or an IO with the productions previously defined.
+
+== Installation
+
+<code>sudo gem install llip</code>
+
+== History of this gem
+
+This library was originally developed as a project for a computer language course at the engeneering[http://www.ing.unibo.it] faculty of the university of Bologna, Italy.
+
+== A Simple Example
+
+#! /usr/bin/ruby
+
+require 'rubygems'
+
+require 'llip'
+
+class MyParser < LLIP::Parser
+
+  token :num, "(1|2|3|4|5|6|7|8|9|0)+" # simple definition of a number
+
+  scope :number # definition of the scope, the first production which will be called
+
+  production(:number) do |p|
+
+    # inside the :number production,
+    # we are specifying what to do when we encounter a :num token
+    p.token :num do |result,scanner,parser|
+      puts "The number is..."
+      number = scanner.current.value
+      puts number
+      scanner.next # we are reading the next token
+      number
+    end
+
+  end
+end
+
+puts "--->>> Example 1"
+
+parser = MyParser.new
+
+parser.parse("1")
+
+parser.parse("34065")
+
+parser.parse("123456")
+
+puts "--->>> Example 2"
+
+begin
+  parser.parse("3+2")
+rescue LLIP::LLIPError => error
+  puts error
+end
+
+class MyParser
+
+  token :plus, '\+' # the '\' is required because it escapes the '+',
+                    # which is a token of a regular expressions.
+
+  scope :exp
+
+  production :exp, :recursive do |p|
+    p.default { |scanner,parser| parser.parse_number }  # this block is exectued before any
+                                                        # other block. The result of this block
+                                                        # will be putted in the first parameter of the
+                                                        # first production matched.
+
+    p.token :plus do |left,scanner,parser|
+      scanner.next
+      right = parser.parse_number # we are calling another production!!
+      sum = left.to_i + right.to_i
+      puts "The sum is #{sum}"
+      sum
+    end
+  end
+end
+
+result = parser.parse "3+2+4"
+
+puts "the result is #{result}"
+
+== A more complex example, the Ariteval parser
+
+Bundled with this library there is an example of an Arithmetic Evaluator,
+which evaluates simple expressions like "3-7*(6-2)". In the "examples/ariteval" directory there are:
+[<b>exp.rb</b>] contains all the Abstract Syntax Tree node definitions.
+[<b>ariteval.rb</b>] contains the Ariteval class which defines all the productions using LLIP::Parser.
+[<b>evaluator.rb</b>] a simple visitor which uses the classes defined in exp.rb.
+
+== Author
+
+This library has been written by Matteo Collina, matteo dot collina at gmail dot com.
+
+== License
+
+(The MIT license)
+
+Copyright (c) 2006-2007 Matteo Collina
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rake'
+require 'hoe'
+require 'lib/llip'
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+require 'iconv'
+
+Hoe.new('llip',LLIP::VERSION) do |p|
+  p.author = "Matteo Collina"
+  p.name = "llip"
+  p.email = "matteo.collina@gmail.com"
+  p.extra_deps = ["rspec",">= 1.0.0"]
+  p.description = p.paragraphs_of('README.txt', 1..3).join("\n\n")
+  p.summary = "LLIP is a tool to geneate a LL(k) parser."
+  p.url = "http://llip.rubyforge.org"
+  p.rdoc_pattern = /(^lib\/llip\/.*|.*\.txt|^examples\/ariteval\/.*)/
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")  
+end
+
+Rake.application["default"].prerequisites.shift
+
+task :default => [:spec]
+
+desc "Run the LLIP specifications"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/llip/*.rb']
+  t.spec_opts = ["--diff c"]
+end
+
+desc "Run all the specifications"
+Spec::Rake::SpecTask.new('spec:all') do |t|
+  t.spec_files = FileList['spec/**/*.rb'] - ["specs/spec_helper.rb"]
+  t.spec_opts = ["--diff c"]
+end
+
+desc "Run all the specifications and generate the output in html"
+Spec::Rake::SpecTask.new('spec:html') do |t|
+  t.spec_files = FileList['spec/**/*.rb'] - ["specs/spec_helper.rb"]
+  t.spec_opts = ["-f html","--diff c","-o","specs.html"]
+end
+
+desc "Run all the specification with RCov support"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb'] - ["specs/spec_helper.rb"]
+  t.spec_opts = ["-c"]
+  t.rcov = true
+  t.rcov_opts = ['--exclude', "rcov,spec,gem"] 
+end
+
+desc "Run all the specification and checks if the coverage is at the threshold"
+RCov::VerifyTask.new(:verify_rcov => :rcov) do |t|
+  t.threshold = 100.0
+end
+
+desc "Creates the Manifest" 
+task :create_manifest do
+  files = FileList["{examples,lib,spec}/**/*"] + ["README.txt","Manifest.txt","History.txt","MIT-LICENSE","Rakefile"]
+  files.sort!
+  File.open("Manifest.txt", "w") do |io|
+    io.write(files.join("\n"))
+  end
+end
+
+task :commit => :verify_rcov do |t|
+  exec "svn commit"
+end

data/examples/ariteval/ariteval.rb

@@ -0,0 +1,132 @@
+require 'parser'
+require 'evaluator'
+
+# It's a simple arithmetical evaluator. It's able to parse expressions like these: 
+# * ( a = 3 * 2 ) - ( 24 + a ),
+# * 3 * (4 - 2) + 5*(4/2)/(3-2).
+#
+# It realizes the following grammar:
+# 
+# non terminal symbols = { SCOPE, EXP, TERM, POW, FACTOR, NUMBER }
+# terminal symbols = any number, the charachters " , . + - * / ^ = [ ] ( ) ' "
+#
+# an id is an unlimited string composed of every charachter "a".."Z" and the "_" 
+#
+# P = {
+#   SCOPE ::= EXP
+#   EXP    ::= EXP + TERM
+#   EXP    ::= EXP - TERM 
+#   TERM   ::= POW
+#   TERM   ::= TERM * FACTOR 
+#   TERM   ::= TERM / FACTOR
+#   FACTOR ::= any sequence of 0,1,2,3,4,5,6,7,8,9		
+#   FACTOR ::= an id
+#   FACTOR ::= an id = 
+#   FACTOR ::= ( EXP )
+# }
+#
+class Ariteval < Parser
+	
+  def initialize
+    super
+    @evaluator = Evaluator.new
+  end
+
+  def evaluate(source)
+    parse(source).accept(@evaluator)
+    @evaluator.result
+  end
+
+  # tokens definitions
+	
+  numbers = ("0".."9").to_a.join("|")
+  token :number, "(#{numbers})+ *"
+
+  token :plus, '\+ *'
+	
+  token :minus, '- *'
+	
+  token :mul, '\* *'
+	
+  token :div, '/ *'
+
+  token "(".to_sym, '\( *'
+	
+  token ")".to_sym, '\) *'
+
+  identifiers = (("a".."z").to_a + ("A".."Z").to_a).join("|")
+  token :ident, "(#{identifiers}) *"
+
+  token :assign, "= *" 
+	
+  # production definitions
+	
+  lookahead(true)
+	
+  scope :exp
+
+  production(:exp,:recursive) do |prod|
+    prod.default { |scanner,parser| parser.parse_term }
+
+    prod.token(:plus) do |term_seq,scanner,parser|
+      scanner.next
+      next_term = parser.parse_term
+      PlusExp.new(term_seq,next_term)
+    end	
+
+    prod.token(:minus) do |term_seq,scanner,parser|
+      scanner.next
+      next_term = parser.parse_term
+      MinusExp.new(term_seq,next_term)
+    end
+	
+  end
+
+  production(:term,:recursive) do |prod|
+    prod.default { |scanner,parser| parser.parse_factor }
+
+    prod.token(:mul) do |factor_seq,scanner,parser|
+      scanner.next
+      next_factor = parser.parse_factor
+      MulExp.new(factor_seq,next_factor)
+    end	
+
+    prod.token(:div) do |factor_seq,scanner,parser|
+      scanner.next
+      next_factor = parser.parse_factor
+      DivExp.new(factor_seq,next_factor)
+    end	
+  end
+
+  production(:factor,:single) do |prod|
+		
+    prod.token(:number) do |result,scanner|
+      current = scanner.current
+      scanner.next
+      NumExp.new(current.value.to_i)
+    end
+
+    prod.token("(".to_sym) do |result,scanner,parser|
+      scanner.next
+      result = parser.parse_exp
+      parser.raise "Every '(' must be followed by a ')'" unless scanner.current == ")".to_sym
+      scanner.next
+      result
+    end
+
+    prod.token(:ident,:assign) do |result,scanner,parser|
+      name = scanner.current.to_s.strip
+      scanner.next
+      scanner.next
+      AssignIdentExp.new(name,parser.parse_exp)
+    end
+
+    prod.token(:ident) do |result,scanner,parser|
+      result = IdentExp.new(scanner.current.to_s.strip)
+      scanner.next
+      result
+    end
+
+  end
+
+end

data/examples/ariteval/evaluator.rb

@@ -0,0 +1,61 @@
+# It's a symple visitor for the abstract syntax tree created with the nodes in exp.rb.
+# It evaluates the expressions in the obvious way.
+class Evaluator
+
+  attr_reader :ident_table
+
+  def initialize
+    @result = 0
+    @ident_table = {}
+  end
+
+  def visit_plus_exp(exp)
+    left,right = left_and_right(exp)
+    @result = left + right
+  end
+
+  def visit_minus_exp(exp)
+    left,right = left_and_right(exp)
+    @result = left - right
+  end
+
+  def visit_mul_exp(exp)
+    left,right = left_and_right(exp)
+    @result = left * right
+  end
+
+  def visit_div_exp(exp)
+    left,right = left_and_right(exp)
+    @result = left / right
+  end
+
+  def visit_num_exp(exp)
+    @result = exp.value
+  end
+
+  def visit_assign_ident_exp(exp)
+    exp.value.accept(self)
+    ident_table[exp.name] = @result
+  end
+
+  def visit_ident_exp(exp)
+    @result = ident_table[exp.value]
+  end
+
+  def result
+    result = @result
+    @result = 0
+    return result
+  end
+
+  private
+
+  def left_and_right(exp)
+    exp.left.accept(self)
+    left = @result
+		
+    exp.right.accept(self)
+    right = @result
+    [left,right]
+  end
+end