peggy 0.1.0

data/lib/Copy of builder.rb

@@ -0,0 +1,363 @@
+require 'rubygems'
+require 'parser'
+# require File.join(File.dirname(__FILE__), 'parser')
+
+module Peggy
+
+  # Base syntax element class.
+  class Element
+    # Create an element.
+    def self::build *args
+      new *args
+    end
+    
+    # Test to see if there is a match of this element at the current index.
+    # Return's the index following if match is found, or NO_MATCH if not
+    def match parser, index
+      raise "Must override match"
+    end
+    
+    def report index
+      # puts "#{to_s} #{index}"
+      index
+    end
+  end
+
+  # An element that matches a sequence of elements.  All must match for the sequence to match.
+  class Sequence < Element
+    # Add a child element.
+    def add element
+      @list = [] unless @list
+      @list << element
+    end
+
+    # Synonym for add(element)
+    alias :'<<' :add
+    
+    # Reference a child by index.
+    def [] index
+      @list[index]
+    end
+    
+    # Child iterator.
+    def each &blk
+      @list.each &blk
+    end
+    
+    # Match each child in sequence. If any fail this returns NO_MATCH. If all succeed this 
+    # returns the end index of the last.
+    def match parser, index
+      raise "no children added to sequence" unless @list
+      each do |element|
+        index = element.match parser, index
+        return NO_MATCH unless index
+      end
+      report index
+    end
+  end
+  
+  # An element which matches any one of its children. The children are tested in order. The first
+  # to match wins.
+  class Alternatives < Sequence
+    # Match any one of the children. The children are tried in order. The first to match wins.
+    # The result is the end index of the first matching child. If none match this returns NO_MATCH.
+    def match parser, index
+      raise "no children added to alternate" unless @list
+      each do |element|
+        found = element.match parser, index
+        return report(found) if found
+      end
+      report NO_MATCH
+    end
+  end
+  
+  # An element which tries its single child multiple times. It is greedy, meaning it will continue 
+  # to match as long as possible, unless the range specifies a maximum number of matches.
+  class Multiple < Element
+    # A big number
+    MANY = 32767
+    # The minimum and maximum number of tries
+    attr_accessor :range
+    # The single child
+    attr_accessor :child
+
+    # Init the range
+    def initialize range
+      @range = range
+    end
+    
+    # synonym for child=(element)
+    alias :'<<' :'child='
+    
+    # Matches the child multiple times. The range specifies the least and most number of matches.
+    # If the number of matches is less than the minimim of the range then NO_MATCH is returned.
+    # If equal or more than the minimim then the end index of the last match is returned.
+    def match parser, index
+      raise "multiple element child not set" unless child
+      raise "multiple element range not set" unless range
+      count = 0
+      while count < range.last
+        found = child.match parser, index
+        break unless found
+        index = found
+        count += 1
+      end
+      report range === count ? index : NO_MATCH
+    end
+  end
+  
+  # Matcher of 0 or more times.
+  class AnyNumber < Multiple
+    def initialize
+      super 0..MANY
+    end
+  end
+  
+  # Matcher of 1 or more times.
+  class AtLeastOne < Multiple
+    def initialize
+      super 1..MANY
+    end
+  end
+  
+  # Matcher of 0 or 1 time.
+  class Optional < Multiple
+    def initialize
+      super 0..1
+    end
+  end
+  
+  # An element which tries its single child but does not advance the index if found.
+  # If not found, however, it returns NO_MATCH. Used for a positive semantic predicate.
+  class Positive < Element
+    # The single child
+    attr_accessor :child
+    
+    # synonym for child=(element)
+    alias :'<<' :'child='
+    
+    # Matches the child once. If found the original index is returned.
+    # If not found NO_MATCH is returned.
+    def match parser, index
+      raise "positive element child not set" unless child
+      found = child.match parser, index
+      found ? index : NO_MATCH
+    end
+  end
+  
+  # An element which tries its single child but does not advance the index if not found.
+  # If found, however, it returns NO_MATCH. Used for a negative semantic predicate.
+  class Negative < Positive
+    def match parser, index
+      raise "negative element child not set" unless child
+      found = child.match parser, index
+      found ? NO_MATCH : index
+    end
+  end
+  
+  # Match another production in the grammar.
+  class Reference < Element
+    # The name of the production to lookup and match.
+    attr_reader :name
+
+    # Init the name
+    def initialize name=nil
+      self.name = name
+    end
+
+    # Set the name of production to match.
+    def name= value
+      @name = value.to_sym
+    end
+
+    # Match the entire production from the parser grammar. If it matches
+    # the end index is returned. If not, NO_MATCH is returned.
+    def match parser, index
+      raise "reference name not set" unless name
+      parser.match? name, index
+    end
+    
+    def to_s
+      name
+    end
+  end
+  
+  # Matcher of a grammar production. The one and only child defines the production.
+  class Production < Reference
+    # The production definition.
+    attr_accessor :child
+
+    # Init the name and child.
+    def initialize name=nil, child=nil
+      super name
+      @child = child
+    end
+
+    # Synonym of child=(element)
+    alias :'<<' :'child='
+    
+    # Match the production one time. If it matches the end index is returned. If not,
+    # NO_MATCH is returned.
+    def match parser, index
+      raise "production name not set" unless name
+      raise "production child not set" unless child
+      report @child.match(parser, index)
+    end
+  end
+  
+  # Matcher of a literal string or regular expression.
+  class Literal < Element
+    # Value to match.
+    attr_reader :value
+    
+    # Init the value.
+    def initialize value=nil
+      @value = value
+    end
+
+    # Set the value to match.
+    def value= literal
+      # Make sure regular expressions check at the beginnig of the string
+      literal = correct_regexp literal if literal.is_a? Regexp
+      @value = literal
+    end
+    
+    # Match the literal value. If it matches the end index is returned.
+    # If no, NO_MATCH is returned.
+    def match parser, index
+      report parser.literal?(value, index)
+    end
+    
+    def to_s
+      value.inspect
+    end
+  end
+
+  # Parser builder. The built in methods create syntax elements. Any other
+  # method called on this object create references to production, or actual
+  # productions, if called at the top level.
+  # Todo: Change to a class and separate from Parser.
+  class Builder < Parser
+    # Productions to build
+    attr_reader :productions
+    # Current parent being built
+    attr_reader :parent
+    
+    def initialize
+      reset!
+    end
+    
+    def reset!
+      @building = true
+      @productions = {}
+    end
+
+    # Reference a production by its name index.
+    def [] index
+      productions[index]
+    end
+    
+    # Create a production if at the top level, or a reference to a production a 
+    # production is being built.
+    def method_missing name, *args
+      if @building
+        if @parent
+          ref = Reference.new name
+          @parent << ref
+        elsif block_given?
+          prod = Production.new name
+          @parent = prod
+          yield
+          @parent = nil
+          @productions[name] = prod
+        else
+          super
+        end
+      else
+        prod = @productions[name]
+        super unless prod
+# puts "matching #{name} at #{args.first}"
+        prod.match self, args.first
+      end
+    end
+
+    # Add an Alternatives element to the parent.
+    def one &blk
+      build_piece Alternatives, blk
+    end
+    # Synonym for one().
+    alias :alt :one
+  
+    def eof *args
+      if args.length == 1 then super args.first
+      else method_missing :eof, *args
+      end
+    end
+    
+    # Add an Sequence element to the parent.
+    def each &blk
+      build_piece Sequence, blk
+    end
+    # Synonym for each()
+    alias :seq :each
+  
+    # Add an Literal element to the parent.
+    def lit *values
+      if values.size == 1
+        build_piece Literal, nil, values.first
+      else
+        one{
+          for v in values
+            build_piece Literal, nil, v
+          end
+        }
+      end
+    end
+  
+    # Add an AnyNumber element to the parent.
+    def many &blk
+      build_piece AnyNumber, blk
+    end
+  
+    # Add an Optional element to the parent.
+    def opt &blk
+      build_piece Optional, blk
+    end
+  
+    # Add an AtLeastOne element to the parent.
+    def some &blk
+      build_piece AtLeastOne, blk
+    end
+
+    def neg &blk
+      build_piece Negative, blk
+    end
+
+    def pos &blk
+      build_piece Positive, blk
+    end
+
+    def parse? goal, index=0
+      @building = nil
+      super
+    end
+
+    private
+    
+    # Add an object of klass to the parent and yield to its block. If 
+    # value is specified it is passed to the klass constructor.
+    def build_piece klass, blk=nil, value=nil
+# puts "building #{klass.name} with #{value.inspect}"
+      elem = value ? klass.new(value) : klass.new
+      @parent << elem
+      if blk
+        parent = @parent
+        @parent = elem
+        blk.call
+        @parent = parent
+      end
+    end
+    
+  end # Builder
+
+end # Peggy

