personify 1.0.0

data/vendor/treetop/lib/treetop/compiler/metagrammar.treetop

@@ -0,0 +1,404 @@
+module Treetop
+  module Compiler
+    grammar Metagrammar
+      rule treetop_file
+        prefix:space? module_or_grammar:(module_declaration / grammar) suffix:space? {
+          def compile
+            prefix.text_value + module_or_grammar.compile + suffix.text_value
+          end
+        }
+      end
+      
+      rule module_declaration
+        prefix:('module' space [A-Z] alphanumeric_char* space) module_contents:(module_declaration / grammar) suffix:(space 'end') {
+          def compile
+            prefix.text_value + module_contents.compile + suffix.text_value
+          end
+        }
+      end
+
+      rule grammar
+        'grammar' space grammar_name space ('do' space)? declaration_sequence space? 'end' <Grammar>
+      end
+
+      rule grammar_name
+        ([A-Z] alphanumeric_char*)
+      end
+
+      rule declaration_sequence
+        head:declaration tail:(space declaration)* <DeclarationSequence> {
+          def declarations
+            [head] + tail
+          end
+      
+          def tail
+            super.elements.map { |elt| elt.declaration }
+          end
+        }
+        /
+        '' {
+          def compile(builder)
+          end
+        }
+      end
+      
+      rule declaration
+        parsing_rule / include_declaration
+      end
+      
+      rule include_declaration
+        'include' space [A-Z] (alphanumeric_char / '::')* {
+          def compile(builder)
+            builder << text_value
+          end
+        }
+      end
+
+      rule parsing_rule
+        'rule' space nonterminal space ('do' space)? parsing_expression space 'end' <ParsingRule>
+      end
+
+      rule parsing_expression
+        choice / sequence / primary
+      end
+
+      rule choice
+        head:alternative tail:(space? '/' space? alternative)+ <Choice> {
+          def alternatives
+            [head] + tail
+          end
+          
+          def tail
+            super.elements.map {|elt| elt.alternative}
+          end
+          
+          def inline_modules
+            (alternatives.map {|alt| alt.inline_modules }).flatten
+          end
+        }
+      end
+
+      rule sequence
+        head:labeled_sequence_primary tail:(space labeled_sequence_primary)+ node_class_declarations <Sequence> {
+          def sequence_elements
+            [head] + tail
+          end
+    
+          def tail
+            super.elements.map {|elt| elt.labeled_sequence_primary }
+          end
+      
+          def inline_modules
+            (sequence_elements.map {|elt| elt.inline_modules}).flatten +
+            [sequence_element_accessor_module] +
+            node_class_declarations.inline_modules
+          end
+      
+          def inline_module_name
+            node_class_declarations.inline_module_name
+          end
+        }
+      end
+
+      rule alternative
+        sequence / primary
+      end
+
+      rule primary
+        prefix atomic {
+          def compile(address, builder, parent_expression=nil)
+            prefix.compile(address, builder, self)
+          end
+      
+          def prefixed_expression
+            atomic
+          end
+      
+          def inline_modules
+            atomic.inline_modules
+          end
+      
+          def inline_module_name
+            nil
+          end
+        }
+        /
+        atomic suffix node_class_declarations {
+          def compile(address, builder, parent_expression=nil)
+            suffix.compile(address, builder, self)
+          end
+      
+          def optional_expression
+            atomic
+          end
+      
+          def node_class_name
+            node_class_declarations.node_class_name
+          end
+      
+          def inline_modules
+            atomic.inline_modules + node_class_declarations.inline_modules
+          end
+      
+          def inline_module_name
+            node_class_declarations.inline_module_name
+          end
+        }
+        /
+        atomic node_class_declarations {
+          def compile(address, builder, parent_expression=nil)
+            atomic.compile(address, builder, self)
+          end
+      
+          def node_class_name
+            node_class_declarations.node_class_name
+          end
+      
+          def inline_modules
+            atomic.inline_modules + node_class_declarations.inline_modules
+          end
+      
+          def inline_module_name
+            node_class_declarations.inline_module_name
+          end
+        }
+      end
+
+      rule labeled_sequence_primary
+        label sequence_primary {
+          def compile(lexical_address, builder)
+            sequence_primary.compile(lexical_address, builder)
+          end
+      
+          def inline_modules
+            sequence_primary.inline_modules
+          end
+      
+          def label_name
+            if label.name
+              label.name
+            elsif sequence_primary.instance_of?(Nonterminal)
+              sequence_primary.text_value
+            else
+              nil
+            end
+          end
+        }
+      end
+  
+      rule label
+        (alpha_char alphanumeric_char*) ':' {
+          def name
+            elements[0].text_value
+          end
+        }
+        /
+        '' {
+          def name
+            nil
+          end
+        }
+      end
+
+      rule sequence_primary
+        prefix atomic {
+          def compile(lexical_address, builder)
+            prefix.compile(lexical_address, builder, self)
+          end
+      
+          def prefixed_expression
+            elements[1]
+          end
+      
+          def inline_modules
+            atomic.inline_modules
+          end
+      
+          def inline_module_name
+            nil
+          end
+        }
+        /
+        atomic suffix {
+          def compile(lexical_address, builder)
+            suffix.compile(lexical_address, builder, self)
+          end
+      
+          def node_class_name
+            nil
+          end
+      
+          def inline_modules
+            atomic.inline_modules
+          end
+      
+          def inline_module_name
+            nil
+          end
+        }
+        /
+        atomic
+      end
+  
+      rule suffix
+        repetition_suffix / optional_suffix
+      end
+  
+      rule optional_suffix
+        '?' <Optional>
+      end
+      
+      rule node_class_declarations
+        node_class_expression trailing_inline_module {
+          def node_class_name
+            node_class_expression.node_class_name
+          end
+      
+          def inline_modules
+            trailing_inline_module.inline_modules
+          end
+      
+          def inline_module
+            trailing_inline_module.inline_module
+          end
+      
+          def inline_module_name
+            inline_module.module_name if inline_module
+          end
+        }
+      end
+
+      rule repetition_suffix
+        '+' <OneOrMore> / '*' <ZeroOrMore>
+      end
+
+      rule prefix
+        '&' <AndPredicate> / '!' <NotPredicate> / '~' <TransientPrefix>
+      end
+
+      rule atomic
+        terminal
+        /
+        nonterminal
+        /
+        parenthesized_expression
+      end
+
+      rule parenthesized_expression
+        '(' space? parsing_expression space? ')' <ParenthesizedExpression> {
+          def inline_modules
+            parsing_expression.inline_modules
+          end
+        }
+      end
+
+      rule nonterminal
+        !keyword_inside_grammar (alpha_char alphanumeric_char*) <Nonterminal>
+      end
+
+      rule terminal
+        quoted_string / character_class / anything_symbol
+      end
+      
+      rule quoted_string
+        (single_quoted_string / double_quoted_string) {
+          def string
+            super.text_value
+          end
+        }
+      end
+      
+      rule double_quoted_string
+        '"' string:(!'"' ("\\\\" / '\"' / .))* '"' <Terminal>
+      end
+
+      rule single_quoted_string
+        "'" string:(!"'" ("\\\\" / "\\'" / .))* "'" <Terminal>
+      end
+
+      rule character_class
+	'[' characters:(!']' ('\\' . /!'\\' .))+ ']' <CharacterClass> {
+          def characters
+            super.text_value
+          end
+        }
+      end
+
+      rule anything_symbol
+        '.' <AnythingSymbol>
+      end
+
+      rule node_class_expression
+        space '<' (!'>' .)+ '>' {
+          def node_class_name
+            elements[2].text_value
+          end
+        }
+        /
+        '' {
+          def node_class_name
+            nil
+          end
+        }
+      end
+
+      rule trailing_inline_module
+        space inline_module {
+          def inline_modules
+            [inline_module]
+          end
+                
+          def inline_module_name
+            inline_module.module_name
+          end
+        }
+        /
+        '' {
+          def inline_modules
+            []
+          end
+      
+          def inline_module
+            nil 
+          end
+      
+          def inline_module_name
+            nil
+          end
+        }
+      end
+
+      rule inline_module
+        '{' (inline_module / ![{}] .)* '}' <InlineModule>
+      end
+
+      rule keyword_inside_grammar
+        ('rule' / 'end') !non_space_char
+      end
+
+      rule non_space_char
+        !space .
+      end
+
+      rule alpha_char
+        [A-Za-z_]
+      end
+
+      rule alphanumeric_char
+        alpha_char / [0-9]
+      end
+
+      rule space
+        (white / comment_to_eol)+
+      end
+
+      rule comment_to_eol
+        '#' (!"\n" .)*
+      end
+
+      rule white
+        [ \t\n\r]
+      end
+    end
+  end
+end

