personify 1.0.0 → 1.1.0

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

@@ -1,404 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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