swift-pyrite 0.1.0

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/lib/treetop/compiler/metagrammar.treetop

@@ -0,0 +1,503 @@
+module Treetop
+  module Compiler
+    grammar Metagrammar
+      rule treetop_file
+        requires:(space? require_statement)* spacing:space? module_or_grammar suffix:space? {
+          def compile
+            requires.text_value + spacing.text_value + module_or_grammar.compile + suffix.text_value
+          end
+        }
+      end
+
+      rule require_statement
+        spacing:space? "require" [ \t]+ [^\n\r]+ [\n\r]
+      end
+
+      rule module_or_grammar
+	module_declaration / grammar
+      end
+
+      rule module_declaration
+        module_prefix:('module' space name:([A-Z] alphanumeric_char* ('::' [A-Z] alphanumeric_char*)*) space) module_contents:(module_declaration / grammar) suffix:(space 'end') {
+          def compile
+            module_prefix.text_value + module_contents.compile + suffix.text_value
+          end
+
+	  def parser_name
+	    module_prefix.name.text_value+'::'+module_contents.parser_name
+	  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
+        sequence_body node_class_declarations <Sequence> {
+          def sequence_elements
+            [sequence_body.head] + tail
+          end
+
+          def tail
+            sequence_body.tail
+          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 sequence_body
+        variable_length_sequence_body / labeled_expression_sequence_body
+      end
+
+      rule variable_length_sequence_body
+        head:optionally_labeled_sequence_primary tail:(space optionally_labeled_sequence_primary)+ {
+          def tail
+            super.elements.map {|elt| elt.optionally_labeled_sequence_primary }
+          end
+        }
+      end
+
+      rule labeled_expression_sequence_body
+        labeled_sequence_primary {
+          def head
+            self
+          end
+
+          def tail
+            []
+          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
+        }
+        /
+	prefix space? atomic:predicate_block {
+          def compile(address, builder, parent_expression=nil)
+            prefix.compile(address, builder, self)
+          end
+          def prefixed_expression
+            atomic
+          end
+          def inline_modules
+            []
+          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 optionally_labeled_sequence_primary
+        labeled_sequence_primary / unlabeled_sequence_primary
+      end
+
+      rule labeled_sequence_primary
+        named_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
+            named_label.name
+          end
+        }
+      end
+
+      rule unlabeled_sequence_primary
+        null_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 sequence_primary.instance_of?(Nonterminal)
+              sequence_primary.text_value
+            else
+              nil
+            end
+          end
+        }
+      end
+
+      rule label
+        named_label / null_label
+      end
+
+      rule named_label
+        (alpha_char alphanumeric_char*) ':' {
+          def name
+            elements[0].text_value
+          end
+        }
+      end
+
+      rule null_label
+        '' {
+          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
+        }
+        /
+        prefix space? atomic:predicate_block {
+          def compile(address, builder, parent_expression=nil)
+            prefix.compile(address, builder, self)
+          end
+          def prefixed_expression
+            atomic
+          end
+          def inline_modules
+            []
+          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> / occurrence_range
+      end
+
+      rule occurrence_range
+	space? min:([0-9])* '..' max:([0-9])* <OccurrenceRange>
+      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
+        qs:(single_quoted_string / double_quoted_string) modifiers:([ir]*) <Terminal> {
+          def string
+            qs.text_value
+          end
+        }
+      end
+
+      rule double_quoted_string
+        '"' string:(!'"' ("\\\\" / '\"' / .))* '"'
+      end
+
+      rule single_quoted_string
+        "'" string:(!"'" ("\\\\" / "\\'" / .))* "'"
+      end
+
+      rule character_class
+        '[' characters:(!']' ('\\' . / bracket_expression / !'\\' .))+ ']' <CharacterClass> {
+          def characters
+            super.text_value
+          end
+        }
+      end
+
+      rule bracket_expression
+         '[:' '^'? (
+           'alnum' / 'alpha' / 'blank' / 'cntrl' / 'digit' / 'graph' / 'lower' /
+           'print' / 'punct' / 'space' / 'upper' / 'xdigit' / 'word'
+         ) ':]'
+      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 predicate_block
+        '' inline_module <PredicateBlock>
+      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/bundle/ruby/2.0.0/gems/treetop-1.6.3/lib/treetop/compiler/node_classes/anything_symbol.rb

@@ -0,0 +1,26 @@
+module Treetop
+  module Compiler    
+    class AnythingSymbol < AtomicExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+        builder.if__ "index < input_length" do
+          if address == 0 || decorated?
+	    assign_result "instantiate_node(#{node_class_name},input, index...(index + 1))"
+	    extend_result_with_inline_module
+          else
+            assign_lazily_instantiated_node
+          end
+          builder << "@index += 1"
+        end
+        builder.else_ do
+          builder << 'terminal_parse_failure("any character")'
+          assign_result 'nil'
+        end
+      end
+
+      def expected
+	'"any character"'
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/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/bundle/ruby/2.0.0/gems/treetop-1.6.3/lib/treetop/compiler/node_classes/character_class.rb

@@ -0,0 +1,32 @@
+module Treetop
+  module Compiler    
+    class CharacterClass < AtomicExpression
+      def compile(address, builder, parent_expression = nil)
+        super
+
+        builder.if__ "has_terminal?(@regexps[gr = #{grounded_regexp(text_value)}] ||= Regexp.new(gr), :regexp, index)" do
+          if address == 0 || decorated?
+            assign_result "instantiate_node(#{node_class_name},input, index...(index + 1))"
+            extend_result_with_inline_module
+          else
+            assign_lazily_instantiated_node
+          end
+          builder << "@index += 1"  # Always one character
+        end
+        builder.else_ do
+          builder << "terminal_parse_failure(#{expected})"
+          assign_result 'nil'
+        end
+      end
+
+      def expected
+	single_quote('['+characters+']')
+      end
+
+      def grounded_regexp(string)
+        # Double any backslashes, then backslash any single-quotes:
+        "'\\A#{string.gsub(/\\/) { '\\\\' }.gsub(/'/) { "\\'"}}'"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/lib/treetop/compiler/node_classes/choice.rb

@@ -0,0 +1,37 @@
+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
+	  # Undo lazy instantiation:
+	  builder << "#{subexpression_result_var} = SyntaxNode.new(input, (index-1)...index) if #{subexpression_result_var} == true"
+          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
+
+      def expected
+	'"(any alternative)"'
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/treetop-1.6.3/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/bundle/ruby/2.0.0/gems/treetop-1.6.3/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/bundle/ruby/2.0.0/gems/treetop-1.6.3/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/bundle/ruby/2.0.0/gems/treetop-1.6.3/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