data/vendor/treetop/lib/treetop/compiler/node_classes/anything_symbol.rb

@@ -0,0 +1,20 @@
+module Treetop
+  module Compiler    
+    class AnythingSymbol < AtomicExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+        builder.if__ "index < input_length" do
+          builder << 'next_character = index + input[index..-1].match(/\A(.)/um).end(1)'
+          assign_result "instantiate_node(#{node_class_name},input, index...next_character)"
+          extend_result_with_inline_module
+          builder << "@index = next_character"
+        end
+        builder.else_ do
+          builder << 'terminal_parse_failure("any character")'
+          assign_result 'nil'
+        end
+      end
+    end
+  end
+end
+

data/vendor/treetop/lib/treetop/compiler/node_classes/atomic_expression.rb

@@ -0,0 +1,14 @@
+module Treetop
+  module Compiler
+    class AtomicExpression < ParsingExpression
+      def inline_modules
+        []
+      end
+      
+      def single_quote(string)
+	# Double any backslashes, then backslash any single-quotes:
+	"'#{string.gsub(/\\/) { '\\\\' }.gsub(/'/) { "\\'"}}'"
+      end
+    end
+  end
+end

data/vendor/treetop/lib/treetop/compiler/node_classes/character_class.rb

@@ -0,0 +1,22 @@
+module Treetop
+  module Compiler    
+    class CharacterClass < AtomicExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+        
+        builder.if__ "input.index(Regexp.new(#{single_quote(text_value)},nil,'u'), index) == index" do
+          builder << 'next_character = index + input[index..-1].match(/\A(.)/um).end(1)'
+          assign_result "instantiate_node(#{node_class_name},input, index...next_character)"
+          extend_result_with_inline_module
+          builder << "@index = next_character"
+        end
+        builder.else_ do
+          "terminal_parse_failure(#{single_quote(characters)})"
+          assign_result 'nil'
+        end
+      end
+    end
+  end
+end
+
+