data/lib/Copy of peg.rb

@@ -0,0 +1,135 @@
+require 'rubygems'
+require 'builder'
+# require File.join(File.dirname(__FILE__), 'builder')
+
+module Peggy
+
+  # Implements the Parser Expression Grammar (PEG), one of several grammars supported.
+  class PEG < Parser
+
+    class PEGCompiler < Builder
+    
+      def initialize
+        super
+        build
+      end
+  
+    private
+    
+      def build
+        # Hierarchical syntax
+        grammar{each{spacing; some{definition}; eof}}
+        definition{each{identifier; left_arrow; expression}}
+        expression{each{sequence; many{each{slash; sequence}}}}
+        sequence{many{prefix}}
+        prefix{each{opt{one{peek; disallow}}; suffix}}
+        suffix{each{primary; opt{one{question; star; plus}}}}
+        primary{one{each{identifier; neg{left_arrow}}
+          each{lparen; expression; rparen}
+          literal; klass; dot}
+        }
+        # Lexical syntax
+        identifier{each{ident_start; many{ident_cont}; spacing}}
+        ident_start{lit /[a-zA-Z_]/}
+        ident_cont{one{ident_start; lit /[0-9]/}}
+        literal{one{
+          each{quote; many{each{neg{quote}; char}}; quote; spacing}
+          each{quotes; many{each{neg{quotes}; char}}; quotes; spacing}
+        }}
+        klass{each{lit '['; many{each{neg{lit ']'}; range}}; lit ']'; spacing}}
+        range{one{each{char; lit '-'; char}; char}}
+        char{lit /\\([nrt'"\[\]\\]|[0-2][0-7][0-7]|[0-7][0-7]?)|[^\\]/}
+        #char{one{
+        #  each{lit '\\'; one{
+        #    quote
+        #    quotes
+        #    lit /[nrt\[\]\\]/
+        #    lit /[0-2][0-7][0-7]/
+        #    lit /[0-7][0-7]?/
+        #  }}
+        #  lit /[^\\]/
+        #}}
+        left_arrow{each{lit '<-'; spacing}}
+        slash{each{lit '/'; spacing}}
+        peek{each{lit '&'; spacing}}
+        disallow{each{lit '!'; spacing}}
+        question{each{lit '?'; spacing}}
+        star{each{lit '*'; spacing}}
+        plus{each{lit '+'; spacing}}
+        lparen{each{lit '('; spacing}}
+        rparen{each{lit ')'; spacing}}
+        dot{each{lit '.'; spacing}}
+        quote{lit "'"}
+        quotes{lit '"'}
+        spacing{many{one{space; comment}}}
+        comment{each{lit '#'; many{each{neg{eol}; lit /./}}; eol}}
+        space{one{lit ' '; lit "\t"; eol}}
+        eol{one{lit "\r\n"; lit "\n"; lit "\r"}}
+      end
+    end # PEGCompiler
+
+    def compile? text
+      reset!
+      compiler = PEGCompiler.new
+      raise "Invalid grammar" unless compiler.parse! :grammar, text
+      ast = compiler.ast
+      ast.find_each 'definition' do |definition|
+        send definition.identifier.to_sym do
+          if definition.count('sequence') == 1
+            build_sequence definition.expression.sequence
+          else
+            one do
+              definition.find_each 'sequence' do |sequence|
+                build_sequence sequence
+            end
+          end
+          end
+        end
+      end
+      
+    private
+
+      def build_sequence sequence
+        if sequence.count('prefix') == 1
+          build_prefix sequence.prefix
+        else
+          each do
+            sequence.find_each 'prefix' do |prefix|
+              build_prefix prefix
+            end
+          end
+        end
+      end
+      
+      def build_prefix prefix
+        if sequence.peek
+          pos do
+            build_suffix prefix.suffix
+          end
+        elsif sequence.disallow
+          neg do
+            build_suffix prefix.suffix
+          end
+        else
+          build_suffix prefix.suffix
+        end
+      end
+      
+      def build_suffix suffix
+        if suffix.question
+          opt do
+            build_primary suffix.primary
+          end
+        elsif suffix.
+          neg do
+            build_suffix prefix.suffix
+          end
+        else
+          build_suffix prefix.suffix
+        end
+      end
+
+    end
+
+  end #PEG
+end # Peggy