data/vendor/treetop/lib/treetop/compiler/node_classes/choice.rb

@@ -0,0 +1,31 @@
+module Treetop
+  module Compiler
+    class Choice < ParsingExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+        begin_comment(self)
+        use_vars :result, :start_index
+        compile_alternatives(alternatives)
+        end_comment(self)
+      end
+      
+      def compile_alternatives(alternatives)
+        obtain_new_subexpression_address
+        alternatives.first.compile(subexpression_address, builder)
+        builder.if__ subexpression_success? do
+          assign_result subexpression_result_var
+          extend_result_with_declared_module
+          extend_result_with_inline_module
+        end
+        builder.else_ do
+          if alternatives.size == 1
+            reset_index
+            assign_failure start_index_var
+          else
+            compile_alternatives(alternatives[1..-1])
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/treetop/lib/treetop/compiler/node_classes/declaration_sequence.rb

@@ -0,0 +1,24 @@
+module Treetop
+  module Compiler
+    class DeclarationSequence < Runtime::SyntaxNode
+
+      def compile(builder)
+        unless rules.empty?
+          builder.method_declaration("root") do
+            builder << "@root || :#{rules.first.name}"
+          end
+          builder.newline
+        end
+        
+        declarations.each do |declaration|
+          declaration.compile(builder)
+          builder.newline
+        end
+      end
+      
+      def rules
+        declarations.select { |declaration| declaration.instance_of?(ParsingRule) }
+      end
+    end
+  end
+end

data/vendor/treetop/lib/treetop/compiler/node_classes/grammar.rb

@@ -0,0 +1,28 @@
+module Treetop
+  module Compiler
+    class Grammar < Runtime::SyntaxNode
+      def compile
+        builder = RubyBuilder.new
+        
+        builder.module_declaration "#{grammar_name.text_value}" do
+          builder.in(indent_level) # account for initial indentation of grammar declaration
+          builder << "include Treetop::Runtime"
+          builder.newline
+          declaration_sequence.compile(builder)
+        end
+        builder.newline
+        builder.class_declaration "#{parser_name} < Treetop::Runtime::CompiledParser" do
+          builder << "include #{grammar_name.text_value}"
+        end
+      end
+      
+      def indent_level
+        input.column_of(interval.begin) - 1
+      end
+      
+      def parser_name
+        grammar_name.text_value + 'Parser'
+      end
+    end
+ end 
+end

data/vendor/treetop/lib/treetop/compiler/node_classes/inline_module.rb

@@ -0,0 +1,27 @@
+module Treetop
+  module Compiler
+    module InlineModuleMixin
+      attr_reader :module_name
+      
+      def compile(index, builder, rule)
+        @module_name = "#{rule.name.treetop_camelize}#{index}"
+      end
+    end
+    
+    class InlineModule < Runtime::SyntaxNode
+
+      include InlineModuleMixin
+      
+      def compile(index, builder, rule)
+        super
+        builder.module_declaration(module_name) do
+          builder << ruby_code.gsub(/\A\n/, '').rstrip
+        end
+      end
+      
+      def ruby_code
+        elements[1].text_value
+      end
+    end
+  end
+end

data/vendor/treetop/lib/treetop/compiler/node_classes/nonterminal.rb

@@ -0,0 +1,13 @@
+module Treetop
+  module Compiler    
+    class Nonterminal < AtomicExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+        use_vars :result
+        assign_result text_value == 'super' ? 'super' : "_nt_#{text_value}"
+        extend_result_with_declared_module
+        extend_result_with_inline_module
+      end
+    end
+  end
+end

data/vendor/treetop/lib/treetop/compiler/node_classes/optional.rb

@@ -0,0 +1,19 @@
+module Treetop
+  module Compiler
+    class Optional < ParsingExpression
+      def compile(address, builder, parent_expression)
+        super
+        use_vars :result
+        obtain_new_subexpression_address
+        parent_expression.atomic.compile(subexpression_address, builder)
+        
+        builder.if__ subexpression_success? do
+          assign_result subexpression_result_var
+        end
+        builder.else_ do
+          assign_result epsilon_node
+        end
+      end
+    end
+  end
+end

data/vendor/treetop/lib/treetop/compiler/node_classes/parenthesized_expression.rb

@@ -0,0 +1,9 @@
+module Treetop
+  module Compiler    
+    class ParenthesizedExpression < ParsingExpression
+      def compile(address, builder, parent_expression = nil)
+        elements[2].compile(address, builder, parent_expression)
+      end
+    end
+  end
+end