#!/usr/bin/env ruby # # SfpLang.g # -- # Generated using ANTLR version: 3.5 # Ruby runtime library version: 1.10.0 # Input grammar file: SfpLang.g # Generated at: 2013-12-19 16:23:34 # # ~~~> start load path setup this_directory = File.expand_path( File.dirname( __FILE__ ) ) $LOAD_PATH.unshift( this_directory ) unless $LOAD_PATH.include?( this_directory ) antlr_load_failed = proc do load_path = $LOAD_PATH.map { |dir| ' - ' << dir }.join( $/ ) raise LoadError, <<-END.strip! Failed to load the ANTLR3 runtime library (version 1.10.0): Ensure the library has been installed on your system and is available on the load path. If rubygems is available on your system, this can be done with the command: gem install antlr3 Current load path: #{ load_path } END end defined?( ANTLR3 ) or begin # 1: try to load the ruby antlr3 runtime library from the system path require 'antlr3' rescue LoadError # 2: try to load rubygems if it isn't already loaded defined?( Gem ) or begin require 'rubygems' rescue LoadError antlr_load_failed.call end # 3: try to activate the antlr3 gem begin defined?( gem ) and gem( 'antlr3', '~> 1.10.0' ) rescue Gem::LoadError antlr_load_failed.call end require 'antlr3' end # <~~~ end load path setup module SfpLang # TokenData defines all of the token type integer values # as constants, which will be included in all # ANTLR-generated recognizers. const_defined?( :TokenData ) or TokenData = ANTLR3::TokenScheme.new module TokenData # define the token constants define_tokens( :EOF => -1, :T__18 => 18, :T__19 => 19, :T__20 => 20, :T__21 => 21, :T__22 => 22, :T__23 => 23, :T__24 => 24, :T__25 => 25, :T__26 => 26, :T__27 => 27, :T__28 => 28, :T__29 => 29, :T__30 => 30, :T__31 => 31, :T__32 => 32, :T__33 => 33, :T__34 => 34, :T__35 => 35, :T__36 => 36, :T__37 => 37, :T__38 => 38, :T__39 => 39, :T__40 => 40, :T__41 => 41, :T__42 => 42, :T__43 => 43, :T__44 => 44, :T__45 => 45, :T__46 => 46, :T__47 => 47, :T__48 => 48, :T__49 => 49, :T__50 => 50, :T__51 => 51, :T__52 => 52, :T__53 => 53, :T__54 => 54, :T__55 => 55, :T__56 => 56, :T__57 => 57, :T__58 => 58, :T__59 => 59, :T__60 => 60, :T__61 => 61, :T__62 => 62, :T__63 => 63, :T__64 => 64, :T__65 => 65, :T__66 => 66, :T__67 => 67, :T__68 => 68, :T__69 => 69, :T__70 => 70, :T__71 => 71, :T__72 => 72, :T__73 => 73, :T__74 => 74, :T__75 => 75, :T__76 => 76, :T__77 => 77, :T__78 => 78, :T__79 => 79, :T__80 => 80, :T__81 => 81, :T__82 => 82, :T__83 => 83, :T__84 => 84, :T__85 => 85, :BOOLEAN => 4, :COMMENT => 5, :ESC_SEQ => 6, :EXPONENT => 7, :HEX_DIGIT => 8, :ID => 9, :MULTILINE_STRING => 10, :NL => 11, :NULL => 12, :NUMBER => 13, :OCTAL_ESC => 14, :STRING => 15, :UNICODE_ESC => 16, :WS => 17 ) # register the proper human-readable name or literal value # for each token type # # this is necessary because anonymous tokens, which are # created from literal values in the grammar, do not # have descriptive names register_names( "BOOLEAN", "COMMENT", "ESC_SEQ", "EXPONENT", "HEX_DIGIT", "ID", "MULTILINE_STRING", "NL", "NULL", "NUMBER", "OCTAL_ESC", "STRING", "UNICODE_ESC", "WS", "'!='", "'('", "')'", "'*='", "'+='", "','", "'-='", "'.'", "'/='", "':'", "':different'", "'<'", "'<='", "'='", "'>'", "'>='", "'['", "']'", "'abstract'", "'add('", "'after'", "'always'", "'any'", "'areall'", "'as'", "'before'", "'class'", "'condition'", "'conditions'", "'constraint'", "'cost'", "'delete'", "'effect'", "'effects'", "'either'", "'exist'", "'extends'", "'final'", "'forall'", "'foreach'", "'forsome'", "'global'", "'goal'", "'has'", "'if'", "'in'", "'include'", "'is'", "'isa'", "'isnot'", "'isnt'", "'isref'", "'isset'", "'new'", "'not'", "'or'", "'procedure'", "'remove('", "'schema'", "'sometime'", "'state'", "'sub'", "'synchronized'", "'then'", "'total('", "'within'", "'{'", "'}'" ) end class Parser < ANTLR3::Parser @grammar_home = SfpLang include ANTLR3::ASTBuilder RULE_METHODS = [ :sfp, :constraint_def, :include, :include_file, :state, :class_def, :extends_class, :attribute, :attribute_stmt, :object_schema, :object_schemata, :abstract_object, :object_def, :object_body, :object_attribute, :state_dependency, :dep_effect, :op_param, :op_conditions, :op_effects, :op_statement, :procedure, :parameters, :parameter, :conditions, :effects, :goal_constraint, :global_constraint, :sometime_constraint, :goal_body, :nested_constraint, :constraint, :constraint_body, :constraint_namespace, :constraint_iterator, :quantification_keyword, :constraint_class_quantification, :constraint_different, :constraint_statement, :total_constraint, :total_statement, :comp_value, :conditional_constraint, :conditional_constraint_if_part, :conditional_constraint_then_part, :effect_body, :mutation_iterator, :mutation, :set_value, :set_item, :value, :primitive_value, :path, :path_with_index, :id_ref, :reference, :reference_type, :set_type, :probability_op, :equals_op, :not_equals_op, :binary_op, :binary_comp ].freeze include TokenData begin generated_using( "SfpLang.g", "3.5", "1.10.0" ) rescue NoMethodError => error # ignore end def initialize( input, options = {} ) super( input, options ) end include Sfp::SfpLangHelper # - - - - - - - - - - - - Rules - - - - - - - - - - - - - SfpReturnValue = define_return_scope # # parser rule sfp # # (in SfpLang.g) # 39:1: sfp : ( NL )* ( ( object_def | abstract_object | state | constraint_def | class_def | procedure ) ( NL )* | include )* ; # def sfp # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 1 ) return_value = SfpReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __NL1__ = nil __NL8__ = nil object_def2 = nil abstract_object3 = nil state4 = nil constraint_def5 = nil class_def6 = nil procedure7 = nil include9 = nil tree_for_NL1 = nil tree_for_NL8 = nil begin root_0 = @adaptor.create_flat_list # at line 40:4: ( NL )* ( ( object_def | abstract_object | state | constraint_def | class_def | procedure ) ( NL )* | include )* # --> action self.init # <-- action # at line 41:3: ( NL )* while true # decision 1 alt_1 = 2 look_1_0 = @input.peek( 1 ) if ( look_1_0 == NL ) alt_1 = 1 end case alt_1 when 1 # at line 41:3: NL __NL1__ = match( NL, TOKENS_FOLLOWING_NL_IN_sfp_49 ) tree_for_NL1 = @adaptor.create_with_payload( __NL1__ ) @adaptor.add_child( root_0, tree_for_NL1 ) else break # out of loop for decision 1 end end # loop for decision 1 # at line 42:3: ( ( object_def | abstract_object | state | constraint_def | class_def | procedure ) ( NL )* | include )* while true # decision 4 alt_4 = 3 look_4_0 = @input.peek( 1 ) if ( look_4_0 == ID || look_4_0 == T__36 || look_4_0 == T__39 || look_4_0 == T__44 || look_4_0.between?( T__59, T__60 ) || look_4_0 == T__74 || look_4_0.between?( T__76, T__77 ) || look_4_0.between?( T__79, T__80 ) ) alt_4 = 1 elsif ( look_4_0 == T__64 ) alt_4 = 2 end case alt_4 when 1 # at line 42:5: ( object_def | abstract_object | state | constraint_def | class_def | procedure ) ( NL )* # at line 42:5: ( object_def | abstract_object | state | constraint_def | class_def | procedure ) alt_2 = 6 case look_2 = @input.peek( 1 ) when ID then look_2_1 = @input.peek( 2 ) if ( look_2_1 == T__78 ) alt_2 = 3 elsif ( look_2_1 == EOF || look_2_1 == ID || look_2_1 == NL || look_2_1 == T__36 || look_2_1 == T__39 || look_2_1 == T__44 || look_2_1 == T__54 || look_2_1.between?( T__59, T__60 ) || look_2_1 == T__64 || look_2_1 == T__66 || look_2_1 == T__74 || look_2_1.between?( T__76, T__77 ) || look_2_1.between?( T__79, T__80 ) || look_2_1 == T__84 ) alt_2 = 1 else raise NoViableAlternative( "", 2, 1 ) end when T__36 then alt_2 = 2 when T__39, T__59, T__60, T__77 then alt_2 = 4 when T__44, T__76 then alt_2 = 5 when T__74, T__79, T__80 then alt_2 = 6 else raise NoViableAlternative( "", 2, 0 ) end case alt_2 when 1 # at line 42:6: object_def @state.following.push( TOKENS_FOLLOWING_object_def_IN_sfp_57 ) object_def2 = object_def @state.following.pop @adaptor.add_child( root_0, object_def2.tree ) when 2 # at line 42:19: abstract_object @state.following.push( TOKENS_FOLLOWING_abstract_object_IN_sfp_61 ) abstract_object3 = abstract_object @state.following.pop @adaptor.add_child( root_0, abstract_object3.tree ) when 3 # at line 42:37: state @state.following.push( TOKENS_FOLLOWING_state_IN_sfp_65 ) state4 = state @state.following.pop @adaptor.add_child( root_0, state4.tree ) when 4 # at line 42:45: constraint_def @state.following.push( TOKENS_FOLLOWING_constraint_def_IN_sfp_69 ) constraint_def5 = constraint_def @state.following.pop @adaptor.add_child( root_0, constraint_def5.tree ) when 5 # at line 42:62: class_def @state.following.push( TOKENS_FOLLOWING_class_def_IN_sfp_73 ) class_def6 = class_def @state.following.pop @adaptor.add_child( root_0, class_def6.tree ) when 6 # at line 42:74: procedure @state.following.push( TOKENS_FOLLOWING_procedure_IN_sfp_77 ) procedure7 = procedure @state.following.pop @adaptor.add_child( root_0, procedure7.tree ) end # at line 42:85: ( NL )* while true # decision 3 alt_3 = 2 look_3_0 = @input.peek( 1 ) if ( look_3_0 == NL ) alt_3 = 1 end case alt_3 when 1 # at line 42:85: NL __NL8__ = match( NL, TOKENS_FOLLOWING_NL_IN_sfp_80 ) tree_for_NL8 = @adaptor.create_with_payload( __NL8__ ) @adaptor.add_child( root_0, tree_for_NL8 ) else break # out of loop for decision 3 end end # loop for decision 3 when 2 # at line 43:5: include @state.following.push( TOKENS_FOLLOWING_include_IN_sfp_87 ) include9 = include @state.following.pop @adaptor.add_child( root_0, include9.tree ) else break # out of loop for decision 4 end end # loop for decision 4 # --> action self.finalize # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 1 ) end return return_value end ConstraintDefReturnValue = define_return_scope # # parser rule constraint_def # # (in SfpLang.g) # 47:1: constraint_def : ( goal_constraint | global_constraint | sometime_constraint ); # def constraint_def # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 2 ) return_value = ConstraintDefReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil goal_constraint10 = nil global_constraint11 = nil sometime_constraint12 = nil begin # at line 48:2: ( goal_constraint | global_constraint | sometime_constraint ) alt_5 = 3 case look_5 = @input.peek( 1 ) when T__60 then alt_5 = 1 when T__39, T__59 then alt_5 = 2 when T__77 then alt_5 = 3 else raise NoViableAlternative( "", 5, 0 ) end case alt_5 when 1 root_0 = @adaptor.create_flat_list # at line 48:4: goal_constraint @state.following.push( TOKENS_FOLLOWING_goal_constraint_IN_constraint_def_105 ) goal_constraint10 = goal_constraint @state.following.pop @adaptor.add_child( root_0, goal_constraint10.tree ) when 2 root_0 = @adaptor.create_flat_list # at line 49:4: global_constraint @state.following.push( TOKENS_FOLLOWING_global_constraint_IN_constraint_def_110 ) global_constraint11 = global_constraint @state.following.pop @adaptor.add_child( root_0, global_constraint11.tree ) when 3 root_0 = @adaptor.create_flat_list # at line 50:4: sometime_constraint @state.following.push( TOKENS_FOLLOWING_sometime_constraint_IN_constraint_def_115 ) sometime_constraint12 = sometime_constraint @state.following.pop @adaptor.add_child( root_0, sometime_constraint12.tree ) end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 2 ) end return return_value end IncludeReturnValue = define_return_scope # # parser rule include # # (in SfpLang.g) # 53:1: include : 'include' include_file ( NL )+ ; # def include # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 3 ) return_value = IncludeReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal13 = nil __NL15__ = nil include_file14 = nil tree_for_string_literal13 = nil tree_for_NL15 = nil begin root_0 = @adaptor.create_flat_list # at line 54:4: 'include' include_file ( NL )+ string_literal13 = match( T__64, TOKENS_FOLLOWING_T__64_IN_include_126 ) tree_for_string_literal13 = @adaptor.create_with_payload( string_literal13 ) @adaptor.add_child( root_0, tree_for_string_literal13 ) @state.following.push( TOKENS_FOLLOWING_include_file_IN_include_128 ) include_file14 = include_file @state.following.pop @adaptor.add_child( root_0, include_file14.tree ) # at file 54:27: ( NL )+ match_count_6 = 0 while true alt_6 = 2 look_6_0 = @input.peek( 1 ) if ( look_6_0 == NL ) alt_6 = 1 end case alt_6 when 1 # at line 54:27: NL __NL15__ = match( NL, TOKENS_FOLLOWING_NL_IN_include_130 ) tree_for_NL15 = @adaptor.create_with_payload( __NL15__ ) @adaptor.add_child( root_0, tree_for_NL15 ) else match_count_6 > 0 and break eee = EarlyExit(6) raise eee end match_count_6 += 1 end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 3 ) end return return_value end IncludeFileReturnValue = define_return_scope # # parser rule include_file # # (in SfpLang.g) # 57:1: include_file : STRING ; # def include_file # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 4 ) return_value = IncludeFileReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __STRING16__ = nil tree_for_STRING16 = nil begin root_0 = @adaptor.create_flat_list # at line 58:4: STRING __STRING16__ = match( STRING, TOKENS_FOLLOWING_STRING_IN_include_file_142 ) tree_for_STRING16 = @adaptor.create_with_payload( __STRING16__ ) @adaptor.add_child( root_0, tree_for_STRING16 ) # --> action self.process_file(__STRING16__.text[1,__STRING16__.text.length-2]) # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 4 ) end return return_value end StateReturnValue = define_return_scope # # parser rule state # # (in SfpLang.g) # 62:1: state : ID 'state' ( NL )* '{' ( NL )* ( attribute )* '}' ; # def state # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 5 ) return_value = StateReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __ID17__ = nil string_literal18 = nil __NL19__ = nil char_literal20 = nil __NL21__ = nil char_literal23 = nil attribute22 = nil tree_for_ID17 = nil tree_for_string_literal18 = nil tree_for_NL19 = nil tree_for_char_literal20 = nil tree_for_NL21 = nil tree_for_char_literal23 = nil begin root_0 = @adaptor.create_flat_list # at line 63:4: ID 'state' ( NL )* '{' ( NL )* ( attribute )* '}' __ID17__ = match( ID, TOKENS_FOLLOWING_ID_IN_state_158 ) tree_for_ID17 = @adaptor.create_with_payload( __ID17__ ) @adaptor.add_child( root_0, tree_for_ID17 ) string_literal18 = match( T__78, TOKENS_FOLLOWING_T__78_IN_state_160 ) tree_for_string_literal18 = @adaptor.create_with_payload( string_literal18 ) @adaptor.add_child( root_0, tree_for_string_literal18 ) # at line 63:15: ( NL )* while true # decision 7 alt_7 = 2 look_7_0 = @input.peek( 1 ) if ( look_7_0 == NL ) alt_7 = 1 end case alt_7 when 1 # at line 63:15: NL __NL19__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_162 ) tree_for_NL19 = @adaptor.create_with_payload( __NL19__ ) @adaptor.add_child( root_0, tree_for_NL19 ) else break # out of loop for decision 7 end end # loop for decision 7 # --> action @now[__ID17__.text] = { '_self' => __ID17__.text, '_context' => 'state', '_parent' => @now } @now = @now[__ID17__.text] # <-- action char_literal20 = match( T__84, TOKENS_FOLLOWING_T__84_IN_state_171 ) tree_for_char_literal20 = @adaptor.create_with_payload( char_literal20 ) @adaptor.add_child( root_0, tree_for_char_literal20 ) # at line 71:7: ( NL )* while true # decision 8 alt_8 = 2 look_8_0 = @input.peek( 1 ) if ( look_8_0 == NL ) alt_8 = 1 end case alt_8 when 1 # at line 71:7: NL __NL21__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_173 ) tree_for_NL21 = @adaptor.create_with_payload( __NL21__ ) @adaptor.add_child( root_0, tree_for_NL21 ) else break # out of loop for decision 8 end end # loop for decision 8 # at line 72:3: ( attribute )* while true # decision 9 alt_9 = 2 look_9_0 = @input.peek( 1 ) if ( look_9_0 == ID || look_9_0 == T__55 ) alt_9 = 1 end case alt_9 when 1 # at line 72:3: attribute @state.following.push( TOKENS_FOLLOWING_attribute_IN_state_178 ) attribute22 = attribute @state.following.pop @adaptor.add_child( root_0, attribute22.tree ) else break # out of loop for decision 9 end end # loop for decision 9 char_literal23 = match( T__85, TOKENS_FOLLOWING_T__85_IN_state_183 ) tree_for_char_literal23 = @adaptor.create_with_payload( char_literal23 ) @adaptor.add_child( root_0, tree_for_char_literal23 ) # --> action self.goto_parent(true) # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 5 ) end return return_value end ClassDefReturnValue = define_return_scope # # parser rule class_def # # (in SfpLang.g) # 77:1: class_def : ( 'class' | 'schema' ) ID ( extends_class )? ( '{' ( NL )* ( attribute | procedure ( NL )* )* '}' )? ; # def class_def # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 6 ) return_value = ClassDefReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil set24 = nil __ID25__ = nil char_literal27 = nil __NL28__ = nil __NL31__ = nil char_literal32 = nil extends_class26 = nil attribute29 = nil procedure30 = nil tree_for_set24 = nil tree_for_ID25 = nil tree_for_char_literal27 = nil tree_for_NL28 = nil tree_for_NL31 = nil tree_for_char_literal32 = nil begin root_0 = @adaptor.create_flat_list # at line 78:4: ( 'class' | 'schema' ) ID ( extends_class )? ( '{' ( NL )* ( attribute | procedure ( NL )* )* '}' )? set24 = @input.look if @input.peek(1) == T__44 || @input.peek(1) == T__76 @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set24 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end __ID25__ = match( ID, TOKENS_FOLLOWING_ID_IN_class_def_204 ) tree_for_ID25 = @adaptor.create_with_payload( __ID25__ ) @adaptor.add_child( root_0, tree_for_ID25 ) # --> action @now[__ID25__.text] = { '_self' => __ID25__.text, '_context' => 'class', '_parent' => @now, } @now = @now[__ID25__.text] # <-- action # at line 86:3: ( extends_class )? alt_10 = 2 look_10_0 = @input.peek( 1 ) if ( look_10_0 == T__54 ) alt_10 = 1 end case alt_10 when 1 # at line 86:4: extends_class @state.following.push( TOKENS_FOLLOWING_extends_class_IN_class_def_213 ) extends_class26 = extends_class @state.following.pop @adaptor.add_child( root_0, extends_class26.tree ) # --> action @now['_extends'] = ( extends_class26.nil? ? nil : extends_class26.val ) # <-- action end # at line 91:3: ( '{' ( NL )* ( attribute | procedure ( NL )* )* '}' )? alt_14 = 2 look_14_0 = @input.peek( 1 ) if ( look_14_0 == T__84 ) alt_14 = 1 end case alt_14 when 1 # at line 91:4: '{' ( NL )* ( attribute | procedure ( NL )* )* '}' char_literal27 = match( T__84, TOKENS_FOLLOWING_T__84_IN_class_def_227 ) tree_for_char_literal27 = @adaptor.create_with_payload( char_literal27 ) @adaptor.add_child( root_0, tree_for_char_literal27 ) # at line 91:8: ( NL )* while true # decision 11 alt_11 = 2 look_11_0 = @input.peek( 1 ) if ( look_11_0 == NL ) alt_11 = 1 end case alt_11 when 1 # at line 91:8: NL __NL28__ = match( NL, TOKENS_FOLLOWING_NL_IN_class_def_229 ) tree_for_NL28 = @adaptor.create_with_payload( __NL28__ ) @adaptor.add_child( root_0, tree_for_NL28 ) else break # out of loop for decision 11 end end # loop for decision 11 # at line 91:12: ( attribute | procedure ( NL )* )* while true # decision 13 alt_13 = 3 look_13_0 = @input.peek( 1 ) if ( look_13_0 == ID || look_13_0 == T__55 ) alt_13 = 1 elsif ( look_13_0 == T__74 || look_13_0.between?( T__79, T__80 ) ) alt_13 = 2 end case alt_13 when 1 # at line 91:14: attribute @state.following.push( TOKENS_FOLLOWING_attribute_IN_class_def_234 ) attribute29 = attribute @state.following.pop @adaptor.add_child( root_0, attribute29.tree ) when 2 # at line 91:26: procedure ( NL )* @state.following.push( TOKENS_FOLLOWING_procedure_IN_class_def_238 ) procedure30 = procedure @state.following.pop @adaptor.add_child( root_0, procedure30.tree ) # at line 91:36: ( NL )* while true # decision 12 alt_12 = 2 look_12_0 = @input.peek( 1 ) if ( look_12_0 == NL ) alt_12 = 1 end case alt_12 when 1 # at line 91:36: NL __NL31__ = match( NL, TOKENS_FOLLOWING_NL_IN_class_def_240 ) tree_for_NL31 = @adaptor.create_with_payload( __NL31__ ) @adaptor.add_child( root_0, tree_for_NL31 ) else break # out of loop for decision 12 end end # loop for decision 12 else break # out of loop for decision 13 end end # loop for decision 13 char_literal32 = match( T__85, TOKENS_FOLLOWING_T__85_IN_class_def_246 ) tree_for_char_literal32 = @adaptor.create_with_payload( char_literal32 ) @adaptor.add_child( root_0, tree_for_char_literal32 ) end # --> action if not @now.has_key?('_extends') @now['_extends'] = '$.Object' @now['_super'] = ['$.Object'] end expand_class(@now) self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 6 ) end return return_value end ExtendsClassReturnValue = define_return_scope :val # # parser rule extends_class # # (in SfpLang.g) # 102:1: extends_class returns [val] : 'extends' path ; # def extends_class # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 7 ) return_value = ExtendsClassReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal33 = nil path34 = nil tree_for_string_literal33 = nil begin root_0 = @adaptor.create_flat_list # at line 103:4: 'extends' path string_literal33 = match( T__54, TOKENS_FOLLOWING_T__54_IN_extends_class_268 ) tree_for_string_literal33 = @adaptor.create_with_payload( string_literal33 ) @adaptor.add_child( root_0, tree_for_string_literal33 ) @state.following.push( TOKENS_FOLLOWING_path_IN_extends_class_270 ) path34 = path @state.following.pop @adaptor.add_child( root_0, path34.tree ) # --> action return_value.val = self.to_ref(( path34 && @input.to_s( path34.start, path34.stop ) )) @unexpanded_classes.push(@now) # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 7 ) end return return_value end AttributeReturnValue = define_return_scope # # parser rule attribute # # (in SfpLang.g) # 110:1: attribute : ( ( 'final' )? attribute_stmt | ( 'final' )? object_def ( NL )+ ); # def attribute # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 8 ) return_value = AttributeReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal35 = nil string_literal37 = nil __NL39__ = nil attribute_stmt36 = nil object_def38 = nil tree_for_string_literal35 = nil tree_for_string_literal37 = nil tree_for_NL39 = nil begin # at line 111:2: ( ( 'final' )? attribute_stmt | ( 'final' )? object_def ( NL )+ ) alt_18 = 2 look_18_0 = @input.peek( 1 ) if ( look_18_0 == T__55 ) look_18_1 = @input.peek( 2 ) if ( look_18_1 == ID ) look_18_2 = @input.peek( 3 ) if ( look_18_2 == T__27 || look_18_2 == T__31 || look_18_2 == T__52 || look_18_2 == T__65 || look_18_2.between?( T__69, T__70 ) ) alt_18 = 1 elsif ( look_18_2 == NL || look_18_2 == T__54 || look_18_2 == T__66 || look_18_2 == T__84 ) alt_18 = 2 else raise NoViableAlternative( "", 18, 2 ) end else raise NoViableAlternative( "", 18, 1 ) end elsif ( look_18_0 == ID ) look_18_2 = @input.peek( 2 ) if ( look_18_2 == T__27 || look_18_2 == T__31 || look_18_2 == T__52 || look_18_2 == T__65 || look_18_2.between?( T__69, T__70 ) ) alt_18 = 1 elsif ( look_18_2 == NL || look_18_2 == T__54 || look_18_2 == T__66 || look_18_2 == T__84 ) alt_18 = 2 else raise NoViableAlternative( "", 18, 2 ) end else raise NoViableAlternative( "", 18, 0 ) end case alt_18 when 1 root_0 = @adaptor.create_flat_list # at line 111:4: ( 'final' )? attribute_stmt # --> action @is_final = false @now['_finals'] = [] if !@now.has_key? '_finals' # <-- action # at line 115:3: ( 'final' )? alt_15 = 2 look_15_0 = @input.peek( 1 ) if ( look_15_0 == T__55 ) alt_15 = 1 end case alt_15 when 1 # at line 115:4: 'final' string_literal35 = match( T__55, TOKENS_FOLLOWING_T__55_IN_attribute_290 ) tree_for_string_literal35 = @adaptor.create_with_payload( string_literal35 ) @adaptor.add_child( root_0, tree_for_string_literal35 ) # --> action @is_final = true # <-- action end @state.following.push( TOKENS_FOLLOWING_attribute_stmt_IN_attribute_296 ) attribute_stmt36 = attribute_stmt @state.following.pop @adaptor.add_child( root_0, attribute_stmt36.tree ) # --> action @now['_finals'] << ( attribute_stmt36.nil? ? nil : attribute_stmt36.id ) if @is_final and !( attribute_stmt36.nil? ? nil : attribute_stmt36.id ).nil? # <-- action when 2 root_0 = @adaptor.create_flat_list # at line 119:4: ( 'final' )? object_def ( NL )+ # --> action @is_final = false @now['_finals'] = [] if !@now.has_key? '_finals' # <-- action # at line 123:3: ( 'final' )? alt_16 = 2 look_16_0 = @input.peek( 1 ) if ( look_16_0 == T__55 ) alt_16 = 1 end case alt_16 when 1 # at line 123:4: 'final' string_literal37 = match( T__55, TOKENS_FOLLOWING_T__55_IN_attribute_310 ) tree_for_string_literal37 = @adaptor.create_with_payload( string_literal37 ) @adaptor.add_child( root_0, tree_for_string_literal37 ) # --> action @is_final = true # <-- action end @state.following.push( TOKENS_FOLLOWING_object_def_IN_attribute_316 ) object_def38 = object_def @state.following.pop @adaptor.add_child( root_0, object_def38.tree ) # at file 123:46: ( NL )+ match_count_17 = 0 while true alt_17 = 2 look_17_0 = @input.peek( 1 ) if ( look_17_0 == NL ) alt_17 = 1 end case alt_17 when 1 # at line 123:46: NL __NL39__ = match( NL, TOKENS_FOLLOWING_NL_IN_attribute_318 ) tree_for_NL39 = @adaptor.create_with_payload( __NL39__ ) @adaptor.add_child( root_0, tree_for_NL39 ) else match_count_17 > 0 and break eee = EarlyExit(17) raise eee end match_count_17 += 1 end end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 8 ) end return return_value end AttributeStmtReturnValue = define_return_scope :id # # parser rule attribute_stmt # # (in SfpLang.g) # 126:1: attribute_stmt returns [id] : ( ID equals_op value ( NL )+ | ID reference_type ( NL )+ | ID set_type ( NL )+ | ID probability_op set_value ( NL )+ | ID ':' path ( NL )+ ); # def attribute_stmt # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 9 ) return_value = AttributeStmtReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __ID40__ = nil __NL43__ = nil __ID44__ = nil __NL46__ = nil __ID47__ = nil __NL49__ = nil __ID50__ = nil __NL53__ = nil __ID54__ = nil char_literal55 = nil __NL57__ = nil equals_op41 = nil value42 = nil reference_type45 = nil set_type48 = nil probability_op51 = nil set_value52 = nil path56 = nil tree_for_ID40 = nil tree_for_NL43 = nil tree_for_ID44 = nil tree_for_NL46 = nil tree_for_ID47 = nil tree_for_NL49 = nil tree_for_ID50 = nil tree_for_NL53 = nil tree_for_ID54 = nil tree_for_char_literal55 = nil tree_for_NL57 = nil begin # at line 127:2: ( ID equals_op value ( NL )+ | ID reference_type ( NL )+ | ID set_type ( NL )+ | ID probability_op set_value ( NL )+ | ID ':' path ( NL )+ ) alt_24 = 5 look_24_0 = @input.peek( 1 ) if ( look_24_0 == ID ) case look_24 = @input.peek( 2 ) when T__27 then alt_24 = 5 when T__31, T__65 then alt_24 = 1 when T__69 then alt_24 = 2 when T__70 then alt_24 = 3 when T__52 then alt_24 = 4 else raise NoViableAlternative( "", 24, 1 ) end else raise NoViableAlternative( "", 24, 0 ) end case alt_24 when 1 root_0 = @adaptor.create_flat_list # at line 127:4: ID equals_op value ( NL )+ __ID40__ = match( ID, TOKENS_FOLLOWING_ID_IN_attribute_stmt_334 ) tree_for_ID40 = @adaptor.create_with_payload( __ID40__ ) @adaptor.add_child( root_0, tree_for_ID40 ) @state.following.push( TOKENS_FOLLOWING_equals_op_IN_attribute_stmt_336 ) equals_op41 = equals_op @state.following.pop @adaptor.add_child( root_0, equals_op41.tree ) @state.following.push( TOKENS_FOLLOWING_value_IN_attribute_stmt_338 ) value42 = value @state.following.pop @adaptor.add_child( root_0, value42.tree ) # at file 127:23: ( NL )+ match_count_19 = 0 while true alt_19 = 2 look_19_0 = @input.peek( 1 ) if ( look_19_0 == NL ) alt_19 = 1 end case alt_19 when 1 # at line 127:23: NL __NL43__ = match( NL, TOKENS_FOLLOWING_NL_IN_attribute_stmt_340 ) tree_for_NL43 = @adaptor.create_with_payload( __NL43__ ) @adaptor.add_child( root_0, tree_for_NL43 ) else match_count_19 > 0 and break eee = EarlyExit(19) raise eee end match_count_19 += 1 end # --> action if @now.has_key?(__ID40__.text) and @now[__ID40__.text].is_a?(Hash) and @now[__ID40__.text].isset and ( value42.nil? ? nil : value42.type ) == 'Set' ( value42.nil? ? nil : value42.val ).each { |v| @now[__ID40__.text]['_values'].push(v) } else @now[__ID40__.text] = ( value42.nil? ? nil : value42.val ) end return_value.id = __ID40__.text # <-- action when 2 root_0 = @adaptor.create_flat_list # at line 137:4: ID reference_type ( NL )+ __ID44__ = match( ID, TOKENS_FOLLOWING_ID_IN_attribute_stmt_350 ) tree_for_ID44 = @adaptor.create_with_payload( __ID44__ ) @adaptor.add_child( root_0, tree_for_ID44 ) @state.following.push( TOKENS_FOLLOWING_reference_type_IN_attribute_stmt_352 ) reference_type45 = reference_type @state.following.pop @adaptor.add_child( root_0, reference_type45.tree ) # at file 137:22: ( NL )+ match_count_20 = 0 while true alt_20 = 2 look_20_0 = @input.peek( 1 ) if ( look_20_0 == NL ) alt_20 = 1 end case alt_20 when 1 # at line 137:22: NL __NL46__ = match( NL, TOKENS_FOLLOWING_NL_IN_attribute_stmt_354 ) tree_for_NL46 = @adaptor.create_with_payload( __NL46__ ) @adaptor.add_child( root_0, tree_for_NL46 ) else match_count_20 > 0 and break eee = EarlyExit(20) raise eee end match_count_20 += 1 end # --> action @now[__ID44__.text] = ( reference_type45.nil? ? nil : reference_type45.val ) return_value.id = __ID44__.text # <-- action when 3 root_0 = @adaptor.create_flat_list # at line 142:4: ID set_type ( NL )+ __ID47__ = match( ID, TOKENS_FOLLOWING_ID_IN_attribute_stmt_364 ) tree_for_ID47 = @adaptor.create_with_payload( __ID47__ ) @adaptor.add_child( root_0, tree_for_ID47 ) @state.following.push( TOKENS_FOLLOWING_set_type_IN_attribute_stmt_366 ) set_type48 = set_type @state.following.pop @adaptor.add_child( root_0, set_type48.tree ) # at file 142:16: ( NL )+ match_count_21 = 0 while true alt_21 = 2 look_21_0 = @input.peek( 1 ) if ( look_21_0 == NL ) alt_21 = 1 end case alt_21 when 1 # at line 142:16: NL __NL49__ = match( NL, TOKENS_FOLLOWING_NL_IN_attribute_stmt_368 ) tree_for_NL49 = @adaptor.create_with_payload( __NL49__ ) @adaptor.add_child( root_0, tree_for_NL49 ) else match_count_21 > 0 and break eee = EarlyExit(21) raise eee end match_count_21 += 1 end # --> action @now[__ID47__.text] = ( set_type48.nil? ? nil : set_type48.val ) return_value.id = __ID47__.text # <-- action when 4 root_0 = @adaptor.create_flat_list # at line 147:4: ID probability_op set_value ( NL )+ __ID50__ = match( ID, TOKENS_FOLLOWING_ID_IN_attribute_stmt_378 ) tree_for_ID50 = @adaptor.create_with_payload( __ID50__ ) @adaptor.add_child( root_0, tree_for_ID50 ) @state.following.push( TOKENS_FOLLOWING_probability_op_IN_attribute_stmt_380 ) probability_op51 = probability_op @state.following.pop @adaptor.add_child( root_0, probability_op51.tree ) @state.following.push( TOKENS_FOLLOWING_set_value_IN_attribute_stmt_382 ) set_value52 = set_value @state.following.pop @adaptor.add_child( root_0, set_value52.tree ) # at file 147:32: ( NL )+ match_count_22 = 0 while true alt_22 = 2 look_22_0 = @input.peek( 1 ) if ( look_22_0 == NL ) alt_22 = 1 end case alt_22 when 1 # at line 147:32: NL __NL53__ = match( NL, TOKENS_FOLLOWING_NL_IN_attribute_stmt_384 ) tree_for_NL53 = @adaptor.create_with_payload( __NL53__ ) @adaptor.add_child( root_0, tree_for_NL53 ) else match_count_22 > 0 and break eee = EarlyExit(22) raise eee end match_count_22 += 1 end # --> action @conformant = true @now[__ID50__.text] = { '_self' => __ID50__.text, '_context' => 'either', '_parent' => @now, '_values' => ( set_value52.nil? ? nil : set_value52.val ) } return_value.id = __ID50__.text # <-- action when 5 root_0 = @adaptor.create_flat_list # at line 157:4: ID ':' path ( NL )+ __ID54__ = match( ID, TOKENS_FOLLOWING_ID_IN_attribute_stmt_394 ) tree_for_ID54 = @adaptor.create_with_payload( __ID54__ ) @adaptor.add_child( root_0, tree_for_ID54 ) char_literal55 = match( T__27, TOKENS_FOLLOWING_T__27_IN_attribute_stmt_396 ) tree_for_char_literal55 = @adaptor.create_with_payload( char_literal55 ) @adaptor.add_child( root_0, tree_for_char_literal55 ) @state.following.push( TOKENS_FOLLOWING_path_IN_attribute_stmt_398 ) path56 = path @state.following.pop @adaptor.add_child( root_0, path56.tree ) # at file 157:16: ( NL )+ match_count_23 = 0 while true alt_23 = 2 look_23_0 = @input.peek( 1 ) if ( look_23_0 == NL ) alt_23 = 1 end case alt_23 when 1 # at line 157:16: NL __NL57__ = match( NL, TOKENS_FOLLOWING_NL_IN_attribute_stmt_400 ) tree_for_NL57 = @adaptor.create_with_payload( __NL57__ ) @adaptor.add_child( root_0, tree_for_NL57 ) else match_count_23 > 0 and break eee = EarlyExit(23) raise eee end match_count_23 += 1 end # --> action case ( path56 && @input.to_s( path56.start, path56.stop ) ) when 'String' @now[__ID54__.text] = { '_context' => 'any_value', '_isa' => '$.String' } when 'Bool' @now[__ID54__.text] = { '_context' => 'any_value', '_isa' => '$.Boolean' } when 'Int' @now[__ID54__.text] = { '_context' => 'any_value', '_isa' => '$.Number' } else raise Exception, "Use isa/isref for any non-primitive type (#{( path56 && @input.to_s( path56.start, path56.stop ) )})." end return_value.id = __ID54__.text # <-- action end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 9 ) end return return_value end ObjectSchemaReturnValue = define_return_scope # # parser rule object_schema # # (in SfpLang.g) # 179:1: object_schema : path ( '[' NUMBER ']' )? ; # def object_schema # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 10 ) return_value = ObjectSchemaReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil char_literal59 = nil __NUMBER60__ = nil char_literal61 = nil path58 = nil tree_for_char_literal59 = nil tree_for_NUMBER60 = nil tree_for_char_literal61 = nil begin root_0 = @adaptor.create_flat_list # at line 180:4: path ( '[' NUMBER ']' )? @state.following.push( TOKENS_FOLLOWING_path_IN_object_schema_416 ) path58 = path @state.following.pop @adaptor.add_child( root_0, path58.tree ) # at line 180:8: ( '[' NUMBER ']' )? alt_25 = 2 look_25_0 = @input.peek( 1 ) if ( look_25_0 == T__34 ) alt_25 = 1 end case alt_25 when 1 # at line 180:9: '[' NUMBER ']' char_literal59 = match( T__34, TOKENS_FOLLOWING_T__34_IN_object_schema_418 ) tree_for_char_literal59 = @adaptor.create_with_payload( char_literal59 ) @adaptor.add_child( root_0, tree_for_char_literal59 ) __NUMBER60__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_object_schema_420 ) tree_for_NUMBER60 = @adaptor.create_with_payload( __NUMBER60__ ) @adaptor.add_child( root_0, tree_for_NUMBER60 ) # --> action @now['_is_array'] = true # <-- action char_literal61 = match( T__35, TOKENS_FOLLOWING_T__35_IN_object_schema_424 ) tree_for_char_literal61 = @adaptor.create_with_payload( char_literal61 ) @adaptor.add_child( root_0, tree_for_char_literal61 ) end # --> action @now['_isa'] = self.to_ref(( path58 && @input.to_s( path58.start, path58.stop ) )) self.expand_object(@now) # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 10 ) end return return_value end ObjectSchemataReturnValue = define_return_scope # # parser rule object_schemata # # (in SfpLang.g) # 187:1: object_schemata : ',' object_schema ; # def object_schemata # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 11 ) return_value = ObjectSchemataReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil char_literal62 = nil object_schema63 = nil tree_for_char_literal62 = nil begin root_0 = @adaptor.create_flat_list # at line 188:4: ',' object_schema char_literal62 = match( T__23, TOKENS_FOLLOWING_T__23_IN_object_schemata_441 ) tree_for_char_literal62 = @adaptor.create_with_payload( char_literal62 ) @adaptor.add_child( root_0, tree_for_char_literal62 ) @state.following.push( TOKENS_FOLLOWING_object_schema_IN_object_schemata_443 ) object_schema63 = object_schema @state.following.pop @adaptor.add_child( root_0, object_schema63.tree ) # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 11 ) end return return_value end AbstractObjectReturnValue = define_return_scope # # parser rule abstract_object # # (in SfpLang.g) # 191:1: abstract_object : 'abstract' object_def ; # def abstract_object # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 12 ) return_value = AbstractObjectReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal64 = nil object_def65 = nil tree_for_string_literal64 = nil begin root_0 = @adaptor.create_flat_list # at line 192:4: 'abstract' object_def string_literal64 = match( T__36, TOKENS_FOLLOWING_T__36_IN_abstract_object_454 ) tree_for_string_literal64 = @adaptor.create_with_payload( string_literal64 ) @adaptor.add_child( root_0, tree_for_string_literal64 ) @state.following.push( TOKENS_FOLLOWING_object_def_IN_abstract_object_456 ) object_def65 = object_def @state.following.pop @adaptor.add_child( root_0, object_def65.tree ) # --> action @root[( object_def65.nil? ? nil : object_def65.id )]['_context'] = 'abstract' # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 12 ) end return return_value end ObjectDefReturnValue = define_return_scope :id # # parser rule object_def # # (in SfpLang.g) # 196:1: object_def returns [id] : ID ( 'extends' path )? ( 'isa' object_schema ( object_schemata )* )? ( object_body )? ; # def object_def # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 13 ) return_value = ObjectDefReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __ID66__ = nil string_literal67 = nil string_literal69 = nil path68 = nil object_schema70 = nil object_schemata71 = nil object_body72 = nil tree_for_ID66 = nil tree_for_string_literal67 = nil tree_for_string_literal69 = nil begin root_0 = @adaptor.create_flat_list # at line 197:4: ID ( 'extends' path )? ( 'isa' object_schema ( object_schemata )* )? ( object_body )? __ID66__ = match( ID, TOKENS_FOLLOWING_ID_IN_object_def_475 ) tree_for_ID66 = @adaptor.create_with_payload( __ID66__ ) @adaptor.add_child( root_0, tree_for_ID66 ) # --> action return_value.id = __ID66__.text # <-- action # --> action @use_template = false @now['_finals'] << __ID66__.text if @is_final # <-- action # at line 202:3: ( 'extends' path )? alt_26 = 2 look_26_0 = @input.peek( 1 ) if ( look_26_0 == T__54 ) alt_26 = 1 end case alt_26 when 1 # at line 202:4: 'extends' path string_literal67 = match( T__54, TOKENS_FOLLOWING_T__54_IN_object_def_486 ) tree_for_string_literal67 = @adaptor.create_with_payload( string_literal67 ) @adaptor.add_child( root_0, tree_for_string_literal67 ) @state.following.push( TOKENS_FOLLOWING_path_IN_object_def_488 ) path68 = path @state.following.pop @adaptor.add_child( root_0, path68.tree ) # --> action template = @root.at?(( path68 && @input.to_s( path68.start, path68.stop ) )) if template.is_a?(Sfp::Unknown) or template.is_a?(Sfp::Undefined) raise Exception, "Object template #{( path68 && @input.to_s( path68.start, path68.stop ) )} is not found!" end if !template.is_a?(Hash) or (template['_context'] != 'object' and template['_context'] != 'abstract') puts template['_context'] raise Exception, "#{( path68 && @input.to_s( path68.start, path68.stop ) )}:[#{template['_context']}] is not an object or an abstract object!" end object = @now[__ID66__.text] = Sfp::Helper.deep_clone(template) object.accept(Sfp::Visitor::ParentEliminator.new) object['_parent'] = @now object['_self'] = __ID66__.text object['_context'] = 'object' object.accept(Sfp::Visitor::SfpGenerator.new(@root)) @use_template = true # <-- action end # --> action @now[__ID66__.text] = { '_self' => __ID66__.text, '_context' => 'object', '_parent' => @now, '_isa' => '$.Object' } if not @use_template @now = @now[__ID66__.text] @now['_is_array'] = false # <-- action # at line 230:3: ( 'isa' object_schema ( object_schemata )* )? alt_28 = 2 look_28_0 = @input.peek( 1 ) if ( look_28_0 == T__66 ) alt_28 = 1 end case alt_28 when 1 # at line 230:4: 'isa' object_schema ( object_schemata )* string_literal69 = match( T__66, TOKENS_FOLLOWING_T__66_IN_object_def_506 ) tree_for_string_literal69 = @adaptor.create_with_payload( string_literal69 ) @adaptor.add_child( root_0, tree_for_string_literal69 ) @state.following.push( TOKENS_FOLLOWING_object_schema_IN_object_def_508 ) object_schema70 = object_schema @state.following.pop @adaptor.add_child( root_0, object_schema70.tree ) # at line 230:24: ( object_schemata )* while true # decision 27 alt_27 = 2 look_27_0 = @input.peek( 1 ) if ( look_27_0 == T__23 ) alt_27 = 1 end case alt_27 when 1 # at line 230:25: object_schemata @state.following.push( TOKENS_FOLLOWING_object_schemata_IN_object_def_511 ) object_schemata71 = object_schemata @state.following.pop @adaptor.add_child( root_0, object_schemata71.tree ) else break # out of loop for decision 27 end end # loop for decision 27 end # at line 231:3: ( object_body )? alt_29 = 2 look_29_0 = @input.peek( 1 ) if ( look_29_0 == T__84 ) alt_29 = 1 end case alt_29 when 1 # at line 231:3: object_body @state.following.push( TOKENS_FOLLOWING_object_body_IN_object_def_520 ) object_body72 = object_body @state.following.pop @adaptor.add_child( root_0, object_body72.tree ) end # --> action if @now['_is_array'] @now.delete('_is_array') obj = self.goto_parent() total = $NUMBER.to_s.to_i @arrays[obj.ref] = total for i in 0..(total-1) id = obj['_self'] + '[' + i.to_s + ']' @now[id] = deep_clone(obj) @now[id]['_self'] = id @now[id]['_classes'] = obj['_classes'] end @now.delete(obj['_self']) else self.goto_parent() end # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 13 ) end return return_value end ObjectBodyReturnValue = define_return_scope # # parser rule object_body # # (in SfpLang.g) # 251:1: object_body : '{' ( NL )* ( object_attribute | procedure ( NL )* )* '}' ; # def object_body # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 14 ) return_value = ObjectBodyReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil char_literal73 = nil __NL74__ = nil __NL77__ = nil char_literal78 = nil object_attribute75 = nil procedure76 = nil tree_for_char_literal73 = nil tree_for_NL74 = nil tree_for_NL77 = nil tree_for_char_literal78 = nil begin root_0 = @adaptor.create_flat_list # at line 252:4: '{' ( NL )* ( object_attribute | procedure ( NL )* )* '}' char_literal73 = match( T__84, TOKENS_FOLLOWING_T__84_IN_object_body_536 ) tree_for_char_literal73 = @adaptor.create_with_payload( char_literal73 ) @adaptor.add_child( root_0, tree_for_char_literal73 ) # at line 252:8: ( NL )* while true # decision 30 alt_30 = 2 look_30_0 = @input.peek( 1 ) if ( look_30_0 == NL ) alt_30 = 1 end case alt_30 when 1 # at line 252:8: NL __NL74__ = match( NL, TOKENS_FOLLOWING_NL_IN_object_body_538 ) tree_for_NL74 = @adaptor.create_with_payload( __NL74__ ) @adaptor.add_child( root_0, tree_for_NL74 ) else break # out of loop for decision 30 end end # loop for decision 30 # at line 252:12: ( object_attribute | procedure ( NL )* )* while true # decision 32 alt_32 = 3 look_32_0 = @input.peek( 1 ) if ( look_32_0 == ID || look_32_0 == T__55 ) alt_32 = 1 elsif ( look_32_0 == T__74 || look_32_0.between?( T__79, T__80 ) ) alt_32 = 2 end case alt_32 when 1 # at line 252:14: object_attribute @state.following.push( TOKENS_FOLLOWING_object_attribute_IN_object_body_543 ) object_attribute75 = object_attribute @state.following.pop @adaptor.add_child( root_0, object_attribute75.tree ) when 2 # at line 252:33: procedure ( NL )* @state.following.push( TOKENS_FOLLOWING_procedure_IN_object_body_547 ) procedure76 = procedure @state.following.pop @adaptor.add_child( root_0, procedure76.tree ) # at line 252:43: ( NL )* while true # decision 31 alt_31 = 2 look_31_0 = @input.peek( 1 ) if ( look_31_0 == NL ) alt_31 = 1 end case alt_31 when 1 # at line 252:43: NL __NL77__ = match( NL, TOKENS_FOLLOWING_NL_IN_object_body_549 ) tree_for_NL77 = @adaptor.create_with_payload( __NL77__ ) @adaptor.add_child( root_0, tree_for_NL77 ) else break # out of loop for decision 31 end end # loop for decision 31 else break # out of loop for decision 32 end end # loop for decision 32 char_literal78 = match( T__85, TOKENS_FOLLOWING_T__85_IN_object_body_555 ) tree_for_char_literal78 = @adaptor.create_with_payload( char_literal78 ) @adaptor.add_child( root_0, tree_for_char_literal78 ) # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 14 ) end return return_value end ObjectAttributeReturnValue = define_return_scope # # parser rule object_attribute # # (in SfpLang.g) # 255:1: object_attribute : ( attribute | ID equals_op NULL ( NL )+ ); # def object_attribute # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 15 ) return_value = ObjectAttributeReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __ID80__ = nil __NULL82__ = nil __NL83__ = nil attribute79 = nil equals_op81 = nil tree_for_ID80 = nil tree_for_NULL82 = nil tree_for_NL83 = nil begin # at line 256:2: ( attribute | ID equals_op NULL ( NL )+ ) alt_34 = 2 look_34_0 = @input.peek( 1 ) if ( look_34_0 == T__55 ) alt_34 = 1 elsif ( look_34_0 == ID ) look_34_2 = @input.peek( 2 ) if ( look_34_2 == NL || look_34_2 == T__27 || look_34_2 == T__52 || look_34_2 == T__54 || look_34_2 == T__66 || look_34_2.between?( T__69, T__70 ) || look_34_2 == T__84 ) alt_34 = 1 elsif ( look_34_2 == T__31 || look_34_2 == T__65 ) look_34_3 = @input.peek( 3 ) if ( look_34_3 == BOOLEAN || look_34_3.between?( ID, MULTILINE_STRING ) || look_34_3 == NUMBER || look_34_3 == STRING || look_34_3 == T__19 || look_34_3 == T__40 ) alt_34 = 1 elsif ( look_34_3 == NULL ) alt_34 = 2 else raise NoViableAlternative( "", 34, 3 ) end else raise NoViableAlternative( "", 34, 2 ) end else raise NoViableAlternative( "", 34, 0 ) end case alt_34 when 1 root_0 = @adaptor.create_flat_list # at line 256:4: attribute @state.following.push( TOKENS_FOLLOWING_attribute_IN_object_attribute_566 ) attribute79 = attribute @state.following.pop @adaptor.add_child( root_0, attribute79.tree ) when 2 root_0 = @adaptor.create_flat_list # at line 257:4: ID equals_op NULL ( NL )+ __ID80__ = match( ID, TOKENS_FOLLOWING_ID_IN_object_attribute_571 ) tree_for_ID80 = @adaptor.create_with_payload( __ID80__ ) @adaptor.add_child( root_0, tree_for_ID80 ) @state.following.push( TOKENS_FOLLOWING_equals_op_IN_object_attribute_573 ) equals_op81 = equals_op @state.following.pop @adaptor.add_child( root_0, equals_op81.tree ) __NULL82__ = match( NULL, TOKENS_FOLLOWING_NULL_IN_object_attribute_575 ) tree_for_NULL82 = @adaptor.create_with_payload( __NULL82__ ) @adaptor.add_child( root_0, tree_for_NULL82 ) # at file 257:22: ( NL )+ match_count_33 = 0 while true alt_33 = 2 look_33_0 = @input.peek( 1 ) if ( look_33_0 == NL ) alt_33 = 1 end case alt_33 when 1 # at line 257:22: NL __NL83__ = match( NL, TOKENS_FOLLOWING_NL_IN_object_attribute_577 ) tree_for_NL83 = @adaptor.create_with_payload( __NL83__ ) @adaptor.add_child( root_0, tree_for_NL83 ) else match_count_33 > 0 and break eee = EarlyExit(33) raise eee end match_count_33 += 1 end # --> action @now[__ID80__.text] = self.null_value # <-- action end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 15 ) end return return_value end StateDependencyReturnValue = define_return_scope # # parser rule state_dependency # # (in SfpLang.g) # 261:1: state_dependency : 'if' dep_effect ( NL )* 'then' ( NL )* '{' ( NL )* constraint_body '}' ( ( NL )* 'or' ( NL )* '{' ( NL )* constraint_body '}' )* ( NL )+ ; # def state_dependency # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 16 ) return_value = StateDependencyReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal84 = nil __NL86__ = nil string_literal87 = nil __NL88__ = nil char_literal89 = nil __NL90__ = nil char_literal92 = nil __NL93__ = nil string_literal94 = nil __NL95__ = nil char_literal96 = nil __NL97__ = nil char_literal99 = nil __NL100__ = nil dep_effect85 = nil constraint_body91 = nil constraint_body98 = nil tree_for_string_literal84 = nil tree_for_NL86 = nil tree_for_string_literal87 = nil tree_for_NL88 = nil tree_for_char_literal89 = nil tree_for_NL90 = nil tree_for_char_literal92 = nil tree_for_NL93 = nil tree_for_string_literal94 = nil tree_for_NL95 = nil tree_for_char_literal96 = nil tree_for_NL97 = nil tree_for_char_literal99 = nil tree_for_NL100 = nil begin root_0 = @adaptor.create_flat_list # at line 262:4: 'if' dep_effect ( NL )* 'then' ( NL )* '{' ( NL )* constraint_body '}' ( ( NL )* 'or' ( NL )* '{' ( NL )* constraint_body '}' )* ( NL )+ string_literal84 = match( T__62, TOKENS_FOLLOWING_T__62_IN_state_dependency_593 ) tree_for_string_literal84 = @adaptor.create_with_payload( string_literal84 ) @adaptor.add_child( root_0, tree_for_string_literal84 ) @state.following.push( TOKENS_FOLLOWING_dep_effect_IN_state_dependency_597 ) dep_effect85 = dep_effect @state.following.pop @adaptor.add_child( root_0, dep_effect85.tree ) # at line 263:14: ( NL )* while true # decision 35 alt_35 = 2 look_35_0 = @input.peek( 1 ) if ( look_35_0 == NL ) alt_35 = 1 end case alt_35 when 1 # at line 263:14: NL __NL86__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_599 ) tree_for_NL86 = @adaptor.create_with_payload( __NL86__ ) @adaptor.add_child( root_0, tree_for_NL86 ) else break # out of loop for decision 35 end end # loop for decision 35 string_literal87 = match( T__81, TOKENS_FOLLOWING_T__81_IN_state_dependency_602 ) tree_for_string_literal87 = @adaptor.create_with_payload( string_literal87 ) @adaptor.add_child( root_0, tree_for_string_literal87 ) # at line 263:25: ( NL )* while true # decision 36 alt_36 = 2 look_36_0 = @input.peek( 1 ) if ( look_36_0 == NL ) alt_36 = 1 end case alt_36 when 1 # at line 263:25: NL __NL88__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_604 ) tree_for_NL88 = @adaptor.create_with_payload( __NL88__ ) @adaptor.add_child( root_0, tree_for_NL88 ) else break # out of loop for decision 36 end end # loop for decision 36 char_literal89 = match( T__84, TOKENS_FOLLOWING_T__84_IN_state_dependency_607 ) tree_for_char_literal89 = @adaptor.create_with_payload( char_literal89 ) @adaptor.add_child( root_0, tree_for_char_literal89 ) # at line 264:3: ( NL )* while true # decision 37 alt_37 = 2 look_37_0 = @input.peek( 1 ) if ( look_37_0 == NL ) alt_37 = 1 end case alt_37 when 1 # at line 264:3: NL __NL90__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_611 ) tree_for_NL90 = @adaptor.create_with_payload( __NL90__ ) @adaptor.add_child( root_0, tree_for_NL90 ) else break # out of loop for decision 37 end end # loop for decision 37 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_state_dependency_614 ) constraint_body91 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body91.tree ) char_literal92 = match( T__85, TOKENS_FOLLOWING_T__85_IN_state_dependency_619 ) tree_for_char_literal92 = @adaptor.create_with_payload( char_literal92 ) @adaptor.add_child( root_0, tree_for_char_literal92 ) # at line 266:3: ( ( NL )* 'or' ( NL )* '{' ( NL )* constraint_body '}' )* while true # decision 41 alt_41 = 2 alt_41 = @dfa41.predict( @input ) case alt_41 when 1 # at line 266:5: ( NL )* 'or' ( NL )* '{' ( NL )* constraint_body '}' # at line 266:5: ( NL )* while true # decision 38 alt_38 = 2 look_38_0 = @input.peek( 1 ) if ( look_38_0 == NL ) alt_38 = 1 end case alt_38 when 1 # at line 266:5: NL __NL93__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_625 ) tree_for_NL93 = @adaptor.create_with_payload( __NL93__ ) @adaptor.add_child( root_0, tree_for_NL93 ) else break # out of loop for decision 38 end end # loop for decision 38 string_literal94 = match( T__73, TOKENS_FOLLOWING_T__73_IN_state_dependency_628 ) tree_for_string_literal94 = @adaptor.create_with_payload( string_literal94 ) @adaptor.add_child( root_0, tree_for_string_literal94 ) # at line 266:14: ( NL )* while true # decision 39 alt_39 = 2 look_39_0 = @input.peek( 1 ) if ( look_39_0 == NL ) alt_39 = 1 end case alt_39 when 1 # at line 266:14: NL __NL95__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_630 ) tree_for_NL95 = @adaptor.create_with_payload( __NL95__ ) @adaptor.add_child( root_0, tree_for_NL95 ) else break # out of loop for decision 39 end end # loop for decision 39 char_literal96 = match( T__84, TOKENS_FOLLOWING_T__84_IN_state_dependency_633 ) tree_for_char_literal96 = @adaptor.create_with_payload( char_literal96 ) @adaptor.add_child( root_0, tree_for_char_literal96 ) # at line 267:3: ( NL )* while true # decision 40 alt_40 = 2 look_40_0 = @input.peek( 1 ) if ( look_40_0 == NL ) alt_40 = 1 end case alt_40 when 1 # at line 267:3: NL __NL97__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_637 ) tree_for_NL97 = @adaptor.create_with_payload( __NL97__ ) @adaptor.add_child( root_0, tree_for_NL97 ) else break # out of loop for decision 40 end end # loop for decision 40 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_state_dependency_640 ) constraint_body98 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body98.tree ) char_literal99 = match( T__85, TOKENS_FOLLOWING_T__85_IN_state_dependency_644 ) tree_for_char_literal99 = @adaptor.create_with_payload( char_literal99 ) @adaptor.add_child( root_0, tree_for_char_literal99 ) else break # out of loop for decision 41 end end # loop for decision 41 # at file 269:3: ( NL )+ match_count_42 = 0 while true alt_42 = 2 look_42_0 = @input.peek( 1 ) if ( look_42_0 == NL ) alt_42 = 1 end case alt_42 when 1 # at line 269:3: NL __NL100__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_650 ) tree_for_NL100 = @adaptor.create_with_payload( __NL100__ ) @adaptor.add_child( root_0, tree_for_NL100 ) else match_count_42 > 0 and break eee = EarlyExit(42) raise eee end match_count_42 += 1 end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 16 ) end return return_value end DepEffectReturnValue = define_return_scope # # parser rule dep_effect # # (in SfpLang.g) # 272:1: dep_effect : reference equals_op ( value | NULL ) ; # def dep_effect # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 17 ) return_value = DepEffectReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __NULL104__ = nil reference101 = nil equals_op102 = nil value103 = nil tree_for_NULL104 = nil begin root_0 = @adaptor.create_flat_list # at line 273:4: reference equals_op ( value | NULL ) @state.following.push( TOKENS_FOLLOWING_reference_IN_dep_effect_662 ) reference101 = reference @state.following.pop @adaptor.add_child( root_0, reference101.tree ) @state.following.push( TOKENS_FOLLOWING_equals_op_IN_dep_effect_664 ) equals_op102 = equals_op @state.following.pop @adaptor.add_child( root_0, equals_op102.tree ) # at line 274:3: ( value | NULL ) alt_43 = 2 look_43_0 = @input.peek( 1 ) if ( look_43_0 == BOOLEAN || look_43_0.between?( ID, MULTILINE_STRING ) || look_43_0 == NUMBER || look_43_0 == STRING || look_43_0 == T__19 || look_43_0 == T__40 ) alt_43 = 1 elsif ( look_43_0 == NULL ) alt_43 = 2 else raise NoViableAlternative( "", 43, 0 ) end case alt_43 when 1 # at line 274:5: value @state.following.push( TOKENS_FOLLOWING_value_IN_dep_effect_671 ) value103 = value @state.following.pop @adaptor.add_child( root_0, value103.tree ) when 2 # at line 275:5: NULL __NULL104__ = match( NULL, TOKENS_FOLLOWING_NULL_IN_dep_effect_677 ) tree_for_NULL104 = @adaptor.create_with_payload( __NULL104__ ) @adaptor.add_child( root_0, tree_for_NULL104 ) end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 17 ) end return return_value end OpParamReturnValue = define_return_scope # # parser rule op_param # # (in SfpLang.g) # 279:1: op_param : ID equals_op reference ( NL )+ ; # def op_param # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 18 ) return_value = OpParamReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __ID105__ = nil __NL108__ = nil equals_op106 = nil reference107 = nil tree_for_ID105 = nil tree_for_NL108 = nil begin root_0 = @adaptor.create_flat_list # at line 280:4: ID equals_op reference ( NL )+ __ID105__ = match( ID, TOKENS_FOLLOWING_ID_IN_op_param_693 ) tree_for_ID105 = @adaptor.create_with_payload( __ID105__ ) @adaptor.add_child( root_0, tree_for_ID105 ) @state.following.push( TOKENS_FOLLOWING_equals_op_IN_op_param_695 ) equals_op106 = equals_op @state.following.pop @adaptor.add_child( root_0, equals_op106.tree ) @state.following.push( TOKENS_FOLLOWING_reference_IN_op_param_697 ) reference107 = reference @state.following.pop @adaptor.add_child( root_0, reference107.tree ) # at file 280:27: ( NL )+ match_count_44 = 0 while true alt_44 = 2 look_44_0 = @input.peek( 1 ) if ( look_44_0 == NL ) alt_44 = 1 end case alt_44 when 1 # at line 280:27: NL __NL108__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_param_699 ) tree_for_NL108 = @adaptor.create_with_payload( __NL108__ ) @adaptor.add_child( root_0, tree_for_NL108 ) else match_count_44 > 0 and break eee = EarlyExit(44) raise eee end match_count_44 += 1 end # --> action @now[__ID105__.text] = ( reference107.nil? ? nil : reference107.val ) # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 18 ) end return return_value end OpConditionsReturnValue = define_return_scope # # parser rule op_conditions # # (in SfpLang.g) # 284:1: op_conditions : ( 'conditions' | 'condition' ) '{' ( NL )* ( op_statement )* '}' ( NL )+ ; # def op_conditions # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 19 ) return_value = OpConditionsReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil set109 = nil char_literal110 = nil __NL111__ = nil char_literal113 = nil __NL114__ = nil op_statement112 = nil tree_for_set109 = nil tree_for_char_literal110 = nil tree_for_NL111 = nil tree_for_char_literal113 = nil tree_for_NL114 = nil begin root_0 = @adaptor.create_flat_list # at line 285:4: ( 'conditions' | 'condition' ) '{' ( NL )* ( op_statement )* '}' ( NL )+ set109 = @input.look if @input.peek( 1 ).between?( T__45, T__46 ) @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set109 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end char_literal110 = match( T__84, TOKENS_FOLLOWING_T__84_IN_op_conditions_723 ) tree_for_char_literal110 = @adaptor.create_with_payload( char_literal110 ) @adaptor.add_child( root_0, tree_for_char_literal110 ) # at line 285:37: ( NL )* while true # decision 45 alt_45 = 2 look_45_0 = @input.peek( 1 ) if ( look_45_0 == NL ) alt_45 = 1 end case alt_45 when 1 # at line 285:37: NL __NL111__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_conditions_725 ) tree_for_NL111 = @adaptor.create_with_payload( __NL111__ ) @adaptor.add_child( root_0, tree_for_NL111 ) else break # out of loop for decision 45 end end # loop for decision 45 # --> action @now['_condition']['_parent'] = @now @now = @now['_condition'] # <-- action # at line 290:3: ( op_statement )* while true # decision 46 alt_46 = 2 look_46_0 = @input.peek( 1 ) if ( look_46_0 == ID ) alt_46 = 1 end case alt_46 when 1 # at line 290:3: op_statement @state.following.push( TOKENS_FOLLOWING_op_statement_IN_op_conditions_734 ) op_statement112 = op_statement @state.following.pop @adaptor.add_child( root_0, op_statement112.tree ) else break # out of loop for decision 46 end end # loop for decision 46 char_literal113 = match( T__85, TOKENS_FOLLOWING_T__85_IN_op_conditions_739 ) tree_for_char_literal113 = @adaptor.create_with_payload( char_literal113 ) @adaptor.add_child( root_0, tree_for_char_literal113 ) # at file 291:7: ( NL )+ match_count_47 = 0 while true alt_47 = 2 look_47_0 = @input.peek( 1 ) if ( look_47_0 == NL ) alt_47 = 1 end case alt_47 when 1 # at line 291:7: NL __NL114__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_conditions_741 ) tree_for_NL114 = @adaptor.create_with_payload( __NL114__ ) @adaptor.add_child( root_0, tree_for_NL114 ) else match_count_47 > 0 and break eee = EarlyExit(47) raise eee end match_count_47 += 1 end # --> action self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 19 ) end return return_value end OpEffectsReturnValue = define_return_scope # # parser rule op_effects # # (in SfpLang.g) # 295:1: op_effects : 'effects' '{' ( NL )* ( op_statement )* '}' ( NL )+ ; # def op_effects # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 20 ) return_value = OpEffectsReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal115 = nil char_literal116 = nil __NL117__ = nil char_literal119 = nil __NL120__ = nil op_statement118 = nil tree_for_string_literal115 = nil tree_for_char_literal116 = nil tree_for_NL117 = nil tree_for_char_literal119 = nil tree_for_NL120 = nil begin root_0 = @adaptor.create_flat_list # at line 296:4: 'effects' '{' ( NL )* ( op_statement )* '}' ( NL )+ string_literal115 = match( T__51, TOKENS_FOLLOWING_T__51_IN_op_effects_757 ) tree_for_string_literal115 = @adaptor.create_with_payload( string_literal115 ) @adaptor.add_child( root_0, tree_for_string_literal115 ) char_literal116 = match( T__84, TOKENS_FOLLOWING_T__84_IN_op_effects_759 ) tree_for_char_literal116 = @adaptor.create_with_payload( char_literal116 ) @adaptor.add_child( root_0, tree_for_char_literal116 ) # at line 296:18: ( NL )* while true # decision 48 alt_48 = 2 look_48_0 = @input.peek( 1 ) if ( look_48_0 == NL ) alt_48 = 1 end case alt_48 when 1 # at line 296:18: NL __NL117__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_effects_761 ) tree_for_NL117 = @adaptor.create_with_payload( __NL117__ ) @adaptor.add_child( root_0, tree_for_NL117 ) else break # out of loop for decision 48 end end # loop for decision 48 # --> action @now['_effect']['_parent'] = @now @now = @now['_effect'] # <-- action # at line 301:3: ( op_statement )* while true # decision 49 alt_49 = 2 look_49_0 = @input.peek( 1 ) if ( look_49_0 == ID ) alt_49 = 1 end case alt_49 when 1 # at line 301:3: op_statement @state.following.push( TOKENS_FOLLOWING_op_statement_IN_op_effects_770 ) op_statement118 = op_statement @state.following.pop @adaptor.add_child( root_0, op_statement118.tree ) else break # out of loop for decision 49 end end # loop for decision 49 char_literal119 = match( T__85, TOKENS_FOLLOWING_T__85_IN_op_effects_775 ) tree_for_char_literal119 = @adaptor.create_with_payload( char_literal119 ) @adaptor.add_child( root_0, tree_for_char_literal119 ) # at file 302:7: ( NL )+ match_count_50 = 0 while true alt_50 = 2 look_50_0 = @input.peek( 1 ) if ( look_50_0 == NL ) alt_50 = 1 end case alt_50 when 1 # at line 302:7: NL __NL120__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_effects_777 ) tree_for_NL120 = @adaptor.create_with_payload( __NL120__ ) @adaptor.add_child( root_0, tree_for_NL120 ) else match_count_50 > 0 and break eee = EarlyExit(50) raise eee end match_count_50 += 1 end # --> action self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 20 ) end return return_value end OpStatementReturnValue = define_return_scope # # parser rule op_statement # # (in SfpLang.g) # 306:1: op_statement : reference equals_op value ( NL )+ ; # def op_statement # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 21 ) return_value = OpStatementReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __NL124__ = nil reference121 = nil equals_op122 = nil value123 = nil tree_for_NL124 = nil begin root_0 = @adaptor.create_flat_list # at line 307:4: reference equals_op value ( NL )+ @state.following.push( TOKENS_FOLLOWING_reference_IN_op_statement_793 ) reference121 = reference @state.following.pop @adaptor.add_child( root_0, reference121.tree ) @state.following.push( TOKENS_FOLLOWING_equals_op_IN_op_statement_795 ) equals_op122 = equals_op @state.following.pop @adaptor.add_child( root_0, equals_op122.tree ) @state.following.push( TOKENS_FOLLOWING_value_IN_op_statement_797 ) value123 = value @state.following.pop @adaptor.add_child( root_0, value123.tree ) # at file 307:30: ( NL )+ match_count_51 = 0 while true alt_51 = 2 look_51_0 = @input.peek( 1 ) if ( look_51_0 == NL ) alt_51 = 1 end case alt_51 when 1 # at line 307:30: NL __NL124__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_statement_799 ) tree_for_NL124 = @adaptor.create_with_payload( __NL124__ ) @adaptor.add_child( root_0, tree_for_NL124 ) else match_count_51 > 0 and break eee = EarlyExit(51) raise eee end match_count_51 += 1 end # --> action @now[( reference121.nil? ? nil : reference121.val )] = ( value123.nil? ? nil : value123.val ) # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 21 ) end return return_value end ProcedureReturnValue = define_return_scope # # parser rule procedure # # (in SfpLang.g) # 311:1: procedure : ( 'synchronized' )? ( 'procedure' | 'sub' ) ID ( parameters )? '{' ( NL )* ( 'cost' equals_op NUMBER ( NL )+ )? ( conditions )? effects '}' ; # def procedure # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 22 ) return_value = ProcedureReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal125 = nil set126 = nil __ID127__ = nil char_literal129 = nil __NL130__ = nil string_literal131 = nil __NUMBER133__ = nil __NL134__ = nil char_literal137 = nil parameters128 = nil equals_op132 = nil conditions135 = nil effects136 = nil tree_for_string_literal125 = nil tree_for_set126 = nil tree_for_ID127 = nil tree_for_char_literal129 = nil tree_for_NL130 = nil tree_for_string_literal131 = nil tree_for_NUMBER133 = nil tree_for_NL134 = nil tree_for_char_literal137 = nil begin root_0 = @adaptor.create_flat_list # at line 312:4: ( 'synchronized' )? ( 'procedure' | 'sub' ) ID ( parameters )? '{' ( NL )* ( 'cost' equals_op NUMBER ( NL )+ )? ( conditions )? effects '}' # --> action @synchronized = false # <-- action # at line 313:3: ( 'synchronized' )? alt_52 = 2 look_52_0 = @input.peek( 1 ) if ( look_52_0 == T__80 ) alt_52 = 1 end case alt_52 when 1 # at line 313:4: 'synchronized' string_literal125 = match( T__80, TOKENS_FOLLOWING_T__80_IN_procedure_820 ) tree_for_string_literal125 = @adaptor.create_with_payload( string_literal125 ) @adaptor.add_child( root_0, tree_for_string_literal125 ) # --> action @synchronized = true # <-- action end set126 = @input.look if @input.peek(1) == T__74 || @input.peek(1) == T__79 @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set126 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end __ID127__ = match( ID, TOKENS_FOLLOWING_ID_IN_procedure_834 ) tree_for_ID127 = @adaptor.create_with_payload( __ID127__ ) @adaptor.add_child( root_0, tree_for_ID127 ) # --> action @now[__ID127__.text] = { '_self' => __ID127__.text, '_context' => 'procedure', '_parent' => @now, '_cost' => 1, '_condition' => { '_context' => 'constraint', '_type' => 'and' }, '_effect' => { '_context' => 'effect', '_type' => 'and' }, '_synchronized' => @synchronized, } @now = @now[__ID127__.text] # <-- action # at line 326:3: ( parameters )? alt_53 = 2 look_53_0 = @input.peek( 1 ) if ( look_53_0 == T__19 ) alt_53 = 1 end case alt_53 when 1 # at line 326:3: parameters @state.following.push( TOKENS_FOLLOWING_parameters_IN_procedure_842 ) parameters128 = parameters @state.following.pop @adaptor.add_child( root_0, parameters128.tree ) end char_literal129 = match( T__84, TOKENS_FOLLOWING_T__84_IN_procedure_845 ) tree_for_char_literal129 = @adaptor.create_with_payload( char_literal129 ) @adaptor.add_child( root_0, tree_for_char_literal129 ) # at line 326:19: ( NL )* while true # decision 54 alt_54 = 2 look_54_0 = @input.peek( 1 ) if ( look_54_0 == NL ) alt_54 = 1 end case alt_54 when 1 # at line 326:19: NL __NL130__ = match( NL, TOKENS_FOLLOWING_NL_IN_procedure_847 ) tree_for_NL130 = @adaptor.create_with_payload( __NL130__ ) @adaptor.add_child( root_0, tree_for_NL130 ) else break # out of loop for decision 54 end end # loop for decision 54 # at line 327:3: ( 'cost' equals_op NUMBER ( NL )+ )? alt_56 = 2 look_56_0 = @input.peek( 1 ) if ( look_56_0 == T__48 ) alt_56 = 1 end case alt_56 when 1 # at line 327:5: 'cost' equals_op NUMBER ( NL )+ string_literal131 = match( T__48, TOKENS_FOLLOWING_T__48_IN_procedure_855 ) tree_for_string_literal131 = @adaptor.create_with_payload( string_literal131 ) @adaptor.add_child( root_0, tree_for_string_literal131 ) @state.following.push( TOKENS_FOLLOWING_equals_op_IN_procedure_857 ) equals_op132 = equals_op @state.following.pop @adaptor.add_child( root_0, equals_op132.tree ) __NUMBER133__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_procedure_859 ) tree_for_NUMBER133 = @adaptor.create_with_payload( __NUMBER133__ ) @adaptor.add_child( root_0, tree_for_NUMBER133 ) # --> action @now['_cost'] = __NUMBER133__.text.to_i # <-- action # at file 329:4: ( NL )+ match_count_55 = 0 while true alt_55 = 2 look_55_0 = @input.peek( 1 ) if ( look_55_0 == NL ) alt_55 = 1 end case alt_55 when 1 # at line 329:4: NL __NL134__ = match( NL, TOKENS_FOLLOWING_NL_IN_procedure_869 ) tree_for_NL134 = @adaptor.create_with_payload( __NL134__ ) @adaptor.add_child( root_0, tree_for_NL134 ) else match_count_55 > 0 and break eee = EarlyExit(55) raise eee end match_count_55 += 1 end end # at line 331:3: ( conditions )? alt_57 = 2 look_57_0 = @input.peek( 1 ) if ( look_57_0.between?( T__45, T__46 ) ) alt_57 = 1 end case alt_57 when 1 # at line 331:3: conditions @state.following.push( TOKENS_FOLLOWING_conditions_IN_procedure_879 ) conditions135 = conditions @state.following.pop @adaptor.add_child( root_0, conditions135.tree ) end @state.following.push( TOKENS_FOLLOWING_effects_IN_procedure_882 ) effects136 = effects @state.following.pop @adaptor.add_child( root_0, effects136.tree ) char_literal137 = match( T__85, TOKENS_FOLLOWING_T__85_IN_procedure_884 ) tree_for_char_literal137 = @adaptor.create_with_payload( char_literal137 ) @adaptor.add_child( root_0, tree_for_char_literal137 ) # --> action self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 22 ) end return return_value end ParametersReturnValue = define_return_scope # # parser rule parameters # # (in SfpLang.g) # 335:1: parameters : '(' parameter ( ',' ( NL )* parameter )* ')' ; # def parameters # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 23 ) return_value = ParametersReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil char_literal138 = nil char_literal140 = nil __NL141__ = nil char_literal143 = nil parameter139 = nil parameter142 = nil tree_for_char_literal138 = nil tree_for_char_literal140 = nil tree_for_NL141 = nil tree_for_char_literal143 = nil begin root_0 = @adaptor.create_flat_list # at line 336:4: '(' parameter ( ',' ( NL )* parameter )* ')' char_literal138 = match( T__19, TOKENS_FOLLOWING_T__19_IN_parameters_899 ) tree_for_char_literal138 = @adaptor.create_with_payload( char_literal138 ) @adaptor.add_child( root_0, tree_for_char_literal138 ) @state.following.push( TOKENS_FOLLOWING_parameter_IN_parameters_901 ) parameter139 = parameter @state.following.pop @adaptor.add_child( root_0, parameter139.tree ) # at line 336:18: ( ',' ( NL )* parameter )* while true # decision 59 alt_59 = 2 look_59_0 = @input.peek( 1 ) if ( look_59_0 == T__23 ) alt_59 = 1 end case alt_59 when 1 # at line 336:19: ',' ( NL )* parameter char_literal140 = match( T__23, TOKENS_FOLLOWING_T__23_IN_parameters_904 ) tree_for_char_literal140 = @adaptor.create_with_payload( char_literal140 ) @adaptor.add_child( root_0, tree_for_char_literal140 ) # at line 336:23: ( NL )* while true # decision 58 alt_58 = 2 look_58_0 = @input.peek( 1 ) if ( look_58_0 == NL ) alt_58 = 1 end case alt_58 when 1 # at line 336:23: NL __NL141__ = match( NL, TOKENS_FOLLOWING_NL_IN_parameters_906 ) tree_for_NL141 = @adaptor.create_with_payload( __NL141__ ) @adaptor.add_child( root_0, tree_for_NL141 ) else break # out of loop for decision 58 end end # loop for decision 58 @state.following.push( TOKENS_FOLLOWING_parameter_IN_parameters_909 ) parameter142 = parameter @state.following.pop @adaptor.add_child( root_0, parameter142.tree ) else break # out of loop for decision 59 end end # loop for decision 59 char_literal143 = match( T__20, TOKENS_FOLLOWING_T__20_IN_parameters_913 ) tree_for_char_literal143 = @adaptor.create_with_payload( char_literal143 ) @adaptor.add_child( root_0, tree_for_char_literal143 ) # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 23 ) end return return_value end ParameterReturnValue = define_return_scope # # parser rule parameter # # (in SfpLang.g) # 339:1: parameter : ( ID ':' path | ID reference_type | ID 'areall' path | ID 'isset' path ); # def parameter # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 24 ) return_value = ParameterReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __ID144__ = nil char_literal145 = nil __ID147__ = nil __ID149__ = nil string_literal150 = nil __ID152__ = nil string_literal153 = nil path146 = nil reference_type148 = nil path151 = nil path154 = nil tree_for_ID144 = nil tree_for_char_literal145 = nil tree_for_ID147 = nil tree_for_ID149 = nil tree_for_string_literal150 = nil tree_for_ID152 = nil tree_for_string_literal153 = nil begin # at line 340:2: ( ID ':' path | ID reference_type | ID 'areall' path | ID 'isset' path ) alt_60 = 4 look_60_0 = @input.peek( 1 ) if ( look_60_0 == ID ) case look_60 = @input.peek( 2 ) when T__27 then alt_60 = 1 when T__41 then alt_60 = 3 when T__70 then alt_60 = 4 when T__69 then alt_60 = 2 else raise NoViableAlternative( "", 60, 1 ) end else raise NoViableAlternative( "", 60, 0 ) end case alt_60 when 1 root_0 = @adaptor.create_flat_list # at line 340:4: ID ':' path __ID144__ = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_925 ) tree_for_ID144 = @adaptor.create_with_payload( __ID144__ ) @adaptor.add_child( root_0, tree_for_ID144 ) char_literal145 = match( T__27, TOKENS_FOLLOWING_T__27_IN_parameter_927 ) tree_for_char_literal145 = @adaptor.create_with_payload( char_literal145 ) @adaptor.add_child( root_0, tree_for_char_literal145 ) @state.following.push( TOKENS_FOLLOWING_path_IN_parameter_929 ) path146 = path @state.following.pop @adaptor.add_child( root_0, path146.tree ) # --> action @now[__ID144__.text] = { '_context' => 'any_value', '_isa' => self.to_ref(( path146 && @input.to_s( path146.start, path146.stop ) )) } # <-- action when 2 root_0 = @adaptor.create_flat_list # at line 346:4: ID reference_type __ID147__ = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_938 ) tree_for_ID147 = @adaptor.create_with_payload( __ID147__ ) @adaptor.add_child( root_0, tree_for_ID147 ) @state.following.push( TOKENS_FOLLOWING_reference_type_IN_parameter_940 ) reference_type148 = reference_type @state.following.pop @adaptor.add_child( root_0, reference_type148.tree ) # --> action @now[__ID147__.text] = ( reference_type148.nil? ? nil : reference_type148.val ) # <-- action when 3 root_0 = @adaptor.create_flat_list # at line 348:4: ID 'areall' path __ID149__ = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_949 ) tree_for_ID149 = @adaptor.create_with_payload( __ID149__ ) @adaptor.add_child( root_0, tree_for_ID149 ) string_literal150 = match( T__41, TOKENS_FOLLOWING_T__41_IN_parameter_951 ) tree_for_string_literal150 = @adaptor.create_with_payload( string_literal150 ) @adaptor.add_child( root_0, tree_for_string_literal150 ) @state.following.push( TOKENS_FOLLOWING_path_IN_parameter_953 ) path151 = path @state.following.pop @adaptor.add_child( root_0, path151.tree ) # --> action @now[__ID149__.text] = { '_context' => 'all', '_isa' => self.to_ref(( path151 && @input.to_s( path151.start, path151.stop ) )), '_value' => nil } # <-- action when 4 root_0 = @adaptor.create_flat_list # at line 355:4: ID 'isset' path __ID152__ = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_962 ) tree_for_ID152 = @adaptor.create_with_payload( __ID152__ ) @adaptor.add_child( root_0, tree_for_ID152 ) string_literal153 = match( T__70, TOKENS_FOLLOWING_T__70_IN_parameter_964 ) tree_for_string_literal153 = @adaptor.create_with_payload( string_literal153 ) @adaptor.add_child( root_0, tree_for_string_literal153 ) @state.following.push( TOKENS_FOLLOWING_path_IN_parameter_966 ) path154 = path @state.following.pop @adaptor.add_child( root_0, path154.tree ) # --> action @now[__ID152__.text] = { '_context' => 'set', '_isa' => self.to_ref(( path154 && @input.to_s( path154.start, path154.stop ) )), '_values' => [] } # <-- action end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 24 ) end return return_value end ConditionsReturnValue = define_return_scope # # parser rule conditions # # (in SfpLang.g) # 364:1: conditions : ( 'conditions' | 'condition' ) '{' ( NL )* constraint_body '}' ( NL )+ ; # def conditions # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 25 ) return_value = ConditionsReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil set155 = nil char_literal156 = nil __NL157__ = nil char_literal159 = nil __NL160__ = nil constraint_body158 = nil tree_for_set155 = nil tree_for_char_literal156 = nil tree_for_NL157 = nil tree_for_char_literal159 = nil tree_for_NL160 = nil begin root_0 = @adaptor.create_flat_list # at line 365:4: ( 'conditions' | 'condition' ) '{' ( NL )* constraint_body '}' ( NL )+ set155 = @input.look if @input.peek( 1 ).between?( T__45, T__46 ) @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set155 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end # --> action @now['_condition']['_parent'] = @now @now = @now['_condition'] # <-- action char_literal156 = match( T__84, TOKENS_FOLLOWING_T__84_IN_conditions_995 ) tree_for_char_literal156 = @adaptor.create_with_payload( char_literal156 ) @adaptor.add_child( root_0, tree_for_char_literal156 ) # at line 370:7: ( NL )* while true # decision 61 alt_61 = 2 look_61_0 = @input.peek( 1 ) if ( look_61_0 == NL ) alt_61 = 1 end case alt_61 when 1 # at line 370:7: NL __NL157__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditions_997 ) tree_for_NL157 = @adaptor.create_with_payload( __NL157__ ) @adaptor.add_child( root_0, tree_for_NL157 ) else break # out of loop for decision 61 end end # loop for decision 61 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_conditions_1000 ) constraint_body158 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body158.tree ) char_literal159 = match( T__85, TOKENS_FOLLOWING_T__85_IN_conditions_1002 ) tree_for_char_literal159 = @adaptor.create_with_payload( char_literal159 ) @adaptor.add_child( root_0, tree_for_char_literal159 ) # at file 370:31: ( NL )+ match_count_62 = 0 while true alt_62 = 2 look_62_0 = @input.peek( 1 ) if ( look_62_0 == NL ) alt_62 = 1 end case alt_62 when 1 # at line 370:31: NL __NL160__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditions_1004 ) tree_for_NL160 = @adaptor.create_with_payload( __NL160__ ) @adaptor.add_child( root_0, tree_for_NL160 ) else match_count_62 > 0 and break eee = EarlyExit(62) raise eee end match_count_62 += 1 end # --> action self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 25 ) end return return_value end EffectsReturnValue = define_return_scope # # parser rule effects # # (in SfpLang.g) # 375:1: effects : ( 'effects' | 'effect' ) '{' ( NL )* effect_body '}' ( NL )+ ; # def effects # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 26 ) return_value = EffectsReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil set161 = nil char_literal162 = nil __NL163__ = nil char_literal165 = nil __NL166__ = nil effect_body164 = nil tree_for_set161 = nil tree_for_char_literal162 = nil tree_for_NL163 = nil tree_for_char_literal165 = nil tree_for_NL166 = nil begin root_0 = @adaptor.create_flat_list # at line 376:4: ( 'effects' | 'effect' ) '{' ( NL )* effect_body '}' ( NL )+ set161 = @input.look if @input.peek( 1 ).between?( T__50, T__51 ) @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set161 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end # --> action @now['_effect']['_parent'] = @now @now = @now['_effect'] @in_effects = true # <-- action char_literal162 = match( T__84, TOKENS_FOLLOWING_T__84_IN_effects_1035 ) tree_for_char_literal162 = @adaptor.create_with_payload( char_literal162 ) @adaptor.add_child( root_0, tree_for_char_literal162 ) # at line 382:7: ( NL )* while true # decision 63 alt_63 = 2 look_63_0 = @input.peek( 1 ) if ( look_63_0 == NL ) alt_63 = 1 end case alt_63 when 1 # at line 382:7: NL __NL163__ = match( NL, TOKENS_FOLLOWING_NL_IN_effects_1037 ) tree_for_NL163 = @adaptor.create_with_payload( __NL163__ ) @adaptor.add_child( root_0, tree_for_NL163 ) else break # out of loop for decision 63 end end # loop for decision 63 @state.following.push( TOKENS_FOLLOWING_effect_body_IN_effects_1043 ) effect_body164 = effect_body @state.following.pop @adaptor.add_child( root_0, effect_body164.tree ) char_literal165 = match( T__85, TOKENS_FOLLOWING_T__85_IN_effects_1048 ) tree_for_char_literal165 = @adaptor.create_with_payload( char_literal165 ) @adaptor.add_child( root_0, tree_for_char_literal165 ) # at file 384:7: ( NL )+ match_count_64 = 0 while true alt_64 = 2 look_64_0 = @input.peek( 1 ) if ( look_64_0 == NL ) alt_64 = 1 end case alt_64 when 1 # at line 384:7: NL __NL166__ = match( NL, TOKENS_FOLLOWING_NL_IN_effects_1050 ) tree_for_NL166 = @adaptor.create_with_payload( __NL166__ ) @adaptor.add_child( root_0, tree_for_NL166 ) else match_count_64 > 0 and break eee = EarlyExit(64) raise eee end match_count_64 += 1 end # --> action self.goto_parent() @in_effects = false # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 26 ) end return return_value end GoalConstraintReturnValue = define_return_scope # # parser rule goal_constraint # # (in SfpLang.g) # 391:1: goal_constraint : 'goal' ( 'constraint' )? ( NL )* '{' ( NL )* ( goal_body )* '}' ; # def goal_constraint # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 27 ) return_value = GoalConstraintReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal167 = nil string_literal168 = nil __NL169__ = nil char_literal170 = nil __NL171__ = nil char_literal173 = nil goal_body172 = nil tree_for_string_literal167 = nil tree_for_string_literal168 = nil tree_for_NL169 = nil tree_for_char_literal170 = nil tree_for_NL171 = nil tree_for_char_literal173 = nil begin root_0 = @adaptor.create_flat_list # at line 392:4: 'goal' ( 'constraint' )? ( NL )* '{' ( NL )* ( goal_body )* '}' string_literal167 = match( T__60, TOKENS_FOLLOWING_T__60_IN_goal_constraint_1066 ) tree_for_string_literal167 = @adaptor.create_with_payload( string_literal167 ) @adaptor.add_child( root_0, tree_for_string_literal167 ) # at line 392:11: ( 'constraint' )? alt_65 = 2 look_65_0 = @input.peek( 1 ) if ( look_65_0 == T__47 ) alt_65 = 1 end case alt_65 when 1 # at line 392:11: 'constraint' string_literal168 = match( T__47, TOKENS_FOLLOWING_T__47_IN_goal_constraint_1068 ) tree_for_string_literal168 = @adaptor.create_with_payload( string_literal168 ) @adaptor.add_child( root_0, tree_for_string_literal168 ) end # at line 392:25: ( NL )* while true # decision 66 alt_66 = 2 look_66_0 = @input.peek( 1 ) if ( look_66_0 == NL ) alt_66 = 1 end case alt_66 when 1 # at line 392:25: NL __NL169__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_constraint_1071 ) tree_for_NL169 = @adaptor.create_with_payload( __NL169__ ) @adaptor.add_child( root_0, tree_for_NL169 ) else break # out of loop for decision 66 end end # loop for decision 66 # --> action @now['goal'] = { '_self' => 'goal', '_context' => 'constraint', '_type' => 'and', '_parent' => @now } @now = @now['goal'] # <-- action char_literal170 = match( T__84, TOKENS_FOLLOWING_T__84_IN_goal_constraint_1080 ) tree_for_char_literal170 = @adaptor.create_with_payload( char_literal170 ) @adaptor.add_child( root_0, tree_for_char_literal170 ) # at line 401:7: ( NL )* while true # decision 67 alt_67 = 2 look_67_0 = @input.peek( 1 ) if ( look_67_0 == NL ) alt_67 = 1 end case alt_67 when 1 # at line 401:7: NL __NL171__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_constraint_1082 ) tree_for_NL171 = @adaptor.create_with_payload( __NL171__ ) @adaptor.add_child( root_0, tree_for_NL171 ) else break # out of loop for decision 67 end end # loop for decision 67 # at line 401:11: ( goal_body )* while true # decision 68 alt_68 = 2 look_68_0 = @input.peek( 1 ) if ( look_68_0 == ID || look_68_0.between?( T__38, T__39 ) || look_68_0 == T__43 || look_68_0 == T__53 || look_68_0.between?( T__56, T__59 ) || look_68_0 == T__62 || look_68_0 == T__72 || look_68_0 == T__77 || look_68_0.between?( T__82, T__83 ) ) alt_68 = 1 end case alt_68 when 1 # at line 401:11: goal_body @state.following.push( TOKENS_FOLLOWING_goal_body_IN_goal_constraint_1085 ) goal_body172 = goal_body @state.following.pop @adaptor.add_child( root_0, goal_body172.tree ) else break # out of loop for decision 68 end end # loop for decision 68 char_literal173 = match( T__85, TOKENS_FOLLOWING_T__85_IN_goal_constraint_1088 ) tree_for_char_literal173 = @adaptor.create_with_payload( char_literal173 ) @adaptor.add_child( root_0, tree_for_char_literal173 ) # --> action self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 27 ) end return return_value end GlobalConstraintReturnValue = define_return_scope # # parser rule global_constraint # # (in SfpLang.g) # 405:1: global_constraint : ( 'global' | 'always' ) ( 'constraint' )? ( NL )* '{' ( NL )* constraint_body '}' ; # def global_constraint # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 28 ) return_value = GlobalConstraintReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil set174 = nil string_literal175 = nil __NL176__ = nil char_literal177 = nil __NL178__ = nil char_literal180 = nil constraint_body179 = nil tree_for_set174 = nil tree_for_string_literal175 = nil tree_for_NL176 = nil tree_for_char_literal177 = nil tree_for_NL178 = nil tree_for_char_literal180 = nil begin root_0 = @adaptor.create_flat_list # at line 406:4: ( 'global' | 'always' ) ( 'constraint' )? ( NL )* '{' ( NL )* constraint_body '}' set174 = @input.look if @input.peek(1) == T__39 || @input.peek(1) == T__59 @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set174 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end # at line 406:24: ( 'constraint' )? alt_69 = 2 look_69_0 = @input.peek( 1 ) if ( look_69_0 == T__47 ) alt_69 = 1 end case alt_69 when 1 # at line 406:24: 'constraint' string_literal175 = match( T__47, TOKENS_FOLLOWING_T__47_IN_global_constraint_1109 ) tree_for_string_literal175 = @adaptor.create_with_payload( string_literal175 ) @adaptor.add_child( root_0, tree_for_string_literal175 ) end # at line 406:38: ( NL )* while true # decision 70 alt_70 = 2 look_70_0 = @input.peek( 1 ) if ( look_70_0 == NL ) alt_70 = 1 end case alt_70 when 1 # at line 406:38: NL __NL176__ = match( NL, TOKENS_FOLLOWING_NL_IN_global_constraint_1112 ) tree_for_NL176 = @adaptor.create_with_payload( __NL176__ ) @adaptor.add_child( root_0, tree_for_NL176 ) else break # out of loop for decision 70 end end # loop for decision 70 # --> action @now['global'] = self.create_constraint('global', 'and') if !@now.has_key?('global') @now = @now['global'] # <-- action char_literal177 = match( T__84, TOKENS_FOLLOWING_T__84_IN_global_constraint_1121 ) tree_for_char_literal177 = @adaptor.create_with_payload( char_literal177 ) @adaptor.add_child( root_0, tree_for_char_literal177 ) # at line 411:7: ( NL )* while true # decision 71 alt_71 = 2 look_71_0 = @input.peek( 1 ) if ( look_71_0 == NL ) alt_71 = 1 end case alt_71 when 1 # at line 411:7: NL __NL178__ = match( NL, TOKENS_FOLLOWING_NL_IN_global_constraint_1123 ) tree_for_NL178 = @adaptor.create_with_payload( __NL178__ ) @adaptor.add_child( root_0, tree_for_NL178 ) else break # out of loop for decision 71 end end # loop for decision 71 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_global_constraint_1126 ) constraint_body179 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body179.tree ) char_literal180 = match( T__85, TOKENS_FOLLOWING_T__85_IN_global_constraint_1128 ) tree_for_char_literal180 = @adaptor.create_with_payload( char_literal180 ) @adaptor.add_child( root_0, tree_for_char_literal180 ) # --> action self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 28 ) end return return_value end SometimeConstraintReturnValue = define_return_scope # # parser rule sometime_constraint # # (in SfpLang.g) # 415:1: sometime_constraint : 'sometime' ( 'constraint' )? ( NL )* '{' ( NL )* constraint_body '}' ; # def sometime_constraint # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 29 ) return_value = SometimeConstraintReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal181 = nil string_literal182 = nil __NL183__ = nil char_literal184 = nil __NL185__ = nil char_literal187 = nil constraint_body186 = nil tree_for_string_literal181 = nil tree_for_string_literal182 = nil tree_for_NL183 = nil tree_for_char_literal184 = nil tree_for_NL185 = nil tree_for_char_literal187 = nil begin root_0 = @adaptor.create_flat_list # at line 416:4: 'sometime' ( 'constraint' )? ( NL )* '{' ( NL )* constraint_body '}' string_literal181 = match( T__77, TOKENS_FOLLOWING_T__77_IN_sometime_constraint_1143 ) tree_for_string_literal181 = @adaptor.create_with_payload( string_literal181 ) @adaptor.add_child( root_0, tree_for_string_literal181 ) # at line 416:15: ( 'constraint' )? alt_72 = 2 look_72_0 = @input.peek( 1 ) if ( look_72_0 == T__47 ) alt_72 = 1 end case alt_72 when 1 # at line 416:15: 'constraint' string_literal182 = match( T__47, TOKENS_FOLLOWING_T__47_IN_sometime_constraint_1145 ) tree_for_string_literal182 = @adaptor.create_with_payload( string_literal182 ) @adaptor.add_child( root_0, tree_for_string_literal182 ) end # at line 416:29: ( NL )* while true # decision 73 alt_73 = 2 look_73_0 = @input.peek( 1 ) if ( look_73_0 == NL ) alt_73 = 1 end case alt_73 when 1 # at line 416:29: NL __NL183__ = match( NL, TOKENS_FOLLOWING_NL_IN_sometime_constraint_1148 ) tree_for_NL183 = @adaptor.create_with_payload( __NL183__ ) @adaptor.add_child( root_0, tree_for_NL183 ) else break # out of loop for decision 73 end end # loop for decision 73 # --> action @now['sometime'] = self.create_constraint('sometime', 'or') if !@now.has_key?('sometime') @now = @now['sometime'] # <-- action char_literal184 = match( T__84, TOKENS_FOLLOWING_T__84_IN_sometime_constraint_1157 ) tree_for_char_literal184 = @adaptor.create_with_payload( char_literal184 ) @adaptor.add_child( root_0, tree_for_char_literal184 ) # at line 421:7: ( NL )* while true # decision 74 alt_74 = 2 look_74_0 = @input.peek( 1 ) if ( look_74_0 == NL ) alt_74 = 1 end case alt_74 when 1 # at line 421:7: NL __NL185__ = match( NL, TOKENS_FOLLOWING_NL_IN_sometime_constraint_1159 ) tree_for_NL185 = @adaptor.create_with_payload( __NL185__ ) @adaptor.add_child( root_0, tree_for_NL185 ) else break # out of loop for decision 74 end end # loop for decision 74 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_sometime_constraint_1162 ) constraint_body186 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body186.tree ) char_literal187 = match( T__85, TOKENS_FOLLOWING_T__85_IN_sometime_constraint_1164 ) tree_for_char_literal187 = @adaptor.create_with_payload( char_literal187 ) @adaptor.add_child( root_0, tree_for_char_literal187 ) # --> action self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 29 ) end return return_value end GoalBodyReturnValue = define_return_scope # # parser rule goal_body # # (in SfpLang.g) # 426:1: goal_body : ( ( ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ ) | ( 'always' | 'global' ) ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ | 'sometime' ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ | 'within' NUMBER ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ | 'after' ( NL )* '{' ( NL )* constraint_body '}' ( NL )* ( 'then' | 'within' NUMBER ) ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ | 'before' ( NL )* '{' ( NL )* constraint_body '}' ( NL )* 'then' ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ ); # def goal_body # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 30 ) return_value = GoalBodyReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __NL192__ = nil set193 = nil __NL194__ = nil char_literal195 = nil __NL196__ = nil char_literal198 = nil __NL199__ = nil string_literal200 = nil __NL201__ = nil char_literal202 = nil __NL203__ = nil char_literal205 = nil __NL206__ = nil string_literal207 = nil __NUMBER208__ = nil __NL209__ = nil char_literal210 = nil __NL211__ = nil char_literal213 = nil __NL214__ = nil string_literal215 = nil __NL216__ = nil char_literal217 = nil __NL218__ = nil char_literal220 = nil __NL221__ = nil string_literal222 = nil string_literal223 = nil __NUMBER224__ = nil __NL225__ = nil char_literal226 = nil __NL227__ = nil char_literal229 = nil __NL230__ = nil string_literal231 = nil __NL232__ = nil char_literal233 = nil __NL234__ = nil char_literal236 = nil __NL237__ = nil string_literal238 = nil __NL239__ = nil char_literal240 = nil __NL241__ = nil char_literal243 = nil __NL244__ = nil constraint_statement188 = nil constraint_namespace189 = nil constraint_iterator190 = nil constraint_class_quantification191 = nil constraint_body197 = nil constraint_body204 = nil constraint_body212 = nil constraint_body219 = nil constraint_body228 = nil constraint_body235 = nil constraint_body242 = nil tree_for_NL192 = nil tree_for_set193 = nil tree_for_NL194 = nil tree_for_char_literal195 = nil tree_for_NL196 = nil tree_for_char_literal198 = nil tree_for_NL199 = nil tree_for_string_literal200 = nil tree_for_NL201 = nil tree_for_char_literal202 = nil tree_for_NL203 = nil tree_for_char_literal205 = nil tree_for_NL206 = nil tree_for_string_literal207 = nil tree_for_NUMBER208 = nil tree_for_NL209 = nil tree_for_char_literal210 = nil tree_for_NL211 = nil tree_for_char_literal213 = nil tree_for_NL214 = nil tree_for_string_literal215 = nil tree_for_NL216 = nil tree_for_char_literal217 = nil tree_for_NL218 = nil tree_for_char_literal220 = nil tree_for_NL221 = nil tree_for_string_literal222 = nil tree_for_string_literal223 = nil tree_for_NUMBER224 = nil tree_for_NL225 = nil tree_for_char_literal226 = nil tree_for_NL227 = nil tree_for_char_literal229 = nil tree_for_NL230 = nil tree_for_string_literal231 = nil tree_for_NL232 = nil tree_for_char_literal233 = nil tree_for_NL234 = nil tree_for_char_literal236 = nil tree_for_NL237 = nil tree_for_string_literal238 = nil tree_for_NL239 = nil tree_for_char_literal240 = nil tree_for_NL241 = nil tree_for_char_literal243 = nil tree_for_NL244 = nil begin # at line 427:2: ( ( ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ ) | ( 'always' | 'global' ) ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ | 'sometime' ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ | 'within' NUMBER ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ | 'after' ( NL )* '{' ( NL )* constraint_body '}' ( NL )* ( 'then' | 'within' NUMBER ) ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ | 'before' ( NL )* '{' ( NL )* constraint_body '}' ( NL )* 'then' ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ ) alt_99 = 6 case look_99 = @input.peek( 1 ) when ID, T__53, T__56, T__57, T__58, T__62, T__72, T__82 then alt_99 = 1 when T__39, T__59 then alt_99 = 2 when T__77 then alt_99 = 3 when T__83 then alt_99 = 4 when T__38 then alt_99 = 5 when T__43 then alt_99 = 6 else raise NoViableAlternative( "", 99, 0 ) end case alt_99 when 1 root_0 = @adaptor.create_flat_list # at line 427:4: ( ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ ) # at line 427:4: ( ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ ) # at line 428:4: ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ # at line 428:4: ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) alt_75 = 4 alt_75 = @dfa75.predict( @input ) case alt_75 when 1 # at line 428:6: constraint_statement @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_goal_body_1187 ) constraint_statement188 = constraint_statement @state.following.pop @adaptor.add_child( root_0, constraint_statement188.tree ) # --> action @now[( constraint_statement188.nil? ? nil : constraint_statement188.key )] = ( constraint_statement188.nil? ? nil : constraint_statement188.val ) # <-- action when 2 # at line 432:6: constraint_namespace @state.following.push( TOKENS_FOLLOWING_constraint_namespace_IN_goal_body_1200 ) constraint_namespace189 = constraint_namespace @state.following.pop @adaptor.add_child( root_0, constraint_namespace189.tree ) when 3 # at line 433:6: constraint_iterator @state.following.push( TOKENS_FOLLOWING_constraint_iterator_IN_goal_body_1207 ) constraint_iterator190 = constraint_iterator @state.following.pop @adaptor.add_child( root_0, constraint_iterator190.tree ) when 4 # at line 434:6: constraint_class_quantification @state.following.push( TOKENS_FOLLOWING_constraint_class_quantification_IN_goal_body_1214 ) constraint_class_quantification191 = constraint_class_quantification @state.following.pop @adaptor.add_child( root_0, constraint_class_quantification191.tree ) end # at file 436:3: ( NL )+ match_count_76 = 0 while true alt_76 = 2 look_76_0 = @input.peek( 1 ) if ( look_76_0 == NL ) alt_76 = 1 end case alt_76 when 1 # at line 436:3: NL __NL192__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1223 ) tree_for_NL192 = @adaptor.create_with_payload( __NL192__ ) @adaptor.add_child( root_0, tree_for_NL192 ) else match_count_76 > 0 and break eee = EarlyExit(76) raise eee end match_count_76 += 1 end when 2 root_0 = @adaptor.create_flat_list # at line 437:4: ( 'always' | 'global' ) ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ set193 = @input.look if @input.peek(1) == T__39 || @input.peek(1) == T__59 @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set193 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end # at line 437:24: ( NL )* while true # decision 77 alt_77 = 2 look_77_0 = @input.peek( 1 ) if ( look_77_0 == NL ) alt_77 = 1 end case alt_77 when 1 # at line 437:24: NL __NL194__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1236 ) tree_for_NL194 = @adaptor.create_with_payload( __NL194__ ) @adaptor.add_child( root_0, tree_for_NL194 ) else break # out of loop for decision 77 end end # loop for decision 77 # --> action @now['global'] = self.create_constraint('global', 'and') if not @now.has_key?('global') @now = @now['global'] # <-- action char_literal195 = match( T__84, TOKENS_FOLLOWING_T__84_IN_goal_body_1245 ) tree_for_char_literal195 = @adaptor.create_with_payload( char_literal195 ) @adaptor.add_child( root_0, tree_for_char_literal195 ) # at line 443:7: ( NL )* while true # decision 78 alt_78 = 2 look_78_0 = @input.peek( 1 ) if ( look_78_0 == NL ) alt_78 = 1 end case alt_78 when 1 # at line 443:7: NL __NL196__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1247 ) tree_for_NL196 = @adaptor.create_with_payload( __NL196__ ) @adaptor.add_child( root_0, tree_for_NL196 ) else break # out of loop for decision 78 end end # loop for decision 78 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_goal_body_1250 ) constraint_body197 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body197.tree ) char_literal198 = match( T__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1252 ) tree_for_char_literal198 = @adaptor.create_with_payload( char_literal198 ) @adaptor.add_child( root_0, tree_for_char_literal198 ) # at file 443:31: ( NL )+ match_count_79 = 0 while true alt_79 = 2 look_79_0 = @input.peek( 1 ) if ( look_79_0 == NL ) alt_79 = 1 end case alt_79 when 1 # at line 443:31: NL __NL199__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1254 ) tree_for_NL199 = @adaptor.create_with_payload( __NL199__ ) @adaptor.add_child( root_0, tree_for_NL199 ) else match_count_79 > 0 and break eee = EarlyExit(79) raise eee end match_count_79 += 1 end # --> action self.goto_parent() # <-- action when 3 root_0 = @adaptor.create_flat_list # at line 445:4: 'sometime' ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ string_literal200 = match( T__77, TOKENS_FOLLOWING_T__77_IN_goal_body_1264 ) tree_for_string_literal200 = @adaptor.create_with_payload( string_literal200 ) @adaptor.add_child( root_0, tree_for_string_literal200 ) # at line 445:15: ( NL )* while true # decision 80 alt_80 = 2 look_80_0 = @input.peek( 1 ) if ( look_80_0 == NL ) alt_80 = 1 end case alt_80 when 1 # at line 445:15: NL __NL201__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1266 ) tree_for_NL201 = @adaptor.create_with_payload( __NL201__ ) @adaptor.add_child( root_0, tree_for_NL201 ) else break # out of loop for decision 80 end end # loop for decision 80 # --> action @now['sometime'] = self.create_constraint('sometime', 'or') if not @now.has_key?('sometime') @now = @now['sometime'] id = self.next_id.to_s @now[id] = self.create_constraint(id, 'and') @now = @now[id] # <-- action char_literal202 = match( T__84, TOKENS_FOLLOWING_T__84_IN_goal_body_1275 ) tree_for_char_literal202 = @adaptor.create_with_payload( char_literal202 ) @adaptor.add_child( root_0, tree_for_char_literal202 ) # at line 454:7: ( NL )* while true # decision 81 alt_81 = 2 look_81_0 = @input.peek( 1 ) if ( look_81_0 == NL ) alt_81 = 1 end case alt_81 when 1 # at line 454:7: NL __NL203__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1277 ) tree_for_NL203 = @adaptor.create_with_payload( __NL203__ ) @adaptor.add_child( root_0, tree_for_NL203 ) else break # out of loop for decision 81 end end # loop for decision 81 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_goal_body_1280 ) constraint_body204 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body204.tree ) char_literal205 = match( T__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1282 ) tree_for_char_literal205 = @adaptor.create_with_payload( char_literal205 ) @adaptor.add_child( root_0, tree_for_char_literal205 ) # at file 454:31: ( NL )+ match_count_82 = 0 while true alt_82 = 2 look_82_0 = @input.peek( 1 ) if ( look_82_0 == NL ) alt_82 = 1 end case alt_82 when 1 # at line 454:31: NL __NL206__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1284 ) tree_for_NL206 = @adaptor.create_with_payload( __NL206__ ) @adaptor.add_child( root_0, tree_for_NL206 ) else match_count_82 > 0 and break eee = EarlyExit(82) raise eee end match_count_82 += 1 end # --> action self.goto_parent() # <-- action # --> action self.goto_parent() # <-- action when 4 root_0 = @adaptor.create_flat_list # at line 457:4: 'within' NUMBER ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ string_literal207 = match( T__83, TOKENS_FOLLOWING_T__83_IN_goal_body_1298 ) tree_for_string_literal207 = @adaptor.create_with_payload( string_literal207 ) @adaptor.add_child( root_0, tree_for_string_literal207 ) __NUMBER208__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_goal_body_1300 ) tree_for_NUMBER208 = @adaptor.create_with_payload( __NUMBER208__ ) @adaptor.add_child( root_0, tree_for_NUMBER208 ) # at line 457:20: ( NL )* while true # decision 83 alt_83 = 2 look_83_0 = @input.peek( 1 ) if ( look_83_0 == NL ) alt_83 = 1 end case alt_83 when 1 # at line 457:20: NL __NL209__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1302 ) tree_for_NL209 = @adaptor.create_with_payload( __NL209__ ) @adaptor.add_child( root_0, tree_for_NL209 ) else break # out of loop for decision 83 end end # loop for decision 83 # --> action id = self.next_id.to_s @now[id] = self.create_constraint(id, 'within') @now = @now[id] @now['deadline'] = __NUMBER208__.text.to_s.to_i # <-- action char_literal210 = match( T__84, TOKENS_FOLLOWING_T__84_IN_goal_body_1311 ) tree_for_char_literal210 = @adaptor.create_with_payload( char_literal210 ) @adaptor.add_child( root_0, tree_for_char_literal210 ) # at line 464:7: ( NL )* while true # decision 84 alt_84 = 2 look_84_0 = @input.peek( 1 ) if ( look_84_0 == NL ) alt_84 = 1 end case alt_84 when 1 # at line 464:7: NL __NL211__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1313 ) tree_for_NL211 = @adaptor.create_with_payload( __NL211__ ) @adaptor.add_child( root_0, tree_for_NL211 ) else break # out of loop for decision 84 end end # loop for decision 84 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_goal_body_1316 ) constraint_body212 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body212.tree ) char_literal213 = match( T__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1318 ) tree_for_char_literal213 = @adaptor.create_with_payload( char_literal213 ) @adaptor.add_child( root_0, tree_for_char_literal213 ) # at file 464:31: ( NL )+ match_count_85 = 0 while true alt_85 = 2 look_85_0 = @input.peek( 1 ) if ( look_85_0 == NL ) alt_85 = 1 end case alt_85 when 1 # at line 464:31: NL __NL214__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1320 ) tree_for_NL214 = @adaptor.create_with_payload( __NL214__ ) @adaptor.add_child( root_0, tree_for_NL214 ) else match_count_85 > 0 and break eee = EarlyExit(85) raise eee end match_count_85 += 1 end # --> action self.goto_parent() # <-- action when 5 root_0 = @adaptor.create_flat_list # at line 466:4: 'after' ( NL )* '{' ( NL )* constraint_body '}' ( NL )* ( 'then' | 'within' NUMBER ) ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ string_literal215 = match( T__38, TOKENS_FOLLOWING_T__38_IN_goal_body_1330 ) tree_for_string_literal215 = @adaptor.create_with_payload( string_literal215 ) @adaptor.add_child( root_0, tree_for_string_literal215 ) # at line 466:12: ( NL )* while true # decision 86 alt_86 = 2 look_86_0 = @input.peek( 1 ) if ( look_86_0 == NL ) alt_86 = 1 end case alt_86 when 1 # at line 466:12: NL __NL216__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1332 ) tree_for_NL216 = @adaptor.create_with_payload( __NL216__ ) @adaptor.add_child( root_0, tree_for_NL216 ) else break # out of loop for decision 86 end end # loop for decision 86 # --> action @now['sometime-after'] = self.create_constraint('sometime-after', 'or') if not @now.has_key?('sometime-after') @now = @now['sometime-after'] id = self.next_id.to_s @now[id] = self.create_constraint(id, 'sometime-after') @now = @now[id] @now['after'] = self.create_constraint('after') @now['deadline'] = -1 @now = @now['after'] # <-- action char_literal217 = match( T__84, TOKENS_FOLLOWING_T__84_IN_goal_body_1341 ) tree_for_char_literal217 = @adaptor.create_with_payload( char_literal217 ) @adaptor.add_child( root_0, tree_for_char_literal217 ) # at line 479:7: ( NL )* while true # decision 87 alt_87 = 2 look_87_0 = @input.peek( 1 ) if ( look_87_0 == NL ) alt_87 = 1 end case alt_87 when 1 # at line 479:7: NL __NL218__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1343 ) tree_for_NL218 = @adaptor.create_with_payload( __NL218__ ) @adaptor.add_child( root_0, tree_for_NL218 ) else break # out of loop for decision 87 end end # loop for decision 87 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_goal_body_1346 ) constraint_body219 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body219.tree ) char_literal220 = match( T__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1348 ) tree_for_char_literal220 = @adaptor.create_with_payload( char_literal220 ) @adaptor.add_child( root_0, tree_for_char_literal220 ) # at line 479:31: ( NL )* while true # decision 88 alt_88 = 2 look_88_0 = @input.peek( 1 ) if ( look_88_0 == NL ) alt_88 = 1 end case alt_88 when 1 # at line 479:31: NL __NL221__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1350 ) tree_for_NL221 = @adaptor.create_with_payload( __NL221__ ) @adaptor.add_child( root_0, tree_for_NL221 ) else break # out of loop for decision 88 end end # loop for decision 88 # --> action self.goto_parent() # <-- action # at line 481:3: ( 'then' | 'within' NUMBER ) alt_89 = 2 look_89_0 = @input.peek( 1 ) if ( look_89_0 == T__81 ) alt_89 = 1 elsif ( look_89_0 == T__83 ) alt_89 = 2 else raise NoViableAlternative( "", 89, 0 ) end case alt_89 when 1 # at line 481:5: 'then' string_literal222 = match( T__81, TOKENS_FOLLOWING_T__81_IN_goal_body_1361 ) tree_for_string_literal222 = @adaptor.create_with_payload( string_literal222 ) @adaptor.add_child( root_0, tree_for_string_literal222 ) when 2 # at line 482:6: 'within' NUMBER string_literal223 = match( T__83, TOKENS_FOLLOWING_T__83_IN_goal_body_1368 ) tree_for_string_literal223 = @adaptor.create_with_payload( string_literal223 ) @adaptor.add_child( root_0, tree_for_string_literal223 ) __NUMBER224__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_goal_body_1370 ) tree_for_NUMBER224 = @adaptor.create_with_payload( __NUMBER224__ ) @adaptor.add_child( root_0, tree_for_NUMBER224 ) # --> action @now['deadline'] = __NUMBER224__.text.to_s.to_i # <-- action end # at line 484:5: ( NL )* while true # decision 90 alt_90 = 2 look_90_0 = @input.peek( 1 ) if ( look_90_0 == NL ) alt_90 = 1 end case alt_90 when 1 # at line 484:5: NL __NL225__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1382 ) tree_for_NL225 = @adaptor.create_with_payload( __NL225__ ) @adaptor.add_child( root_0, tree_for_NL225 ) else break # out of loop for decision 90 end end # loop for decision 90 # --> action @now['then'] = self.create_constraint('then') @now = @now['then'] # <-- action char_literal226 = match( T__84, TOKENS_FOLLOWING_T__84_IN_goal_body_1391 ) tree_for_char_literal226 = @adaptor.create_with_payload( char_literal226 ) @adaptor.add_child( root_0, tree_for_char_literal226 ) # at line 489:7: ( NL )* while true # decision 91 alt_91 = 2 look_91_0 = @input.peek( 1 ) if ( look_91_0 == NL ) alt_91 = 1 end case alt_91 when 1 # at line 489:7: NL __NL227__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1393 ) tree_for_NL227 = @adaptor.create_with_payload( __NL227__ ) @adaptor.add_child( root_0, tree_for_NL227 ) else break # out of loop for decision 91 end end # loop for decision 91 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_goal_body_1396 ) constraint_body228 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body228.tree ) char_literal229 = match( T__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1398 ) tree_for_char_literal229 = @adaptor.create_with_payload( char_literal229 ) @adaptor.add_child( root_0, tree_for_char_literal229 ) # at file 489:31: ( NL )+ match_count_92 = 0 while true alt_92 = 2 look_92_0 = @input.peek( 1 ) if ( look_92_0 == NL ) alt_92 = 1 end case alt_92 when 1 # at line 489:31: NL __NL230__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1400 ) tree_for_NL230 = @adaptor.create_with_payload( __NL230__ ) @adaptor.add_child( root_0, tree_for_NL230 ) else match_count_92 > 0 and break eee = EarlyExit(92) raise eee end match_count_92 += 1 end # --> action self.goto_parent() # <-- action # --> action self.goto_parent() # <-- action # --> action self.goto_parent() # <-- action when 6 root_0 = @adaptor.create_flat_list # at line 493:4: 'before' ( NL )* '{' ( NL )* constraint_body '}' ( NL )* 'then' ( NL )* '{' ( NL )* constraint_body '}' ( NL )+ string_literal231 = match( T__43, TOKENS_FOLLOWING_T__43_IN_goal_body_1418 ) tree_for_string_literal231 = @adaptor.create_with_payload( string_literal231 ) @adaptor.add_child( root_0, tree_for_string_literal231 ) # at line 493:13: ( NL )* while true # decision 93 alt_93 = 2 look_93_0 = @input.peek( 1 ) if ( look_93_0 == NL ) alt_93 = 1 end case alt_93 when 1 # at line 493:13: NL __NL232__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1420 ) tree_for_NL232 = @adaptor.create_with_payload( __NL232__ ) @adaptor.add_child( root_0, tree_for_NL232 ) else break # out of loop for decision 93 end end # loop for decision 93 # --> action id = self.next_id.to_s @now[id] = self.create_constraint(id, 'sometime-before') @now = @now[id] @now['before'] = self.create_constraint('before') @now = @now['before'] # <-- action char_literal233 = match( T__84, TOKENS_FOLLOWING_T__84_IN_goal_body_1429 ) tree_for_char_literal233 = @adaptor.create_with_payload( char_literal233 ) @adaptor.add_child( root_0, tree_for_char_literal233 ) # at line 501:7: ( NL )* while true # decision 94 alt_94 = 2 look_94_0 = @input.peek( 1 ) if ( look_94_0 == NL ) alt_94 = 1 end case alt_94 when 1 # at line 501:7: NL __NL234__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1431 ) tree_for_NL234 = @adaptor.create_with_payload( __NL234__ ) @adaptor.add_child( root_0, tree_for_NL234 ) else break # out of loop for decision 94 end end # loop for decision 94 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_goal_body_1434 ) constraint_body235 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body235.tree ) char_literal236 = match( T__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1436 ) tree_for_char_literal236 = @adaptor.create_with_payload( char_literal236 ) @adaptor.add_child( root_0, tree_for_char_literal236 ) # at line 501:31: ( NL )* while true # decision 95 alt_95 = 2 look_95_0 = @input.peek( 1 ) if ( look_95_0 == NL ) alt_95 = 1 end case alt_95 when 1 # at line 501:31: NL __NL237__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1438 ) tree_for_NL237 = @adaptor.create_with_payload( __NL237__ ) @adaptor.add_child( root_0, tree_for_NL237 ) else break # out of loop for decision 95 end end # loop for decision 95 # --> action self.goto_parent() # <-- action string_literal238 = match( T__81, TOKENS_FOLLOWING_T__81_IN_goal_body_1447 ) tree_for_string_literal238 = @adaptor.create_with_payload( string_literal238 ) @adaptor.add_child( root_0, tree_for_string_literal238 ) # at line 503:10: ( NL )* while true # decision 96 alt_96 = 2 look_96_0 = @input.peek( 1 ) if ( look_96_0 == NL ) alt_96 = 1 end case alt_96 when 1 # at line 503:10: NL __NL239__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1449 ) tree_for_NL239 = @adaptor.create_with_payload( __NL239__ ) @adaptor.add_child( root_0, tree_for_NL239 ) else break # out of loop for decision 96 end end # loop for decision 96 # --> action @now['then'] = self.create_constraint('then') @now = @now['then'] # <-- action char_literal240 = match( T__84, TOKENS_FOLLOWING_T__84_IN_goal_body_1458 ) tree_for_char_literal240 = @adaptor.create_with_payload( char_literal240 ) @adaptor.add_child( root_0, tree_for_char_literal240 ) # at line 508:7: ( NL )* while true # decision 97 alt_97 = 2 look_97_0 = @input.peek( 1 ) if ( look_97_0 == NL ) alt_97 = 1 end case alt_97 when 1 # at line 508:7: NL __NL241__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1460 ) tree_for_NL241 = @adaptor.create_with_payload( __NL241__ ) @adaptor.add_child( root_0, tree_for_NL241 ) else break # out of loop for decision 97 end end # loop for decision 97 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_goal_body_1463 ) constraint_body242 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body242.tree ) char_literal243 = match( T__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1465 ) tree_for_char_literal243 = @adaptor.create_with_payload( char_literal243 ) @adaptor.add_child( root_0, tree_for_char_literal243 ) # at file 508:31: ( NL )+ match_count_98 = 0 while true alt_98 = 2 look_98_0 = @input.peek( 1 ) if ( look_98_0 == NL ) alt_98 = 1 end case alt_98 when 1 # at line 508:31: NL __NL244__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1467 ) tree_for_NL244 = @adaptor.create_with_payload( __NL244__ ) @adaptor.add_child( root_0, tree_for_NL244 ) else match_count_98 > 0 and break eee = EarlyExit(98) raise eee end match_count_98 += 1 end # --> action self.goto_parent() # <-- action # --> action self.goto_parent() # <-- action end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 30 ) end return return_value end NestedConstraintReturnValue = define_return_scope # # parser rule nested_constraint # # (in SfpLang.g) # 513:1: nested_constraint : '{' ( NL )* constraint_body '}' ; # def nested_constraint # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 31 ) return_value = NestedConstraintReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil char_literal245 = nil __NL246__ = nil char_literal248 = nil constraint_body247 = nil tree_for_char_literal245 = nil tree_for_NL246 = nil tree_for_char_literal248 = nil begin root_0 = @adaptor.create_flat_list # at line 514:4: '{' ( NL )* constraint_body '}' char_literal245 = match( T__84, TOKENS_FOLLOWING_T__84_IN_nested_constraint_1487 ) tree_for_char_literal245 = @adaptor.create_with_payload( char_literal245 ) @adaptor.add_child( root_0, tree_for_char_literal245 ) # at line 514:8: ( NL )* while true # decision 100 alt_100 = 2 look_100_0 = @input.peek( 1 ) if ( look_100_0 == NL ) alt_100 = 1 end case alt_100 when 1 # at line 514:8: NL __NL246__ = match( NL, TOKENS_FOLLOWING_NL_IN_nested_constraint_1489 ) tree_for_NL246 = @adaptor.create_with_payload( __NL246__ ) @adaptor.add_child( root_0, tree_for_NL246 ) else break # out of loop for decision 100 end end # loop for decision 100 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_nested_constraint_1492 ) constraint_body247 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body247.tree ) char_literal248 = match( T__85, TOKENS_FOLLOWING_T__85_IN_nested_constraint_1494 ) tree_for_char_literal248 = @adaptor.create_with_payload( char_literal248 ) @adaptor.add_child( root_0, tree_for_char_literal248 ) # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 31 ) end return return_value end ConstraintReturnValue = define_return_scope # # parser rule constraint # # (in SfpLang.g) # 517:1: constraint : 'constraint' ID '{' ( NL )* constraint_body '}' ; # def constraint # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 32 ) return_value = ConstraintReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal249 = nil __ID250__ = nil char_literal251 = nil __NL252__ = nil char_literal254 = nil constraint_body253 = nil tree_for_string_literal249 = nil tree_for_ID250 = nil tree_for_char_literal251 = nil tree_for_NL252 = nil tree_for_char_literal254 = nil begin root_0 = @adaptor.create_flat_list # at line 518:4: 'constraint' ID '{' ( NL )* constraint_body '}' string_literal249 = match( T__47, TOKENS_FOLLOWING_T__47_IN_constraint_1505 ) tree_for_string_literal249 = @adaptor.create_with_payload( string_literal249 ) @adaptor.add_child( root_0, tree_for_string_literal249 ) __ID250__ = match( ID, TOKENS_FOLLOWING_ID_IN_constraint_1507 ) tree_for_ID250 = @adaptor.create_with_payload( __ID250__ ) @adaptor.add_child( root_0, tree_for_ID250 ) # --> action @now[__ID250__.text] = self.create_constraint(__ID250__.text, 'and') @now = @now[__ID250__.text] # <-- action char_literal251 = match( T__84, TOKENS_FOLLOWING_T__84_IN_constraint_1515 ) tree_for_char_literal251 = @adaptor.create_with_payload( char_literal251 ) @adaptor.add_child( root_0, tree_for_char_literal251 ) # at line 523:7: ( NL )* while true # decision 101 alt_101 = 2 look_101_0 = @input.peek( 1 ) if ( look_101_0 == NL ) alt_101 = 1 end case alt_101 when 1 # at line 523:7: NL __NL252__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_1517 ) tree_for_NL252 = @adaptor.create_with_payload( __NL252__ ) @adaptor.add_child( root_0, tree_for_NL252 ) else break # out of loop for decision 101 end end # loop for decision 101 @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_constraint_1520 ) constraint_body253 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body253.tree ) char_literal254 = match( T__85, TOKENS_FOLLOWING_T__85_IN_constraint_1522 ) tree_for_char_literal254 = @adaptor.create_with_payload( char_literal254 ) @adaptor.add_child( root_0, tree_for_char_literal254 ) # --> action self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 32 ) end return return_value end ConstraintBodyReturnValue = define_return_scope # # parser rule constraint_body # # (in SfpLang.g) # 527:1: constraint_body : ( ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ )* ; # def constraint_body # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 33 ) return_value = ConstraintBodyReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __NL259__ = nil constraint_statement255 = nil constraint_namespace256 = nil constraint_iterator257 = nil constraint_class_quantification258 = nil tree_for_NL259 = nil begin root_0 = @adaptor.create_flat_list # at line 528:4: ( ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ )* # at line 528:4: ( ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ )* while true # decision 104 alt_104 = 2 look_104_0 = @input.peek( 1 ) if ( look_104_0 == ID || look_104_0 == T__53 || look_104_0.between?( T__56, T__58 ) || look_104_0 == T__62 || look_104_0 == T__72 || look_104_0 == T__82 ) alt_104 = 1 end case alt_104 when 1 # at line 529:4: ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ # at line 529:4: ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) alt_102 = 4 alt_102 = @dfa102.predict( @input ) case alt_102 when 1 # at line 529:6: constraint_statement @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_constraint_body_1544 ) constraint_statement255 = constraint_statement @state.following.pop @adaptor.add_child( root_0, constraint_statement255.tree ) # --> action @now[( constraint_statement255.nil? ? nil : constraint_statement255.key )] = ( constraint_statement255.nil? ? nil : constraint_statement255.val ) # <-- action when 2 # at line 533:6: constraint_namespace @state.following.push( TOKENS_FOLLOWING_constraint_namespace_IN_constraint_body_1557 ) constraint_namespace256 = constraint_namespace @state.following.pop @adaptor.add_child( root_0, constraint_namespace256.tree ) when 3 # at line 534:6: constraint_iterator @state.following.push( TOKENS_FOLLOWING_constraint_iterator_IN_constraint_body_1564 ) constraint_iterator257 = constraint_iterator @state.following.pop @adaptor.add_child( root_0, constraint_iterator257.tree ) when 4 # at line 535:6: constraint_class_quantification @state.following.push( TOKENS_FOLLOWING_constraint_class_quantification_IN_constraint_body_1571 ) constraint_class_quantification258 = constraint_class_quantification @state.following.pop @adaptor.add_child( root_0, constraint_class_quantification258.tree ) end # at file 537:3: ( NL )+ match_count_103 = 0 while true alt_103 = 2 look_103_0 = @input.peek( 1 ) if ( look_103_0 == NL ) alt_103 = 1 end case alt_103 when 1 # at line 537:3: NL __NL259__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_body_1580 ) tree_for_NL259 = @adaptor.create_with_payload( __NL259__ ) @adaptor.add_child( root_0, tree_for_NL259 ) else match_count_103 > 0 and break eee = EarlyExit(103) raise eee end match_count_103 += 1 end else break # out of loop for decision 104 end end # loop for decision 104 # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 33 ) end return return_value end ConstraintNamespaceReturnValue = define_return_scope # # parser rule constraint_namespace # # (in SfpLang.g) # 540:1: constraint_namespace : path ( NL )* '{' ( NL )* ( constraint_statement ( NL )+ )* '}' ; # def constraint_namespace # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 34 ) return_value = ConstraintNamespaceReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __NL261__ = nil char_literal262 = nil __NL263__ = nil __NL265__ = nil char_literal266 = nil path260 = nil constraint_statement264 = nil tree_for_NL261 = nil tree_for_char_literal262 = nil tree_for_NL263 = nil tree_for_NL265 = nil tree_for_char_literal266 = nil begin root_0 = @adaptor.create_flat_list # at line 541:4: path ( NL )* '{' ( NL )* ( constraint_statement ( NL )+ )* '}' @state.following.push( TOKENS_FOLLOWING_path_IN_constraint_namespace_1594 ) path260 = path @state.following.pop @adaptor.add_child( root_0, path260.tree ) # at line 541:9: ( NL )* while true # decision 105 alt_105 = 2 look_105_0 = @input.peek( 1 ) if ( look_105_0 == NL ) alt_105 = 1 end case alt_105 when 1 # at line 541:9: NL __NL261__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_namespace_1596 ) tree_for_NL261 = @adaptor.create_with_payload( __NL261__ ) @adaptor.add_child( root_0, tree_for_NL261 ) else break # out of loop for decision 105 end end # loop for decision 105 char_literal262 = match( T__84, TOKENS_FOLLOWING_T__84_IN_constraint_namespace_1599 ) tree_for_char_literal262 = @adaptor.create_with_payload( char_literal262 ) @adaptor.add_child( root_0, tree_for_char_literal262 ) # at line 541:17: ( NL )* while true # decision 106 alt_106 = 2 look_106_0 = @input.peek( 1 ) if ( look_106_0 == NL ) alt_106 = 1 end case alt_106 when 1 # at line 541:17: NL __NL263__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_namespace_1601 ) tree_for_NL263 = @adaptor.create_with_payload( __NL263__ ) @adaptor.add_child( root_0, tree_for_NL263 ) else break # out of loop for decision 106 end end # loop for decision 106 # at line 541:21: ( constraint_statement ( NL )+ )* while true # decision 108 alt_108 = 2 look_108_0 = @input.peek( 1 ) if ( look_108_0 == ID || look_108_0 == T__62 || look_108_0 == T__72 || look_108_0 == T__82 ) alt_108 = 1 end case alt_108 when 1 # at line 541:22: constraint_statement ( NL )+ @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_constraint_namespace_1605 ) constraint_statement264 = constraint_statement @state.following.pop @adaptor.add_child( root_0, constraint_statement264.tree ) # --> action key = self.to_ref(( path260 && @input.to_s( path260.start, path260.stop ) ) + '.' + ( constraint_statement264.nil? ? nil : constraint_statement264.key )[2,( constraint_statement264.nil? ? nil : constraint_statement264.key ).length]) @now[key] = ( constraint_statement264.nil? ? nil : constraint_statement264.val ) # <-- action # at file 546:3: ( NL )+ match_count_107 = 0 while true alt_107 = 2 look_107_0 = @input.peek( 1 ) if ( look_107_0 == NL ) alt_107 = 1 end case alt_107 when 1 # at line 546:3: NL __NL265__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_namespace_1613 ) tree_for_NL265 = @adaptor.create_with_payload( __NL265__ ) @adaptor.add_child( root_0, tree_for_NL265 ) else match_count_107 > 0 and break eee = EarlyExit(107) raise eee end match_count_107 += 1 end else break # out of loop for decision 108 end end # loop for decision 108 char_literal266 = match( T__85, TOKENS_FOLLOWING_T__85_IN_constraint_namespace_1618 ) tree_for_char_literal266 = @adaptor.create_with_payload( char_literal266 ) @adaptor.add_child( root_0, tree_for_char_literal266 ) # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 34 ) end return return_value end ConstraintIteratorReturnValue = define_return_scope # # parser rule constraint_iterator # # (in SfpLang.g) # 549:1: constraint_iterator : 'foreach' '(' path 'as' ID ')' ( NL )* '{' ( NL )+ ( constraint_statement ( NL )+ )* '}' ; # def constraint_iterator # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 35 ) return_value = ConstraintIteratorReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal267 = nil char_literal268 = nil string_literal270 = nil __ID271__ = nil char_literal272 = nil __NL273__ = nil char_literal274 = nil __NL275__ = nil __NL277__ = nil char_literal278 = nil path269 = nil constraint_statement276 = nil tree_for_string_literal267 = nil tree_for_char_literal268 = nil tree_for_string_literal270 = nil tree_for_ID271 = nil tree_for_char_literal272 = nil tree_for_NL273 = nil tree_for_char_literal274 = nil tree_for_NL275 = nil tree_for_NL277 = nil tree_for_char_literal278 = nil begin root_0 = @adaptor.create_flat_list # at line 550:4: 'foreach' '(' path 'as' ID ')' ( NL )* '{' ( NL )+ ( constraint_statement ( NL )+ )* '}' string_literal267 = match( T__57, TOKENS_FOLLOWING_T__57_IN_constraint_iterator_1629 ) tree_for_string_literal267 = @adaptor.create_with_payload( string_literal267 ) @adaptor.add_child( root_0, tree_for_string_literal267 ) char_literal268 = match( T__19, TOKENS_FOLLOWING_T__19_IN_constraint_iterator_1631 ) tree_for_char_literal268 = @adaptor.create_with_payload( char_literal268 ) @adaptor.add_child( root_0, tree_for_char_literal268 ) @state.following.push( TOKENS_FOLLOWING_path_IN_constraint_iterator_1633 ) path269 = path @state.following.pop @adaptor.add_child( root_0, path269.tree ) string_literal270 = match( T__42, TOKENS_FOLLOWING_T__42_IN_constraint_iterator_1635 ) tree_for_string_literal270 = @adaptor.create_with_payload( string_literal270 ) @adaptor.add_child( root_0, tree_for_string_literal270 ) __ID271__ = match( ID, TOKENS_FOLLOWING_ID_IN_constraint_iterator_1637 ) tree_for_ID271 = @adaptor.create_with_payload( __ID271__ ) @adaptor.add_child( root_0, tree_for_ID271 ) char_literal272 = match( T__20, TOKENS_FOLLOWING_T__20_IN_constraint_iterator_1639 ) tree_for_char_literal272 = @adaptor.create_with_payload( char_literal272 ) @adaptor.add_child( root_0, tree_for_char_literal272 ) # at line 550:35: ( NL )* while true # decision 109 alt_109 = 2 look_109_0 = @input.peek( 1 ) if ( look_109_0 == NL ) alt_109 = 1 end case alt_109 when 1 # at line 550:35: NL __NL273__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_iterator_1641 ) tree_for_NL273 = @adaptor.create_with_payload( __NL273__ ) @adaptor.add_child( root_0, tree_for_NL273 ) else break # out of loop for decision 109 end end # loop for decision 109 char_literal274 = match( T__84, TOKENS_FOLLOWING_T__84_IN_constraint_iterator_1644 ) tree_for_char_literal274 = @adaptor.create_with_payload( char_literal274 ) @adaptor.add_child( root_0, tree_for_char_literal274 ) # at file 550:43: ( NL )+ match_count_110 = 0 while true alt_110 = 2 look_110_0 = @input.peek( 1 ) if ( look_110_0 == NL ) alt_110 = 1 end case alt_110 when 1 # at line 550:43: NL __NL275__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_iterator_1646 ) tree_for_NL275 = @adaptor.create_with_payload( __NL275__ ) @adaptor.add_child( root_0, tree_for_NL275 ) else match_count_110 > 0 and break eee = EarlyExit(110) raise eee end match_count_110 += 1 end # --> action id = self.next_id.to_s @now[id] = self.create_constraint(id, 'iterator') @now[id]['_value'] = '$.' + ( path269 && @input.to_s( path269.start, path269.stop ) ) @now[id]['_variable'] = __ID271__.text @now = @now[id] id = '_template' @now[id] = self.create_constraint(id, 'and') @now = @now[id] # <-- action # at line 562:3: ( constraint_statement ( NL )+ )* while true # decision 112 alt_112 = 2 look_112_0 = @input.peek( 1 ) if ( look_112_0 == ID || look_112_0 == T__62 || look_112_0 == T__72 || look_112_0 == T__82 ) alt_112 = 1 end case alt_112 when 1 # at line 562:4: constraint_statement ( NL )+ @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_constraint_iterator_1656 ) constraint_statement276 = constraint_statement @state.following.pop @adaptor.add_child( root_0, constraint_statement276.tree ) # --> action @now[( constraint_statement276.nil? ? nil : constraint_statement276.key )] = ( constraint_statement276.nil? ? nil : constraint_statement276.val ) # <-- action # at file 566:3: ( NL )+ match_count_111 = 0 while true alt_111 = 2 look_111_0 = @input.peek( 1 ) if ( look_111_0 == NL ) alt_111 = 1 end case alt_111 when 1 # at line 566:3: NL __NL277__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_iterator_1664 ) tree_for_NL277 = @adaptor.create_with_payload( __NL277__ ) @adaptor.add_child( root_0, tree_for_NL277 ) else match_count_111 > 0 and break eee = EarlyExit(111) raise eee end match_count_111 += 1 end else break # out of loop for decision 112 end end # loop for decision 112 char_literal278 = match( T__85, TOKENS_FOLLOWING_T__85_IN_constraint_iterator_1671 ) tree_for_char_literal278 = @adaptor.create_with_payload( char_literal278 ) @adaptor.add_child( root_0, tree_for_char_literal278 ) # --> action self.goto_parent() self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 35 ) end return return_value end QuantificationKeywordReturnValue = define_return_scope # # parser rule quantification_keyword # # (in SfpLang.g) # 574:1: quantification_keyword : ( 'forall' | 'exist' | 'forsome' ); # def quantification_keyword # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 36 ) return_value = QuantificationKeywordReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil set279 = nil tree_for_set279 = nil begin root_0 = @adaptor.create_flat_list # at line set279 = @input.look if @input.peek(1) == T__53 || @input.peek(1) == T__56 || @input.peek(1) == T__58 @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set279 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 36 ) end return return_value end ConstraintClassQuantificationReturnValue = define_return_scope # # parser rule constraint_class_quantification # # (in SfpLang.g) # 580:1: constraint_class_quantification : quantification_keyword '(' path 'as' ID ')' ( ( binary_comp | '=' ) NUMBER )? ( NL )* '{' ( NL )+ ( constraint_statement ( NL )+ | constraint_different ( NL )+ | constraint_iterator ( NL )+ )* '}' ; # def constraint_class_quantification # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 37 ) return_value = ConstraintClassQuantificationReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil char_literal281 = nil string_literal283 = nil __ID284__ = nil char_literal285 = nil char_literal287 = nil __NUMBER288__ = nil __NL289__ = nil char_literal290 = nil __NL291__ = nil __NL293__ = nil __NL295__ = nil __NL297__ = nil char_literal298 = nil quantification_keyword280 = nil path282 = nil binary_comp286 = nil constraint_statement292 = nil constraint_different294 = nil constraint_iterator296 = nil tree_for_char_literal281 = nil tree_for_string_literal283 = nil tree_for_ID284 = nil tree_for_char_literal285 = nil tree_for_char_literal287 = nil tree_for_NUMBER288 = nil tree_for_NL289 = nil tree_for_char_literal290 = nil tree_for_NL291 = nil tree_for_NL293 = nil tree_for_NL295 = nil tree_for_NL297 = nil tree_for_char_literal298 = nil begin root_0 = @adaptor.create_flat_list # at line 581:4: quantification_keyword '(' path 'as' ID ')' ( ( binary_comp | '=' ) NUMBER )? ( NL )* '{' ( NL )+ ( constraint_statement ( NL )+ | constraint_different ( NL )+ | constraint_iterator ( NL )+ )* '}' @state.following.push( TOKENS_FOLLOWING_quantification_keyword_IN_constraint_class_quantification_1707 ) quantification_keyword280 = quantification_keyword @state.following.pop @adaptor.add_child( root_0, quantification_keyword280.tree ) char_literal281 = match( T__19, TOKENS_FOLLOWING_T__19_IN_constraint_class_quantification_1709 ) tree_for_char_literal281 = @adaptor.create_with_payload( char_literal281 ) @adaptor.add_child( root_0, tree_for_char_literal281 ) @state.following.push( TOKENS_FOLLOWING_path_IN_constraint_class_quantification_1711 ) path282 = path @state.following.pop @adaptor.add_child( root_0, path282.tree ) string_literal283 = match( T__42, TOKENS_FOLLOWING_T__42_IN_constraint_class_quantification_1713 ) tree_for_string_literal283 = @adaptor.create_with_payload( string_literal283 ) @adaptor.add_child( root_0, tree_for_string_literal283 ) __ID284__ = match( ID, TOKENS_FOLLOWING_ID_IN_constraint_class_quantification_1715 ) tree_for_ID284 = @adaptor.create_with_payload( __ID284__ ) @adaptor.add_child( root_0, tree_for_ID284 ) char_literal285 = match( T__20, TOKENS_FOLLOWING_T__20_IN_constraint_class_quantification_1717 ) tree_for_char_literal285 = @adaptor.create_with_payload( char_literal285 ) @adaptor.add_child( root_0, tree_for_char_literal285 ) # --> action id = self.next_id.to_s @now[id] = { '_parent' => @now, '_context' => 'constraint', '_type' => ( quantification_keyword280 && @input.to_s( quantification_keyword280.start, quantification_keyword280.stop ) ), '_self' => id, '_class' => ( path282 && @input.to_s( path282.start, path282.stop ) ), '_variable' => __ID284__.text } @now = @now[id] id = '_template' @now[id] = self.create_constraint(id, 'and') @now = @now[id] # <-- action # at line 597:3: ( ( binary_comp | '=' ) NUMBER )? alt_114 = 2 look_114_0 = @input.peek( 1 ) if ( look_114_0.between?( T__29, T__33 ) ) alt_114 = 1 end case alt_114 when 1 # at line 597:5: ( binary_comp | '=' ) NUMBER # at line 597:5: ( binary_comp | '=' ) alt_113 = 2 look_113_0 = @input.peek( 1 ) if ( look_113_0.between?( T__29, T__30 ) || look_113_0.between?( T__32, T__33 ) ) alt_113 = 1 elsif ( look_113_0 == T__31 ) alt_113 = 2 else raise NoViableAlternative( "", 113, 0 ) end case alt_113 when 1 # at line 597:7: binary_comp @state.following.push( TOKENS_FOLLOWING_binary_comp_IN_constraint_class_quantification_1729 ) binary_comp286 = binary_comp @state.following.pop @adaptor.add_child( root_0, binary_comp286.tree ) # --> action @now['_count_operator'] = ( binary_comp286 && @input.to_s( binary_comp286.start, binary_comp286.stop ) ) # <-- action when 2 # at line 599:6: '=' char_literal287 = match( T__31, TOKENS_FOLLOWING_T__31_IN_constraint_class_quantification_1742 ) tree_for_char_literal287 = @adaptor.create_with_payload( char_literal287 ) @adaptor.add_child( root_0, tree_for_char_literal287 ) # --> action @now['_count_operator'] = '=' # <-- action end __NUMBER288__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_constraint_class_quantification_1758 ) tree_for_NUMBER288 = @adaptor.create_with_payload( __NUMBER288__ ) @adaptor.add_child( root_0, tree_for_NUMBER288 ) # --> action @now['_count_value'] = __NUMBER288__.text.to_i # <-- action end # at line 605:3: ( NL )* while true # decision 115 alt_115 = 2 look_115_0 = @input.peek( 1 ) if ( look_115_0 == NL ) alt_115 = 1 end case alt_115 when 1 # at line 605:3: NL __NL289__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1772 ) tree_for_NL289 = @adaptor.create_with_payload( __NL289__ ) @adaptor.add_child( root_0, tree_for_NL289 ) else break # out of loop for decision 115 end end # loop for decision 115 char_literal290 = match( T__84, TOKENS_FOLLOWING_T__84_IN_constraint_class_quantification_1775 ) tree_for_char_literal290 = @adaptor.create_with_payload( char_literal290 ) @adaptor.add_child( root_0, tree_for_char_literal290 ) # at file 605:11: ( NL )+ match_count_116 = 0 while true alt_116 = 2 look_116_0 = @input.peek( 1 ) if ( look_116_0 == NL ) alt_116 = 1 end case alt_116 when 1 # at line 605:11: NL __NL291__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1777 ) tree_for_NL291 = @adaptor.create_with_payload( __NL291__ ) @adaptor.add_child( root_0, tree_for_NL291 ) else match_count_116 > 0 and break eee = EarlyExit(116) raise eee end match_count_116 += 1 end # at line 606:3: ( constraint_statement ( NL )+ | constraint_different ( NL )+ | constraint_iterator ( NL )+ )* while true # decision 120 alt_120 = 4 case look_120 = @input.peek( 1 ) when ID, T__62, T__72, T__82 then alt_120 = 1 when T__28 then alt_120 = 2 when T__57 then alt_120 = 3 end case alt_120 when 1 # at line 606:5: constraint_statement ( NL )+ @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_constraint_class_quantification_1784 ) constraint_statement292 = constraint_statement @state.following.pop @adaptor.add_child( root_0, constraint_statement292.tree ) # --> action @now[( constraint_statement292.nil? ? nil : constraint_statement292.key )] = ( constraint_statement292.nil? ? nil : constraint_statement292.val ) # <-- action # at file 608:4: ( NL )+ match_count_117 = 0 while true alt_117 = 2 look_117_0 = @input.peek( 1 ) if ( look_117_0 == NL ) alt_117 = 1 end case alt_117 when 1 # at line 608:4: NL __NL293__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1794 ) tree_for_NL293 = @adaptor.create_with_payload( __NL293__ ) @adaptor.add_child( root_0, tree_for_NL293 ) else match_count_117 > 0 and break eee = EarlyExit(117) raise eee end match_count_117 += 1 end when 2 # at line 609:5: constraint_different ( NL )+ @state.following.push( TOKENS_FOLLOWING_constraint_different_IN_constraint_class_quantification_1801 ) constraint_different294 = constraint_different @state.following.pop @adaptor.add_child( root_0, constraint_different294.tree ) # at file 609:26: ( NL )+ match_count_118 = 0 while true alt_118 = 2 look_118_0 = @input.peek( 1 ) if ( look_118_0 == NL ) alt_118 = 1 end case alt_118 when 1 # at line 609:26: NL __NL295__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1803 ) tree_for_NL295 = @adaptor.create_with_payload( __NL295__ ) @adaptor.add_child( root_0, tree_for_NL295 ) else match_count_118 > 0 and break eee = EarlyExit(118) raise eee end match_count_118 += 1 end when 3 # at line 610:5: constraint_iterator ( NL )+ @state.following.push( TOKENS_FOLLOWING_constraint_iterator_IN_constraint_class_quantification_1810 ) constraint_iterator296 = constraint_iterator @state.following.pop @adaptor.add_child( root_0, constraint_iterator296.tree ) # at file 610:25: ( NL )+ match_count_119 = 0 while true alt_119 = 2 look_119_0 = @input.peek( 1 ) if ( look_119_0 == NL ) alt_119 = 1 end case alt_119 when 1 # at line 610:25: NL __NL297__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1812 ) tree_for_NL297 = @adaptor.create_with_payload( __NL297__ ) @adaptor.add_child( root_0, tree_for_NL297 ) else match_count_119 > 0 and break eee = EarlyExit(119) raise eee end match_count_119 += 1 end else break # out of loop for decision 120 end end # loop for decision 120 char_literal298 = match( T__85, TOKENS_FOLLOWING_T__85_IN_constraint_class_quantification_1820 ) tree_for_char_literal298 = @adaptor.create_with_payload( char_literal298 ) @adaptor.add_child( root_0, tree_for_char_literal298 ) # --> action self.goto_parent() # <-- action # --> action self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 37 ) end return return_value end ConstraintDifferentReturnValue = define_return_scope # # parser rule constraint_different # # (in SfpLang.g) # 616:1: constraint_different : ':different' '(' path ')' ; # def constraint_different # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 38 ) return_value = ConstraintDifferentReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal299 = nil char_literal300 = nil char_literal302 = nil path301 = nil tree_for_string_literal299 = nil tree_for_char_literal300 = nil tree_for_char_literal302 = nil begin root_0 = @adaptor.create_flat_list # at line 617:4: ':different' '(' path ')' string_literal299 = match( T__28, TOKENS_FOLLOWING_T__28_IN_constraint_different_1839 ) tree_for_string_literal299 = @adaptor.create_with_payload( string_literal299 ) @adaptor.add_child( root_0, tree_for_string_literal299 ) char_literal300 = match( T__19, TOKENS_FOLLOWING_T__19_IN_constraint_different_1841 ) tree_for_char_literal300 = @adaptor.create_with_payload( char_literal300 ) @adaptor.add_child( root_0, tree_for_char_literal300 ) @state.following.push( TOKENS_FOLLOWING_path_IN_constraint_different_1843 ) path301 = path @state.following.pop @adaptor.add_child( root_0, path301.tree ) char_literal302 = match( T__20, TOKENS_FOLLOWING_T__20_IN_constraint_different_1845 ) tree_for_char_literal302 = @adaptor.create_with_payload( char_literal302 ) @adaptor.add_child( root_0, tree_for_char_literal302 ) # --> action id = self.next_id.to_s @now[id] = { '_parent' => @now, '_context' => 'constraint', '_type' => 'different', '_self' => id, '_path' => ( path301 && @input.to_s( path301.start, path301.stop ) ) } # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 38 ) end return return_value end ConstraintStatementReturnValue = define_return_scope :key, :val # # parser rule constraint_statement # # (in SfpLang.g) # 629:1: constraint_statement returns [key, val] : ( reference | 'not' reference | reference equals_op value | reference equals_op NULL | reference not_equals_op value | reference not_equals_op NULL | conditional_constraint | reference ( 'is' )? 'in' set_value | reference ( 'isnot' | 'isnt' | 'not' ) 'in' set_value | reference 'has' value | reference binary_comp comp_value | total_constraint ); # def constraint_statement # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 39 ) return_value = ConstraintStatementReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal304 = nil __NULL311__ = nil __NULL317__ = nil string_literal320 = nil string_literal321 = nil set324 = nil string_literal325 = nil string_literal328 = nil reference303 = nil reference305 = nil reference306 = nil equals_op307 = nil value308 = nil reference309 = nil equals_op310 = nil reference312 = nil not_equals_op313 = nil value314 = nil reference315 = nil not_equals_op316 = nil conditional_constraint318 = nil reference319 = nil set_value322 = nil reference323 = nil set_value326 = nil reference327 = nil value329 = nil reference330 = nil binary_comp331 = nil comp_value332 = nil total_constraint333 = nil tree_for_string_literal304 = nil tree_for_NULL311 = nil tree_for_NULL317 = nil tree_for_string_literal320 = nil tree_for_string_literal321 = nil tree_for_set324 = nil tree_for_string_literal325 = nil tree_for_string_literal328 = nil begin # at line 630:2: ( reference | 'not' reference | reference equals_op value | reference equals_op NULL | reference not_equals_op value | reference not_equals_op NULL | conditional_constraint | reference ( 'is' )? 'in' set_value | reference ( 'isnot' | 'isnt' | 'not' ) 'in' set_value | reference 'has' value | reference binary_comp comp_value | total_constraint ) alt_122 = 12 alt_122 = @dfa122.predict( @input ) case alt_122 when 1 root_0 = @adaptor.create_flat_list # at line 630:4: reference @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1864 ) reference303 = reference @state.following.pop @adaptor.add_child( root_0, reference303.tree ) # --> action return_value.key = ( reference303.nil? ? nil : reference303.val ) return_value.val = { '_context' => 'constraint', '_type' => 'equals', '_value' => true } # <-- action when 2 root_0 = @adaptor.create_flat_list # at line 635:4: 'not' reference string_literal304 = match( T__72, TOKENS_FOLLOWING_T__72_IN_constraint_statement_1873 ) tree_for_string_literal304 = @adaptor.create_with_payload( string_literal304 ) @adaptor.add_child( root_0, tree_for_string_literal304 ) @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1875 ) reference305 = reference @state.following.pop @adaptor.add_child( root_0, reference305.tree ) # --> action return_value.key = ( reference305.nil? ? nil : reference305.val ) return_value.val = { '_context' => 'constraint', '_type' => 'equals', '_value' => false } # <-- action when 3 root_0 = @adaptor.create_flat_list # at line 640:4: reference equals_op value @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1884 ) reference306 = reference @state.following.pop @adaptor.add_child( root_0, reference306.tree ) @state.following.push( TOKENS_FOLLOWING_equals_op_IN_constraint_statement_1886 ) equals_op307 = equals_op @state.following.pop @adaptor.add_child( root_0, equals_op307.tree ) @state.following.push( TOKENS_FOLLOWING_value_IN_constraint_statement_1888 ) value308 = value @state.following.pop @adaptor.add_child( root_0, value308.tree ) # --> action return_value.key = ( reference306.nil? ? nil : reference306.val ) return_value.val = { '_context' => 'constraint', '_type' => 'equals', '_value' => ( value308.nil? ? nil : value308.val ) } # <-- action when 4 root_0 = @adaptor.create_flat_list # at line 645:4: reference equals_op NULL @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1897 ) reference309 = reference @state.following.pop @adaptor.add_child( root_0, reference309.tree ) @state.following.push( TOKENS_FOLLOWING_equals_op_IN_constraint_statement_1899 ) equals_op310 = equals_op @state.following.pop @adaptor.add_child( root_0, equals_op310.tree ) __NULL311__ = match( NULL, TOKENS_FOLLOWING_NULL_IN_constraint_statement_1901 ) tree_for_NULL311 = @adaptor.create_with_payload( __NULL311__ ) @adaptor.add_child( root_0, tree_for_NULL311 ) # --> action return_value.key = ( reference309.nil? ? nil : reference309.val ) return_value.val = { '_context' => 'constraint', '_type' => 'equals', '_value' => self.null_value } # <-- action when 5 root_0 = @adaptor.create_flat_list # at line 650:4: reference not_equals_op value @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1910 ) reference312 = reference @state.following.pop @adaptor.add_child( root_0, reference312.tree ) @state.following.push( TOKENS_FOLLOWING_not_equals_op_IN_constraint_statement_1912 ) not_equals_op313 = not_equals_op @state.following.pop @adaptor.add_child( root_0, not_equals_op313.tree ) @state.following.push( TOKENS_FOLLOWING_value_IN_constraint_statement_1914 ) value314 = value @state.following.pop @adaptor.add_child( root_0, value314.tree ) # --> action return_value.key = ( reference312.nil? ? nil : reference312.val ) return_value.val = { '_context' => 'constraint', '_type' => 'not-equals', '_value' => ( value314.nil? ? nil : value314.val ) } # <-- action when 6 root_0 = @adaptor.create_flat_list # at line 655:4: reference not_equals_op NULL @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1923 ) reference315 = reference @state.following.pop @adaptor.add_child( root_0, reference315.tree ) @state.following.push( TOKENS_FOLLOWING_not_equals_op_IN_constraint_statement_1925 ) not_equals_op316 = not_equals_op @state.following.pop @adaptor.add_child( root_0, not_equals_op316.tree ) __NULL317__ = match( NULL, TOKENS_FOLLOWING_NULL_IN_constraint_statement_1927 ) tree_for_NULL317 = @adaptor.create_with_payload( __NULL317__ ) @adaptor.add_child( root_0, tree_for_NULL317 ) # --> action return_value.key = ( reference315.nil? ? nil : reference315.val ) return_value.val = { '_context' => 'constraint', '_type' => 'not-equals', '_value' => self.null_value } # <-- action when 7 root_0 = @adaptor.create_flat_list # at line 660:4: conditional_constraint @state.following.push( TOKENS_FOLLOWING_conditional_constraint_IN_constraint_statement_1936 ) conditional_constraint318 = conditional_constraint @state.following.pop @adaptor.add_child( root_0, conditional_constraint318.tree ) # --> action return_value.key = ( conditional_constraint318.nil? ? nil : conditional_constraint318.key ) return_value.val = ( conditional_constraint318.nil? ? nil : conditional_constraint318.val ) # <-- action when 8 root_0 = @adaptor.create_flat_list # at line 665:4: reference ( 'is' )? 'in' set_value @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1945 ) reference319 = reference @state.following.pop @adaptor.add_child( root_0, reference319.tree ) # at line 665:14: ( 'is' )? alt_121 = 2 look_121_0 = @input.peek( 1 ) if ( look_121_0 == T__65 ) alt_121 = 1 end case alt_121 when 1 # at line 665:14: 'is' string_literal320 = match( T__65, TOKENS_FOLLOWING_T__65_IN_constraint_statement_1947 ) tree_for_string_literal320 = @adaptor.create_with_payload( string_literal320 ) @adaptor.add_child( root_0, tree_for_string_literal320 ) end string_literal321 = match( T__63, TOKENS_FOLLOWING_T__63_IN_constraint_statement_1950 ) tree_for_string_literal321 = @adaptor.create_with_payload( string_literal321 ) @adaptor.add_child( root_0, tree_for_string_literal321 ) @state.following.push( TOKENS_FOLLOWING_set_value_IN_constraint_statement_1952 ) set_value322 = set_value @state.following.pop @adaptor.add_child( root_0, set_value322.tree ) # --> action c_or = { '_context' => 'constraint', '_type' => 'or', '_parent' => @now } ( set_value322.nil? ? nil : set_value322.val ).each { |v| id = self.next_id.to_s item = { '_context' => 'constraint', '_type' => 'and', '_parent' => c_or } item[( reference319.nil? ? nil : reference319.val )] = { '_context' => 'constraint', '_type' => 'equals', '_value' => v } c_or[id] = item } return_value.key = self.next_id.to_s return_value.val = c_or # <-- action when 9 root_0 = @adaptor.create_flat_list # at line 677:4: reference ( 'isnot' | 'isnt' | 'not' ) 'in' set_value @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1961 ) reference323 = reference @state.following.pop @adaptor.add_child( root_0, reference323.tree ) set324 = @input.look if @input.peek( 1 ).between?( T__67, T__68 ) || @input.peek(1) == T__72 @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set324 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end string_literal325 = match( T__63, TOKENS_FOLLOWING_T__63_IN_constraint_statement_1971 ) tree_for_string_literal325 = @adaptor.create_with_payload( string_literal325 ) @adaptor.add_child( root_0, tree_for_string_literal325 ) @state.following.push( TOKENS_FOLLOWING_set_value_IN_constraint_statement_1973 ) set_value326 = set_value @state.following.pop @adaptor.add_child( root_0, set_value326.tree ) # --> action c_and = { '_context'=>'constraint', '_type'=>'and', '_parent'=>@now } ( set_value326.nil? ? nil : set_value326.val ).each { |v| id = self.next_id.to_s item = { '_context'=>'constraint', '_type'=>'and'} item[( reference323.nil? ? nil : reference323.val )] = { '_context'=>'constraint', '_type'=>'not-equals', '_value'=>v } c_and[id] = item } return_value.key = self.next_id.to_s return_value.val = c_and #return_value.key = ( reference323.nil? ? nil : reference323.val ) #return_value.val = { '_context' => 'constraint', '_type' => 'not-in', '_value' => ( set_value326.nil? ? nil : set_value326.val ) } # <-- action when 10 root_0 = @adaptor.create_flat_list # at line 692:4: reference 'has' value @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1982 ) reference327 = reference @state.following.pop @adaptor.add_child( root_0, reference327.tree ) string_literal328 = match( T__61, TOKENS_FOLLOWING_T__61_IN_constraint_statement_1984 ) tree_for_string_literal328 = @adaptor.create_with_payload( string_literal328 ) @adaptor.add_child( root_0, tree_for_string_literal328 ) @state.following.push( TOKENS_FOLLOWING_value_IN_constraint_statement_1986 ) value329 = value @state.following.pop @adaptor.add_child( root_0, value329.tree ) # --> action c_has = { '_context' => 'constraint', '_type' => 'has', '_parent' => @now, '_owner' => ( reference327.nil? ? nil : reference327.val ), '_value' => ( value329.nil? ? nil : value329.val ) } # <-- action when 11 root_0 = @adaptor.create_flat_list # at line 701:4: reference binary_comp comp_value @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1995 ) reference330 = reference @state.following.pop @adaptor.add_child( root_0, reference330.tree ) @state.following.push( TOKENS_FOLLOWING_binary_comp_IN_constraint_statement_1997 ) binary_comp331 = binary_comp @state.following.pop @adaptor.add_child( root_0, binary_comp331.tree ) @state.following.push( TOKENS_FOLLOWING_comp_value_IN_constraint_statement_1999 ) comp_value332 = comp_value @state.following.pop @adaptor.add_child( root_0, comp_value332.tree ) # --> action return_value.key = ( reference330.nil? ? nil : reference330.val ) return_value.val = { '_context' => 'constraint', '_type' => ( binary_comp331 && @input.to_s( binary_comp331.start, binary_comp331.stop ) ), '_value' => ( comp_value332.nil? ? nil : comp_value332.val ) } # <-- action when 12 root_0 = @adaptor.create_flat_list # at line 706:4: total_constraint @state.following.push( TOKENS_FOLLOWING_total_constraint_IN_constraint_statement_2008 ) total_constraint333 = total_constraint @state.following.pop @adaptor.add_child( root_0, total_constraint333.tree ) end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 39 ) end return return_value end TotalConstraintReturnValue = define_return_scope # # parser rule total_constraint # # (in SfpLang.g) # 709:1: total_constraint : 'total(' total_statement ')' binary_comp NUMBER ; # def total_constraint # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 40 ) return_value = TotalConstraintReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal334 = nil char_literal336 = nil __NUMBER338__ = nil total_statement335 = nil binary_comp337 = nil tree_for_string_literal334 = nil tree_for_char_literal336 = nil tree_for_NUMBER338 = nil begin root_0 = @adaptor.create_flat_list # at line 710:4: 'total(' total_statement ')' binary_comp NUMBER string_literal334 = match( T__82, TOKENS_FOLLOWING_T__82_IN_total_constraint_2019 ) tree_for_string_literal334 = @adaptor.create_with_payload( string_literal334 ) @adaptor.add_child( root_0, tree_for_string_literal334 ) @state.following.push( TOKENS_FOLLOWING_total_statement_IN_total_constraint_2021 ) total_statement335 = total_statement @state.following.pop @adaptor.add_child( root_0, total_statement335.tree ) char_literal336 = match( T__20, TOKENS_FOLLOWING_T__20_IN_total_constraint_2023 ) tree_for_char_literal336 = @adaptor.create_with_payload( char_literal336 ) @adaptor.add_child( root_0, tree_for_char_literal336 ) @state.following.push( TOKENS_FOLLOWING_binary_comp_IN_total_constraint_2025 ) binary_comp337 = binary_comp @state.following.pop @adaptor.add_child( root_0, binary_comp337.tree ) __NUMBER338__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_total_constraint_2027 ) tree_for_NUMBER338 = @adaptor.create_with_payload( __NUMBER338__ ) @adaptor.add_child( root_0, tree_for_NUMBER338 ) # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 40 ) end return return_value end TotalStatementReturnValue = define_return_scope # # parser rule total_statement # # (in SfpLang.g) # 713:1: total_statement : reference equals_op value ; # def total_statement # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 41 ) return_value = TotalStatementReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil reference339 = nil equals_op340 = nil value341 = nil begin root_0 = @adaptor.create_flat_list # at line 714:4: reference equals_op value @state.following.push( TOKENS_FOLLOWING_reference_IN_total_statement_2038 ) reference339 = reference @state.following.pop @adaptor.add_child( root_0, reference339.tree ) @state.following.push( TOKENS_FOLLOWING_equals_op_IN_total_statement_2040 ) equals_op340 = equals_op @state.following.pop @adaptor.add_child( root_0, equals_op340.tree ) @state.following.push( TOKENS_FOLLOWING_value_IN_total_statement_2042 ) value341 = value @state.following.pop @adaptor.add_child( root_0, value341.tree ) # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 41 ) end return return_value end CompValueReturnValue = define_return_scope :val # # parser rule comp_value # # (in SfpLang.g) # 717:1: comp_value returns [val] : ( NUMBER | reference ); # def comp_value # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 42 ) return_value = CompValueReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __NUMBER342__ = nil reference343 = nil tree_for_NUMBER342 = nil begin # at line 718:2: ( NUMBER | reference ) alt_123 = 2 look_123_0 = @input.peek( 1 ) if ( look_123_0 == NUMBER ) alt_123 = 1 elsif ( look_123_0 == ID ) alt_123 = 2 else raise NoViableAlternative( "", 123, 0 ) end case alt_123 when 1 root_0 = @adaptor.create_flat_list # at line 718:4: NUMBER __NUMBER342__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_comp_value_2057 ) tree_for_NUMBER342 = @adaptor.create_with_payload( __NUMBER342__ ) @adaptor.add_child( root_0, tree_for_NUMBER342 ) # --> action return_value.val = __NUMBER342__.text.to_i # <-- action when 2 root_0 = @adaptor.create_flat_list # at line 720:4: reference @state.following.push( TOKENS_FOLLOWING_reference_IN_comp_value_2066 ) reference343 = reference @state.following.pop @adaptor.add_child( root_0, reference343.tree ) # --> action return_value.val = ( reference343.nil? ? nil : reference343.val ) # <-- action end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 42 ) end return return_value end ConditionalConstraintReturnValue = define_return_scope :key, :val # # parser rule conditional_constraint # # (in SfpLang.g) # 724:1: conditional_constraint returns [key, val] : 'if' conditional_constraint_if_part conditional_constraint_then_part ; # def conditional_constraint # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 43 ) return_value = ConditionalConstraintReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal344 = nil conditional_constraint_if_part345 = nil conditional_constraint_then_part346 = nil tree_for_string_literal344 = nil begin root_0 = @adaptor.create_flat_list # at line 725:4: 'if' conditional_constraint_if_part conditional_constraint_then_part string_literal344 = match( T__62, TOKENS_FOLLOWING_T__62_IN_conditional_constraint_2085 ) tree_for_string_literal344 = @adaptor.create_with_payload( string_literal344 ) @adaptor.add_child( root_0, tree_for_string_literal344 ) # --> action return_value.key = id = self.next_id.to_s @now[id] = self.create_constraint(id, 'imply') @now = @now[id] # <-- action @state.following.push( TOKENS_FOLLOWING_conditional_constraint_if_part_IN_conditional_constraint_2093 ) conditional_constraint_if_part345 = conditional_constraint_if_part @state.following.pop @adaptor.add_child( root_0, conditional_constraint_if_part345.tree ) @state.following.push( TOKENS_FOLLOWING_conditional_constraint_then_part_IN_conditional_constraint_2097 ) conditional_constraint_then_part346 = conditional_constraint_then_part @state.following.pop @adaptor.add_child( root_0, conditional_constraint_then_part346.tree ) # --> action return_value.val = self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 43 ) end return return_value end ConditionalConstraintIfPartReturnValue = define_return_scope # # parser rule conditional_constraint_if_part # # (in SfpLang.g) # 736:1: conditional_constraint_if_part : ( constraint_statement ( NL )* | '{' ( NL )+ constraint_body '}' ( NL )* ); # def conditional_constraint_if_part # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 44 ) return_value = ConditionalConstraintIfPartReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __NL348__ = nil char_literal349 = nil __NL350__ = nil char_literal352 = nil __NL353__ = nil constraint_statement347 = nil constraint_body351 = nil tree_for_NL348 = nil tree_for_char_literal349 = nil tree_for_NL350 = nil tree_for_char_literal352 = nil tree_for_NL353 = nil begin # at line 737:2: ( constraint_statement ( NL )* | '{' ( NL )+ constraint_body '}' ( NL )* ) alt_127 = 2 look_127_0 = @input.peek( 1 ) if ( look_127_0 == ID || look_127_0 == T__62 || look_127_0 == T__72 || look_127_0 == T__82 ) alt_127 = 1 elsif ( look_127_0 == T__84 ) alt_127 = 2 else raise NoViableAlternative( "", 127, 0 ) end case alt_127 when 1 root_0 = @adaptor.create_flat_list # at line 737:4: constraint_statement ( NL )* @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_conditional_constraint_if_part_2112 ) constraint_statement347 = constraint_statement @state.following.pop @adaptor.add_child( root_0, constraint_statement347.tree ) # at line 737:25: ( NL )* while true # decision 124 alt_124 = 2 look_124_0 = @input.peek( 1 ) if ( look_124_0 == NL ) alt_124 = 1 end case alt_124 when 1 # at line 737:25: NL __NL348__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2114 ) tree_for_NL348 = @adaptor.create_with_payload( __NL348__ ) @adaptor.add_child( root_0, tree_for_NL348 ) else break # out of loop for decision 124 end end # loop for decision 124 # --> action id = self.next_id @now[id] = self.create_constraint(id, 'and') @now[id]['_subtype'] = 'premise' @now[id][( constraint_statement347.nil? ? nil : constraint_statement347.key )] = ( constraint_statement347.nil? ? nil : constraint_statement347.val ) # <-- action when 2 root_0 = @adaptor.create_flat_list # at line 744:4: '{' ( NL )+ constraint_body '}' ( NL )* char_literal349 = match( T__84, TOKENS_FOLLOWING_T__84_IN_conditional_constraint_if_part_2124 ) tree_for_char_literal349 = @adaptor.create_with_payload( char_literal349 ) @adaptor.add_child( root_0, tree_for_char_literal349 ) # --> action id = self.next_id @now[id] = self.create_constraint(id, 'and') @now[id]['_subtype'] = 'premise' @now = @now[id] # <-- action # at file 751:3: ( NL )+ match_count_125 = 0 while true alt_125 = 2 look_125_0 = @input.peek( 1 ) if ( look_125_0 == NL ) alt_125 = 1 end case alt_125 when 1 # at line 751:3: NL __NL350__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2132 ) tree_for_NL350 = @adaptor.create_with_payload( __NL350__ ) @adaptor.add_child( root_0, tree_for_NL350 ) else match_count_125 > 0 and break eee = EarlyExit(125) raise eee end match_count_125 += 1 end @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_conditional_constraint_if_part_2135 ) constraint_body351 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body351.tree ) char_literal352 = match( T__85, TOKENS_FOLLOWING_T__85_IN_conditional_constraint_if_part_2139 ) tree_for_char_literal352 = @adaptor.create_with_payload( char_literal352 ) @adaptor.add_child( root_0, tree_for_char_literal352 ) # at line 752:7: ( NL )* while true # decision 126 alt_126 = 2 look_126_0 = @input.peek( 1 ) if ( look_126_0 == NL ) alt_126 = 1 end case alt_126 when 1 # at line 752:7: NL __NL353__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2141 ) tree_for_NL353 = @adaptor.create_with_payload( __NL353__ ) @adaptor.add_child( root_0, tree_for_NL353 ) else break # out of loop for decision 126 end end # loop for decision 126 # --> action self.goto_parent() # <-- action end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 44 ) end return return_value end ConditionalConstraintThenPartReturnValue = define_return_scope # # parser rule conditional_constraint_then_part # # (in SfpLang.g) # 756:1: conditional_constraint_then_part : ( 'then' constraint_statement | 'then' '{' ( NL )+ constraint_body '}' ); # def conditional_constraint_then_part # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 45 ) return_value = ConditionalConstraintThenPartReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal354 = nil string_literal356 = nil char_literal357 = nil __NL358__ = nil char_literal360 = nil constraint_statement355 = nil constraint_body359 = nil tree_for_string_literal354 = nil tree_for_string_literal356 = nil tree_for_char_literal357 = nil tree_for_NL358 = nil tree_for_char_literal360 = nil begin # at line 757:2: ( 'then' constraint_statement | 'then' '{' ( NL )+ constraint_body '}' ) alt_129 = 2 look_129_0 = @input.peek( 1 ) if ( look_129_0 == T__81 ) look_129_1 = @input.peek( 2 ) if ( look_129_1 == ID || look_129_1 == T__62 || look_129_1 == T__72 || look_129_1 == T__82 ) alt_129 = 1 elsif ( look_129_1 == T__84 ) alt_129 = 2 else raise NoViableAlternative( "", 129, 1 ) end else raise NoViableAlternative( "", 129, 0 ) end case alt_129 when 1 root_0 = @adaptor.create_flat_list # at line 757:4: 'then' constraint_statement string_literal354 = match( T__81, TOKENS_FOLLOWING_T__81_IN_conditional_constraint_then_part_2157 ) tree_for_string_literal354 = @adaptor.create_with_payload( string_literal354 ) @adaptor.add_child( root_0, tree_for_string_literal354 ) @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_conditional_constraint_then_part_2159 ) constraint_statement355 = constraint_statement @state.following.pop @adaptor.add_child( root_0, constraint_statement355.tree ) # --> action id = self.next_id @now[id] = self.create_constraint(id, 'and') @now[id]['_subtype'] = 'conclusion' @now[id][( constraint_statement355.nil? ? nil : constraint_statement355.key )] = ( constraint_statement355.nil? ? nil : constraint_statement355.val ) # <-- action when 2 root_0 = @adaptor.create_flat_list # at line 764:4: 'then' '{' ( NL )+ constraint_body '}' string_literal356 = match( T__81, TOKENS_FOLLOWING_T__81_IN_conditional_constraint_then_part_2168 ) tree_for_string_literal356 = @adaptor.create_with_payload( string_literal356 ) @adaptor.add_child( root_0, tree_for_string_literal356 ) # --> action id = self.next_id @now[id] = self.create_constraint(id, 'and') @now[id]['_subtype'] = 'conclusion' @now = @now[id] # <-- action char_literal357 = match( T__84, TOKENS_FOLLOWING_T__84_IN_conditional_constraint_then_part_2176 ) tree_for_char_literal357 = @adaptor.create_with_payload( char_literal357 ) @adaptor.add_child( root_0, tree_for_char_literal357 ) # at file 771:7: ( NL )+ match_count_128 = 0 while true alt_128 = 2 look_128_0 = @input.peek( 1 ) if ( look_128_0 == NL ) alt_128 = 1 end case alt_128 when 1 # at line 771:7: NL __NL358__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditional_constraint_then_part_2178 ) tree_for_NL358 = @adaptor.create_with_payload( __NL358__ ) @adaptor.add_child( root_0, tree_for_NL358 ) else match_count_128 > 0 and break eee = EarlyExit(128) raise eee end match_count_128 += 1 end @state.following.push( TOKENS_FOLLOWING_constraint_body_IN_conditional_constraint_then_part_2181 ) constraint_body359 = constraint_body @state.following.pop @adaptor.add_child( root_0, constraint_body359.tree ) char_literal360 = match( T__85, TOKENS_FOLLOWING_T__85_IN_conditional_constraint_then_part_2183 ) tree_for_char_literal360 = @adaptor.create_with_payload( char_literal360 ) @adaptor.add_child( root_0, tree_for_char_literal360 ) # --> action self.goto_parent() # <-- action end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 45 ) end return return_value end EffectBodyReturnValue = define_return_scope # # parser rule effect_body # # (in SfpLang.g) # 775:1: effect_body : ( ( mutation | mutation_iterator ) ( NL )+ )* ; # def effect_body # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 46 ) return_value = EffectBodyReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __NL363__ = nil mutation361 = nil mutation_iterator362 = nil tree_for_NL363 = nil begin root_0 = @adaptor.create_flat_list # at line 776:4: ( ( mutation | mutation_iterator ) ( NL )+ )* # at line 776:4: ( ( mutation | mutation_iterator ) ( NL )+ )* while true # decision 132 alt_132 = 2 look_132_0 = @input.peek( 1 ) if ( look_132_0 == ID || look_132_0 == T__49 || look_132_0 == T__57 ) alt_132 = 1 end case alt_132 when 1 # at line 777:4: ( mutation | mutation_iterator ) ( NL )+ # at line 777:4: ( mutation | mutation_iterator ) alt_130 = 2 look_130_0 = @input.peek( 1 ) if ( look_130_0 == ID || look_130_0 == T__49 ) alt_130 = 1 elsif ( look_130_0 == T__57 ) alt_130 = 2 else raise NoViableAlternative( "", 130, 0 ) end case alt_130 when 1 # at line 777:6: mutation @state.following.push( TOKENS_FOLLOWING_mutation_IN_effect_body_2205 ) mutation361 = mutation @state.following.pop @adaptor.add_child( root_0, mutation361.tree ) # --> action @now[( mutation361.nil? ? nil : mutation361.key )] = ( mutation361.nil? ? nil : mutation361.val ) # <-- action when 2 # at line 779:6: mutation_iterator @state.following.push( TOKENS_FOLLOWING_mutation_iterator_IN_effect_body_2218 ) mutation_iterator362 = mutation_iterator @state.following.pop @adaptor.add_child( root_0, mutation_iterator362.tree ) end # at file 781:3: ( NL )+ match_count_131 = 0 while true alt_131 = 2 look_131_0 = @input.peek( 1 ) if ( look_131_0 == NL ) alt_131 = 1 end case alt_131 when 1 # at line 781:3: NL __NL363__ = match( NL, TOKENS_FOLLOWING_NL_IN_effect_body_2227 ) tree_for_NL363 = @adaptor.create_with_payload( __NL363__ ) @adaptor.add_child( root_0, tree_for_NL363 ) else match_count_131 > 0 and break eee = EarlyExit(131) raise eee end match_count_131 += 1 end else break # out of loop for decision 132 end end # loop for decision 132 # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 46 ) end return return_value end MutationIteratorReturnValue = define_return_scope # # parser rule mutation_iterator # # (in SfpLang.g) # 784:1: mutation_iterator : 'foreach' path 'as' ID ( NL )* '{' ( NL )+ ( mutation ( NL )+ )* '}' ; # def mutation_iterator # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 47 ) return_value = MutationIteratorReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal364 = nil string_literal366 = nil __ID367__ = nil __NL368__ = nil char_literal369 = nil __NL370__ = nil __NL372__ = nil char_literal373 = nil path365 = nil mutation371 = nil tree_for_string_literal364 = nil tree_for_string_literal366 = nil tree_for_ID367 = nil tree_for_NL368 = nil tree_for_char_literal369 = nil tree_for_NL370 = nil tree_for_NL372 = nil tree_for_char_literal373 = nil begin root_0 = @adaptor.create_flat_list # at line 785:4: 'foreach' path 'as' ID ( NL )* '{' ( NL )+ ( mutation ( NL )+ )* '}' string_literal364 = match( T__57, TOKENS_FOLLOWING_T__57_IN_mutation_iterator_2242 ) tree_for_string_literal364 = @adaptor.create_with_payload( string_literal364 ) @adaptor.add_child( root_0, tree_for_string_literal364 ) @state.following.push( TOKENS_FOLLOWING_path_IN_mutation_iterator_2244 ) path365 = path @state.following.pop @adaptor.add_child( root_0, path365.tree ) string_literal366 = match( T__42, TOKENS_FOLLOWING_T__42_IN_mutation_iterator_2246 ) tree_for_string_literal366 = @adaptor.create_with_payload( string_literal366 ) @adaptor.add_child( root_0, tree_for_string_literal366 ) __ID367__ = match( ID, TOKENS_FOLLOWING_ID_IN_mutation_iterator_2248 ) tree_for_ID367 = @adaptor.create_with_payload( __ID367__ ) @adaptor.add_child( root_0, tree_for_ID367 ) # at line 785:27: ( NL )* while true # decision 133 alt_133 = 2 look_133_0 = @input.peek( 1 ) if ( look_133_0 == NL ) alt_133 = 1 end case alt_133 when 1 # at line 785:27: NL __NL368__ = match( NL, TOKENS_FOLLOWING_NL_IN_mutation_iterator_2250 ) tree_for_NL368 = @adaptor.create_with_payload( __NL368__ ) @adaptor.add_child( root_0, tree_for_NL368 ) else break # out of loop for decision 133 end end # loop for decision 133 char_literal369 = match( T__84, TOKENS_FOLLOWING_T__84_IN_mutation_iterator_2253 ) tree_for_char_literal369 = @adaptor.create_with_payload( char_literal369 ) @adaptor.add_child( root_0, tree_for_char_literal369 ) # at file 785:35: ( NL )+ match_count_134 = 0 while true alt_134 = 2 look_134_0 = @input.peek( 1 ) if ( look_134_0 == NL ) alt_134 = 1 end case alt_134 when 1 # at line 785:35: NL __NL370__ = match( NL, TOKENS_FOLLOWING_NL_IN_mutation_iterator_2255 ) tree_for_NL370 = @adaptor.create_with_payload( __NL370__ ) @adaptor.add_child( root_0, tree_for_NL370 ) else match_count_134 > 0 and break eee = EarlyExit(134) raise eee end match_count_134 += 1 end # --> action id = self.to_ref(( path365 && @input.to_s( path365.start, path365.stop ) )) @now[id] = { '_parent' => @now, '_context' => 'iterator', '_self' => id, '_variable' => __ID367__.text } @now = @now[id] # <-- action # at line 795:3: ( mutation ( NL )+ )* while true # decision 136 alt_136 = 2 look_136_0 = @input.peek( 1 ) if ( look_136_0 == ID || look_136_0 == T__49 ) alt_136 = 1 end case alt_136 when 1 # at line 795:4: mutation ( NL )+ @state.following.push( TOKENS_FOLLOWING_mutation_IN_mutation_iterator_2265 ) mutation371 = mutation @state.following.pop @adaptor.add_child( root_0, mutation371.tree ) # --> action @now[( mutation371.nil? ? nil : mutation371.key )] = ( mutation371.nil? ? nil : mutation371.val ) # <-- action # at file 797:3: ( NL )+ match_count_135 = 0 while true alt_135 = 2 look_135_0 = @input.peek( 1 ) if ( look_135_0 == NL ) alt_135 = 1 end case alt_135 when 1 # at line 797:3: NL __NL372__ = match( NL, TOKENS_FOLLOWING_NL_IN_mutation_iterator_2273 ) tree_for_NL372 = @adaptor.create_with_payload( __NL372__ ) @adaptor.add_child( root_0, tree_for_NL372 ) else match_count_135 > 0 and break eee = EarlyExit(135) raise eee end match_count_135 += 1 end else break # out of loop for decision 136 end end # loop for decision 136 char_literal373 = match( T__85, TOKENS_FOLLOWING_T__85_IN_mutation_iterator_2280 ) tree_for_char_literal373 = @adaptor.create_with_payload( char_literal373 ) @adaptor.add_child( root_0, tree_for_char_literal373 ) # --> action self.goto_parent() # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 47 ) end return return_value end MutationReturnValue = define_return_scope :key, :val # # parser rule mutation # # (in SfpLang.g) # 802:1: mutation returns [key, val] : ( reference equals_op value | reference equals_op NULL | reference binary_op NUMBER | reference 'is' 'new' path ( object_body )? | 'delete' path | reference 'add(' value ')' | reference 'remove(' value ')' ); # def mutation # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 48 ) return_value = MutationReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __NULL379__ = nil __NUMBER382__ = nil string_literal384 = nil string_literal385 = nil string_literal388 = nil string_literal391 = nil char_literal393 = nil string_literal395 = nil char_literal397 = nil reference374 = nil equals_op375 = nil value376 = nil reference377 = nil equals_op378 = nil reference380 = nil binary_op381 = nil reference383 = nil path386 = nil object_body387 = nil path389 = nil reference390 = nil value392 = nil reference394 = nil value396 = nil tree_for_NULL379 = nil tree_for_NUMBER382 = nil tree_for_string_literal384 = nil tree_for_string_literal385 = nil tree_for_string_literal388 = nil tree_for_string_literal391 = nil tree_for_char_literal393 = nil tree_for_string_literal395 = nil tree_for_char_literal397 = nil begin # at line 803:2: ( reference equals_op value | reference equals_op NULL | reference binary_op NUMBER | reference 'is' 'new' path ( object_body )? | 'delete' path | reference 'add(' value ')' | reference 'remove(' value ')' ) alt_138 = 7 alt_138 = @dfa138.predict( @input ) case alt_138 when 1 root_0 = @adaptor.create_flat_list # at line 803:4: reference equals_op value @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2299 ) reference374 = reference @state.following.pop @adaptor.add_child( root_0, reference374.tree ) @state.following.push( TOKENS_FOLLOWING_equals_op_IN_mutation_2301 ) equals_op375 = equals_op @state.following.pop @adaptor.add_child( root_0, equals_op375.tree ) @state.following.push( TOKENS_FOLLOWING_value_IN_mutation_2303 ) value376 = value @state.following.pop @adaptor.add_child( root_0, value376.tree ) # --> action return_value.key = ( reference374.nil? ? nil : reference374.val ) return_value.val = { '_context' => 'mutation', '_type' => 'equals', '_value' => ( value376.nil? ? nil : value376.val ) } # <-- action when 2 root_0 = @adaptor.create_flat_list # at line 811:4: reference equals_op NULL @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2312 ) reference377 = reference @state.following.pop @adaptor.add_child( root_0, reference377.tree ) @state.following.push( TOKENS_FOLLOWING_equals_op_IN_mutation_2314 ) equals_op378 = equals_op @state.following.pop @adaptor.add_child( root_0, equals_op378.tree ) __NULL379__ = match( NULL, TOKENS_FOLLOWING_NULL_IN_mutation_2316 ) tree_for_NULL379 = @adaptor.create_with_payload( __NULL379__ ) @adaptor.add_child( root_0, tree_for_NULL379 ) # --> action return_value.key = ( reference377.nil? ? nil : reference377.val ) return_value.val = { '_context' => 'mutation', '_type' => 'equals', '_value' => self.null_value } # <-- action when 3 root_0 = @adaptor.create_flat_list # at line 819:4: reference binary_op NUMBER @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2325 ) reference380 = reference @state.following.pop @adaptor.add_child( root_0, reference380.tree ) @state.following.push( TOKENS_FOLLOWING_binary_op_IN_mutation_2327 ) binary_op381 = binary_op @state.following.pop @adaptor.add_child( root_0, binary_op381.tree ) __NUMBER382__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_mutation_2329 ) tree_for_NUMBER382 = @adaptor.create_with_payload( __NUMBER382__ ) @adaptor.add_child( root_0, tree_for_NUMBER382 ) # --> action return_value.key = ( reference380.nil? ? nil : reference380.val ) return_value.val = { '_context' => 'mutation', '_type' => ( binary_op381 && @input.to_s( binary_op381.start, binary_op381.stop ) ), '_value' => __NUMBER382__.text.to_i } # <-- action when 4 root_0 = @adaptor.create_flat_list # at line 827:4: reference 'is' 'new' path ( object_body )? @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2338 ) reference383 = reference @state.following.pop @adaptor.add_child( root_0, reference383.tree ) string_literal384 = match( T__65, TOKENS_FOLLOWING_T__65_IN_mutation_2340 ) tree_for_string_literal384 = @adaptor.create_with_payload( string_literal384 ) @adaptor.add_child( root_0, tree_for_string_literal384 ) string_literal385 = match( T__71, TOKENS_FOLLOWING_T__71_IN_mutation_2342 ) tree_for_string_literal385 = @adaptor.create_with_payload( string_literal385 ) @adaptor.add_child( root_0, tree_for_string_literal385 ) @state.following.push( TOKENS_FOLLOWING_path_IN_mutation_2344 ) path386 = path @state.following.pop @adaptor.add_child( root_0, path386.tree ) # --> action id = '_' + self.next_id @now[id] = { '_self' => id, '_context' => 'object', '_isa' => self.to_ref(( path386 && @input.to_s( path386.start, path386.stop ) )), '_parent' => @now } @now = @now[id] # <-- action # at line 837:3: ( object_body )? alt_137 = 2 look_137_0 = @input.peek( 1 ) if ( look_137_0 == T__84 ) alt_137 = 1 end case alt_137 when 1 # at line 837:3: object_body @state.following.push( TOKENS_FOLLOWING_object_body_IN_mutation_2352 ) object_body387 = object_body @state.following.pop @adaptor.add_child( root_0, object_body387.tree ) end # --> action n = self.goto_parent() @now.delete(n['_self']) return_value.key = ( reference383.nil? ? nil : reference383.val ) return_value.val = n # <-- action when 5 root_0 = @adaptor.create_flat_list # at line 844:4: 'delete' path string_literal388 = match( T__49, TOKENS_FOLLOWING_T__49_IN_mutation_2362 ) tree_for_string_literal388 = @adaptor.create_with_payload( string_literal388 ) @adaptor.add_child( root_0, tree_for_string_literal388 ) @state.following.push( TOKENS_FOLLOWING_path_IN_mutation_2364 ) path389 = path @state.following.pop @adaptor.add_child( root_0, path389.tree ) # --> action id = '_' + self.next_id @now[id] = { '_self' => id, '_context' => 'mutation', '_type' => 'delete', '_value' => self.to_ref(( path389 && @input.to_s( path389.start, path389.stop ) )) } # <-- action when 6 root_0 = @adaptor.create_flat_list # at line 853:4: reference 'add(' value ')' @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2373 ) reference390 = reference @state.following.pop @adaptor.add_child( root_0, reference390.tree ) string_literal391 = match( T__37, TOKENS_FOLLOWING_T__37_IN_mutation_2375 ) tree_for_string_literal391 = @adaptor.create_with_payload( string_literal391 ) @adaptor.add_child( root_0, tree_for_string_literal391 ) @state.following.push( TOKENS_FOLLOWING_value_IN_mutation_2377 ) value392 = value @state.following.pop @adaptor.add_child( root_0, value392.tree ) char_literal393 = match( T__20, TOKENS_FOLLOWING_T__20_IN_mutation_2379 ) tree_for_char_literal393 = @adaptor.create_with_payload( char_literal393 ) @adaptor.add_child( root_0, tree_for_char_literal393 ) # --> action return_value.key = ( reference390.nil? ? nil : reference390.val ) return_value.val = { '_context' => 'mutation', '_type' => 'add', '_value' => ( value392.nil? ? nil : value392.val ) } # <-- action when 7 root_0 = @adaptor.create_flat_list # at line 861:4: reference 'remove(' value ')' @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2388 ) reference394 = reference @state.following.pop @adaptor.add_child( root_0, reference394.tree ) string_literal395 = match( T__75, TOKENS_FOLLOWING_T__75_IN_mutation_2390 ) tree_for_string_literal395 = @adaptor.create_with_payload( string_literal395 ) @adaptor.add_child( root_0, tree_for_string_literal395 ) @state.following.push( TOKENS_FOLLOWING_value_IN_mutation_2392 ) value396 = value @state.following.pop @adaptor.add_child( root_0, value396.tree ) char_literal397 = match( T__20, TOKENS_FOLLOWING_T__20_IN_mutation_2394 ) tree_for_char_literal397 = @adaptor.create_with_payload( char_literal397 ) @adaptor.add_child( root_0, tree_for_char_literal397 ) # --> action return_value.key = ( reference394.nil? ? nil : reference394.val ) return_value.val = { '_context' => 'mutation', '_type' => 'remove', '_value' => ( value396.nil? ? nil : value396.val ) } # <-- action end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 48 ) end return return_value end SetValueReturnValue = define_return_scope :val # # parser rule set_value # # (in SfpLang.g) # 871:1: set_value returns [val] : '(' ( set_item ( ',' ( NL )* set_item )* )? ')' ; # def set_value # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 49 ) return_value = SetValueReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil char_literal398 = nil char_literal400 = nil __NL401__ = nil char_literal403 = nil set_item399 = nil set_item402 = nil tree_for_char_literal398 = nil tree_for_char_literal400 = nil tree_for_NL401 = nil tree_for_char_literal403 = nil begin root_0 = @adaptor.create_flat_list # at line 872:4: '(' ( set_item ( ',' ( NL )* set_item )* )? ')' char_literal398 = match( T__19, TOKENS_FOLLOWING_T__19_IN_set_value_2413 ) tree_for_char_literal398 = @adaptor.create_with_payload( char_literal398 ) @adaptor.add_child( root_0, tree_for_char_literal398 ) # --> action @set = Array.new # <-- action # at line 874:3: ( set_item ( ',' ( NL )* set_item )* )? alt_141 = 2 look_141_0 = @input.peek( 1 ) if ( look_141_0 == BOOLEAN || look_141_0.between?( ID, MULTILINE_STRING ) || look_141_0 == NUMBER || look_141_0 == STRING || look_141_0 == T__19 || look_141_0 == T__40 ) alt_141 = 1 end case alt_141 when 1 # at line 874:4: set_item ( ',' ( NL )* set_item )* @state.following.push( TOKENS_FOLLOWING_set_item_IN_set_value_2422 ) set_item399 = set_item @state.following.pop @adaptor.add_child( root_0, set_item399.tree ) # at line 874:13: ( ',' ( NL )* set_item )* while true # decision 140 alt_140 = 2 look_140_0 = @input.peek( 1 ) if ( look_140_0 == T__23 ) alt_140 = 1 end case alt_140 when 1 # at line 874:14: ',' ( NL )* set_item char_literal400 = match( T__23, TOKENS_FOLLOWING_T__23_IN_set_value_2425 ) tree_for_char_literal400 = @adaptor.create_with_payload( char_literal400 ) @adaptor.add_child( root_0, tree_for_char_literal400 ) # at line 874:18: ( NL )* while true # decision 139 alt_139 = 2 look_139_0 = @input.peek( 1 ) if ( look_139_0 == NL ) alt_139 = 1 end case alt_139 when 1 # at line 874:18: NL __NL401__ = match( NL, TOKENS_FOLLOWING_NL_IN_set_value_2427 ) tree_for_NL401 = @adaptor.create_with_payload( __NL401__ ) @adaptor.add_child( root_0, tree_for_NL401 ) else break # out of loop for decision 139 end end # loop for decision 139 @state.following.push( TOKENS_FOLLOWING_set_item_IN_set_value_2430 ) set_item402 = set_item @state.following.pop @adaptor.add_child( root_0, set_item402.tree ) else break # out of loop for decision 140 end end # loop for decision 140 end # --> action return_value.val = @set # <-- action char_literal403 = match( T__20, TOKENS_FOLLOWING_T__20_IN_set_value_2442 ) tree_for_char_literal403 = @adaptor.create_with_payload( char_literal403 ) @adaptor.add_child( root_0, tree_for_char_literal403 ) # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 49 ) end return return_value end SetItemReturnValue = define_return_scope # # parser rule set_item # # (in SfpLang.g) # 879:1: set_item : value ; # def set_item # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 50 ) return_value = SetItemReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil value404 = nil begin root_0 = @adaptor.create_flat_list # at line 880:4: value @state.following.push( TOKENS_FOLLOWING_value_IN_set_item_2453 ) value404 = value @state.following.pop @adaptor.add_child( root_0, value404.tree ) # --> action @set.push(( value404.nil? ? nil : value404.val )) # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 50 ) end return return_value end ValueReturnValue = define_return_scope :val, :type # # parser rule value # # (in SfpLang.g) # 884:1: value returns [val, type] : ( primitive_value | reference | set_value | 'any' ); # def value # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 51 ) return_value = ValueReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal408 = nil primitive_value405 = nil reference406 = nil set_value407 = nil tree_for_string_literal408 = nil begin # at line 885:2: ( primitive_value | reference | set_value | 'any' ) alt_142 = 4 case look_142 = @input.peek( 1 ) when BOOLEAN, MULTILINE_STRING, NUMBER, STRING then alt_142 = 1 when ID then alt_142 = 2 when T__19 then alt_142 = 3 when T__40 then alt_142 = 4 else raise NoViableAlternative( "", 142, 0 ) end case alt_142 when 1 root_0 = @adaptor.create_flat_list # at line 885:4: primitive_value @state.following.push( TOKENS_FOLLOWING_primitive_value_IN_value_2472 ) primitive_value405 = primitive_value @state.following.pop @adaptor.add_child( root_0, primitive_value405.tree ) # --> action return_value.val = ( primitive_value405.nil? ? nil : primitive_value405.val ) return_value.type = ( primitive_value405.nil? ? nil : primitive_value405.type ) # <-- action when 2 root_0 = @adaptor.create_flat_list # at line 890:4: reference @state.following.push( TOKENS_FOLLOWING_reference_IN_value_2481 ) reference406 = reference @state.following.pop @adaptor.add_child( root_0, reference406.tree ) # --> action return_value.val = ( reference406.nil? ? nil : reference406.val ) return_value.type = 'Reference' # <-- action when 3 root_0 = @adaptor.create_flat_list # at line 895:4: set_value @state.following.push( TOKENS_FOLLOWING_set_value_IN_value_2490 ) set_value407 = set_value @state.following.pop @adaptor.add_child( root_0, set_value407.tree ) # --> action return_value.val = ( set_value407.nil? ? nil : set_value407.val ) return_value.type = 'Set' # <-- action when 4 root_0 = @adaptor.create_flat_list # at line 900:4: 'any' string_literal408 = match( T__40, TOKENS_FOLLOWING_T__40_IN_value_2499 ) tree_for_string_literal408 = @adaptor.create_with_payload( string_literal408 ) @adaptor.add_child( root_0, tree_for_string_literal408 ) # --> action return_value.val = Sfp::Any.new return_value.type = 'Any' # <-- action end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 51 ) end return return_value end PrimitiveValueReturnValue = define_return_scope :val, :type # # parser rule primitive_value # # (in SfpLang.g) # 907:1: primitive_value returns [val, type] : ( BOOLEAN | NUMBER | STRING | MULTILINE_STRING ); # def primitive_value # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 52 ) return_value = PrimitiveValueReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __BOOLEAN409__ = nil __NUMBER410__ = nil __STRING411__ = nil __MULTILINE_STRING412__ = nil tree_for_BOOLEAN409 = nil tree_for_NUMBER410 = nil tree_for_STRING411 = nil tree_for_MULTILINE_STRING412 = nil begin # at line 908:2: ( BOOLEAN | NUMBER | STRING | MULTILINE_STRING ) alt_143 = 4 case look_143 = @input.peek( 1 ) when BOOLEAN then alt_143 = 1 when NUMBER then alt_143 = 2 when STRING then alt_143 = 3 when MULTILINE_STRING then alt_143 = 4 else raise NoViableAlternative( "", 143, 0 ) end case alt_143 when 1 root_0 = @adaptor.create_flat_list # at line 908:4: BOOLEAN __BOOLEAN409__ = match( BOOLEAN, TOKENS_FOLLOWING_BOOLEAN_IN_primitive_value_2518 ) tree_for_BOOLEAN409 = @adaptor.create_with_payload( __BOOLEAN409__ ) @adaptor.add_child( root_0, tree_for_BOOLEAN409 ) # --> action if __BOOLEAN409__.text == 'true' or __BOOLEAN409__.text == 'on' or __BOOLEAN409__.text == 'yes' return_value.val = true else # 'false', 'no', 'off' return_value.val = false end return_value.type = 'Boolean' # <-- action when 2 root_0 = @adaptor.create_flat_list # at line 917:4: NUMBER __NUMBER410__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_primitive_value_2527 ) tree_for_NUMBER410 = @adaptor.create_with_payload( __NUMBER410__ ) @adaptor.add_child( root_0, tree_for_NUMBER410 ) # --> action return_value.val = __NUMBER410__.text.to_i return_value.type = 'Number' # <-- action when 3 root_0 = @adaptor.create_flat_list # at line 922:4: STRING __STRING411__ = match( STRING, TOKENS_FOLLOWING_STRING_IN_primitive_value_2536 ) tree_for_STRING411 = @adaptor.create_with_payload( __STRING411__ ) @adaptor.add_child( root_0, tree_for_STRING411 ) # --> action return_value.val = __STRING411__.text[1,__STRING411__.text.length-2] return_value.type = 'String' # <-- action when 4 root_0 = @adaptor.create_flat_list # at line 927:4: MULTILINE_STRING __MULTILINE_STRING412__ = match( MULTILINE_STRING, TOKENS_FOLLOWING_MULTILINE_STRING_IN_primitive_value_2545 ) tree_for_MULTILINE_STRING412 = @adaptor.create_with_payload( __MULTILINE_STRING412__ ) @adaptor.add_child( root_0, tree_for_MULTILINE_STRING412 ) # --> action return_value.val = __MULTILINE_STRING412__.text[2, __MULTILINE_STRING412__.text.length-2] return_value.type = 'String' # <-- action end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 52 ) end return return_value end PathReturnValue = define_return_scope # # parser rule path # # (in SfpLang.g) # 934:1: path : ID ( '.' ID )* ; # def path # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 53 ) return_value = PathReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __ID413__ = nil char_literal414 = nil __ID415__ = nil tree_for_ID413 = nil tree_for_char_literal414 = nil tree_for_ID415 = nil begin root_0 = @adaptor.create_flat_list # at line 935:4: ID ( '.' ID )* __ID413__ = match( ID, TOKENS_FOLLOWING_ID_IN_path_2560 ) tree_for_ID413 = @adaptor.create_with_payload( __ID413__ ) @adaptor.add_child( root_0, tree_for_ID413 ) # at line 935:6: ( '.' ID )* while true # decision 144 alt_144 = 2 look_144_0 = @input.peek( 1 ) if ( look_144_0 == T__25 ) alt_144 = 1 end case alt_144 when 1 # at line 935:7: '.' ID char_literal414 = match( T__25, TOKENS_FOLLOWING_T__25_IN_path_2562 ) tree_for_char_literal414 = @adaptor.create_with_payload( char_literal414 ) @adaptor.add_child( root_0, tree_for_char_literal414 ) __ID415__ = match( ID, TOKENS_FOLLOWING_ID_IN_path_2563 ) tree_for_ID415 = @adaptor.create_with_payload( __ID415__ ) @adaptor.add_child( root_0, tree_for_ID415 ) else break # out of loop for decision 144 end end # loop for decision 144 # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 53 ) end return return_value end PathWithIndexReturnValue = define_return_scope # # parser rule path_with_index # # (in SfpLang.g) # 938:1: path_with_index : id_ref ( '.' id_ref )* ; # def path_with_index # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 54 ) return_value = PathWithIndexReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil char_literal417 = nil id_ref416 = nil id_ref418 = nil tree_for_char_literal417 = nil begin root_0 = @adaptor.create_flat_list # at line 939:4: id_ref ( '.' id_ref )* @state.following.push( TOKENS_FOLLOWING_id_ref_IN_path_with_index_2576 ) id_ref416 = id_ref @state.following.pop @adaptor.add_child( root_0, id_ref416.tree ) # at line 939:10: ( '.' id_ref )* while true # decision 145 alt_145 = 2 look_145_0 = @input.peek( 1 ) if ( look_145_0 == T__25 ) alt_145 = 1 end case alt_145 when 1 # at line 939:11: '.' id_ref char_literal417 = match( T__25, TOKENS_FOLLOWING_T__25_IN_path_with_index_2578 ) tree_for_char_literal417 = @adaptor.create_with_payload( char_literal417 ) @adaptor.add_child( root_0, tree_for_char_literal417 ) @state.following.push( TOKENS_FOLLOWING_id_ref_IN_path_with_index_2579 ) id_ref418 = id_ref @state.following.pop @adaptor.add_child( root_0, id_ref418.tree ) else break # out of loop for decision 145 end end # loop for decision 145 # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 54 ) end return return_value end IdRefReturnValue = define_return_scope # # parser rule id_ref # # (in SfpLang.g) # 942:1: id_ref : ID ( '[' NUMBER ']' )? ; # def id_ref # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 55 ) return_value = IdRefReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil __ID419__ = nil char_literal420 = nil __NUMBER421__ = nil char_literal422 = nil tree_for_ID419 = nil tree_for_char_literal420 = nil tree_for_NUMBER421 = nil tree_for_char_literal422 = nil begin root_0 = @adaptor.create_flat_list # at line 943:4: ID ( '[' NUMBER ']' )? __ID419__ = match( ID, TOKENS_FOLLOWING_ID_IN_id_ref_2592 ) tree_for_ID419 = @adaptor.create_with_payload( __ID419__ ) @adaptor.add_child( root_0, tree_for_ID419 ) # at line 943:6: ( '[' NUMBER ']' )? alt_146 = 2 look_146_0 = @input.peek( 1 ) if ( look_146_0 == T__34 ) alt_146 = 1 end case alt_146 when 1 # at line 943:7: '[' NUMBER ']' char_literal420 = match( T__34, TOKENS_FOLLOWING_T__34_IN_id_ref_2594 ) tree_for_char_literal420 = @adaptor.create_with_payload( char_literal420 ) @adaptor.add_child( root_0, tree_for_char_literal420 ) __NUMBER421__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_id_ref_2596 ) tree_for_NUMBER421 = @adaptor.create_with_payload( __NUMBER421__ ) @adaptor.add_child( root_0, tree_for_NUMBER421 ) char_literal422 = match( T__35, TOKENS_FOLLOWING_T__35_IN_id_ref_2598 ) tree_for_char_literal422 = @adaptor.create_with_payload( char_literal422 ) @adaptor.add_child( root_0, tree_for_char_literal422 ) end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 55 ) end return return_value end ReferenceReturnValue = define_return_scope :val # # parser rule reference # # (in SfpLang.g) # 946:1: reference returns [val] : path_with_index ; # def reference # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 56 ) return_value = ReferenceReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil path_with_index423 = nil begin root_0 = @adaptor.create_flat_list # at line 947:4: path_with_index @state.following.push( TOKENS_FOLLOWING_path_with_index_IN_reference_2615 ) path_with_index423 = path_with_index @state.following.pop @adaptor.add_child( root_0, path_with_index423.tree ) # --> action return_value.val = self.to_ref(( path_with_index423 && @input.to_s( path_with_index423.start, path_with_index423.stop ) )) # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 56 ) end return return_value end ReferenceTypeReturnValue = define_return_scope :val # # parser rule reference_type # # (in SfpLang.g) # 951:1: reference_type returns [val] : 'isref' path ; # def reference_type # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 57 ) return_value = ReferenceTypeReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal424 = nil path425 = nil tree_for_string_literal424 = nil begin root_0 = @adaptor.create_flat_list # at line 952:4: 'isref' path string_literal424 = match( T__69, TOKENS_FOLLOWING_T__69_IN_reference_type_2634 ) tree_for_string_literal424 = @adaptor.create_with_payload( string_literal424 ) @adaptor.add_child( root_0, tree_for_string_literal424 ) @state.following.push( TOKENS_FOLLOWING_path_IN_reference_type_2636 ) path425 = path @state.following.pop @adaptor.add_child( root_0, path425.tree ) # --> action return_value.val = { '_context' => 'null', '_isa' => self.to_ref(( path425 && @input.to_s( path425.start, path425.stop ) )) } # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 57 ) end return return_value end SetTypeReturnValue = define_return_scope :val # # parser rule set_type # # (in SfpLang.g) # 960:1: set_type returns [val] : 'isset' path ; # def set_type # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 58 ) return_value = SetTypeReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal426 = nil path427 = nil tree_for_string_literal426 = nil begin root_0 = @adaptor.create_flat_list # at line 961:4: 'isset' path string_literal426 = match( T__70, TOKENS_FOLLOWING_T__70_IN_set_type_2655 ) tree_for_string_literal426 = @adaptor.create_with_payload( string_literal426 ) @adaptor.add_child( root_0, tree_for_string_literal426 ) @state.following.push( TOKENS_FOLLOWING_path_IN_set_type_2657 ) path427 = path @state.following.pop @adaptor.add_child( root_0, path427.tree ) # --> action return_value.val = { '_context' => 'set', '_isa' => self.to_ref(( path427 && @input.to_s( path427.start, path427.stop ) )), '_values' => [] } # <-- action # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 58 ) end return return_value end ProbabilityOpReturnValue = define_return_scope # # parser rule probability_op # # (in SfpLang.g) # 970:1: probability_op : 'either' ; # def probability_op # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 59 ) return_value = ProbabilityOpReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil string_literal428 = nil tree_for_string_literal428 = nil begin root_0 = @adaptor.create_flat_list # at line 971:4: 'either' string_literal428 = match( T__52, TOKENS_FOLLOWING_T__52_IN_probability_op_2672 ) tree_for_string_literal428 = @adaptor.create_with_payload( string_literal428 ) @adaptor.add_child( root_0, tree_for_string_literal428 ) # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 59 ) end return return_value end EqualsOpReturnValue = define_return_scope # # parser rule equals_op # # (in SfpLang.g) # 974:1: equals_op : ( '=' | 'is' ); # def equals_op # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 60 ) return_value = EqualsOpReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil set429 = nil tree_for_set429 = nil begin root_0 = @adaptor.create_flat_list # at line set429 = @input.look if @input.peek(1) == T__31 || @input.peek(1) == T__65 @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set429 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 60 ) end return return_value end NotEqualsOpReturnValue = define_return_scope # # parser rule not_equals_op # # (in SfpLang.g) # 979:1: not_equals_op : ( '!=' | 'isnt' | 'isnot' ); # def not_equals_op # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 61 ) return_value = NotEqualsOpReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil set430 = nil tree_for_set430 = nil begin root_0 = @adaptor.create_flat_list # at line set430 = @input.look if @input.peek(1) == T__18 || @input.peek( 1 ).between?( T__67, T__68 ) @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set430 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 61 ) end return return_value end BinaryOpReturnValue = define_return_scope # # parser rule binary_op # # (in SfpLang.g) # 985:1: binary_op : ( '+=' | '-=' | '*=' | '/=' ); # def binary_op # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 62 ) return_value = BinaryOpReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil set431 = nil tree_for_set431 = nil begin root_0 = @adaptor.create_flat_list # at line set431 = @input.look if @input.peek( 1 ).between?( T__21, T__22 ) || @input.peek(1) == T__24 || @input.peek(1) == T__26 @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set431 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 62 ) end return return_value end BinaryCompReturnValue = define_return_scope # # parser rule binary_comp # # (in SfpLang.g) # 992:1: binary_comp : ( '>' | '>=' | '<' | '<=' ); # def binary_comp # -> uncomment the next line to manually enable rule tracing # trace_in( __method__, 63 ) return_value = BinaryCompReturnValue.new # $rule.start = the first token seen before matching return_value.start = @input.look root_0 = nil set432 = nil tree_for_set432 = nil begin root_0 = @adaptor.create_flat_list # at line set432 = @input.look if @input.peek( 1 ).between?( T__29, T__30 ) || @input.peek( 1 ).between?( T__32, T__33 ) @input.consume @adaptor.add_child( root_0, @adaptor.create_with_payload( set432 ) ) @state.error_recovery = false else mse = MismatchedSet( nil ) raise mse end # - - - - - - - rule clean up - - - - - - - - return_value.stop = @input.look( -1 ) return_value.tree = @adaptor.rule_post_processing( root_0 ) @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop ) rescue ANTLR3::Error::RecognitionError => re report_error(re) recover(re) return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re ) ensure # -> uncomment the next line to manually enable rule tracing # trace_out( __method__, 63 ) end return return_value end # - - - - - - - - - - DFA definitions - - - - - - - - - - - class DFA41 < ANTLR3::DFA EOT = unpack( 4, -1 ) EOF = unpack( 1, -1, 1, 3, 2, -1 ) MIN = unpack( 2, 11, 2, -1 ) MAX = unpack( 2, 73, 2, -1 ) ACCEPT = unpack( 2, -1, 1, 1, 1, 2 ) SPECIAL = unpack( 4, -1 ) TRANSITION = [ unpack( 1, 1, 61, -1, 1, 2 ), unpack( 1, 1, 61, -1, 1, 2 ), unpack( ), unpack( ) ].freeze ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z | if a > 0 and z < 0 MAX[ i ] %= 0x10000 end end @decision = 41 def description <<-'__dfa_description__'.strip! ()* loopback of 266:3: ( ( NL )* 'or' ( NL )* '{' ( NL )* constraint_body '}' )* __dfa_description__ end end class DFA75 < ANTLR3::DFA EOT = unpack( 9, -1 ) EOF = unpack( 9, -1 ) MIN = unpack( 1, 9, 1, 11, 3, -1, 2, 9, 1, -1, 1, 11 ) MAX = unpack( 1, 82, 1, 84, 3, -1, 1, 9, 1, 85, 1, -1, 1, 84 ) ACCEPT = unpack( 2, -1, 1, 1, 1, 3, 1, 4, 2, -1, 1, 2, 1, -1 ) SPECIAL = unpack( 9, -1 ) TRANSITION = [ unpack( 1, 1, 43, -1, 1, 4, 2, -1, 1, 4, 1, 3, 1, 4, 3, -1, 1, 2, 9, -1, 1, 2, 9, -1, 1, 2 ), unpack( 1, 6, 6, -1, 1, 2, 6, -1, 1, 5, 3, -1, 6, 2, 26, -1, 1, 2, 1, -1, 1, 2, 1, -1, 1, 2, 1, -1, 2, 2, 3, -1, 1, 2, 11, -1, 1, 7 ), unpack( ), unpack( ), unpack( ), unpack( 1, 8 ), unpack( 1, 2, 1, -1, 1, 6, 26, -1, 2, 2, 3, -1, 1, 2, 9, -1, 1, 2, 2, -1, 4, 2, 2, -1, 1, 2, 9, -1, 1, 2, 4, -1, 1, 2, 4, -1, 2, 2, 1, 7, 1, 2 ), unpack( ), unpack( 1, 6, 6, -1, 1, 2, 6, -1, 1, 5, 3, -1, 6, 2, 26, -1, 1, 2, 1, -1, 1, 2, 1, -1, 1, 2, 1, -1, 2, 2, 3, -1, 1, 2, 11, -1, 1, 7 ) ].freeze ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z | if a > 0 and z < 0 MAX[ i ] %= 0x10000 end end @decision = 75 def description <<-'__dfa_description__'.strip! 428:4: ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) __dfa_description__ end end class DFA102 < ANTLR3::DFA EOT = unpack( 9, -1 ) EOF = unpack( 9, -1 ) MIN = unpack( 1, 9, 1, 11, 3, -1, 2, 9, 1, -1, 1, 11 ) MAX = unpack( 1, 82, 1, 84, 3, -1, 1, 9, 1, 85, 1, -1, 1, 84 ) ACCEPT = unpack( 2, -1, 1, 1, 1, 3, 1, 4, 2, -1, 1, 2, 1, -1 ) SPECIAL = unpack( 9, -1 ) TRANSITION = [ unpack( 1, 1, 43, -1, 1, 4, 2, -1, 1, 4, 1, 3, 1, 4, 3, -1, 1, 2, 9, -1, 1, 2, 9, -1, 1, 2 ), unpack( 1, 6, 6, -1, 1, 2, 6, -1, 1, 5, 3, -1, 6, 2, 26, -1, 1, 2, 1, -1, 1, 2, 1, -1, 1, 2, 1, -1, 2, 2, 3, -1, 1, 2, 11, -1, 1, 7 ), unpack( ), unpack( ), unpack( ), unpack( 1, 8 ), unpack( 1, 2, 1, -1, 1, 6, 41, -1, 1, 2, 2, -1, 3, 2, 3, -1, 1, 2, 9, -1, 1, 2, 9, -1, 1, 2, 1, -1, 1, 7, 1, 2 ), unpack( ), unpack( 1, 6, 6, -1, 1, 2, 6, -1, 1, 5, 3, -1, 6, 2, 26, -1, 1, 2, 1, -1, 1, 2, 1, -1, 1, 2, 1, -1, 2, 2, 3, -1, 1, 2, 11, -1, 1, 7 ) ].freeze ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z | if a > 0 and z < 0 MAX[ i ] %= 0x10000 end end @decision = 102 def description <<-'__dfa_description__'.strip! 529:4: ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) __dfa_description__ end end class DFA122 < ANTLR3::DFA EOT = unpack( 26, -1 ) EOF = unpack( 26, -1 ) MIN = unpack( 1, 9, 1, 11, 3, -1, 1, 13, 1, 9, 1, -1, 3, 4, 1, -1, 1, 4, 3, -1, 1, 35, 1, 11, 4, -1, 1, 11, 1, 13, 1, 35, 1, 11 ) MAX = unpack( 1, 82, 1, 81, 3, -1, 1, 13, 1, 9, 1, -1, 2, 63, 1, 40, 1, -1, 1, 40, 3, -1, 1, 35, 1, 81, 4, -1, 1, 81, 1, 13, 1, 35, 1, 81 ) ACCEPT = unpack( 2, -1, 1, 2, 1, 7, 1, 12, 2, -1, 1, 1, 3, -1, 1, 8, 1, -1, 1, 9, 1, 10, 1, 11, 2, -1, 1, 3, 1, 4, 1, 5, 1, 6, 4, -1 ) SPECIAL = unpack( 26, -1 ) TRANSITION = [ unpack( 1, 1, 52, -1, 1, 3, 9, -1, 1, 2, 9, -1, 1, 4 ), unpack( 1, 7, 6, -1, 1, 12, 6, -1, 1, 6, 3, -1, 2, 15, 1, 10, 2, 15, 1, 5, 26, -1, 1, 14, 1, -1, 1, 11, 1, -1, 1, 8, 1, -1, 2, 9, 3, -1, 1, 13, 8, -1, 1, 7 ), unpack( ), unpack( ), unpack( ), unpack( 1, 16 ), unpack( 1, 17 ), unpack( ), unpack( 1, 18, 4, -1, 2, 18, 1, -1, 1, 19, 1, 18, 1, -1, 1, 18, 3, -1, 1, 18, 20, -1, 1, 18, 22, -1, 1, 11 ), unpack( 1, 20, 4, -1, 2, 20, 1, -1, 1, 21, 1, 20, 1, -1, 1, 20, 3, -1, 1, 20, 20, -1, 1, 20, 22, -1, 1, 13 ), unpack( 1, 18, 4, -1, 2, 18, 1, -1, 1, 19, 1, 18, 1, -1, 1, 18, 3, -1, 1, 18, 20, -1, 1, 18 ), unpack( ), unpack( 1, 20, 4, -1, 2, 20, 1, -1, 1, 21, 1, 20, 1, -1, 1, 20, 3, -1, 1, 20, 20, -1, 1, 20 ), unpack( ), unpack( ), unpack( ), unpack( 1, 22 ), unpack( 1, 7, 6, -1, 1, 12, 6, -1, 1, 6, 3, -1, 2, 15, 1, 10, 2, 15, 1, 23, 26, -1, 1, 14, 1, -1, 1, 11, 1, -1, 1, 8, 1, -1, 2, 9, 3, -1, 1, 13, 8, -1, 1, 7 ), unpack( ), unpack( ), unpack( ), unpack( ), unpack( 1, 7, 6, -1, 1, 12, 6, -1, 1, 6, 3, -1, 2, 15, 1, 10, 2, 15, 27, -1, 1, 14, 1, -1, 1, 11, 1, -1, 1, 8, 1, -1, 2, 9, 3, -1, 1, 13, 8, -1, 1, 7 ), unpack( 1, 24 ), unpack( 1, 25 ), unpack( 1, 7, 6, -1, 1, 12, 6, -1, 1, 6, 3, -1, 2, 15, 1, 10, 2, 15, 27, -1, 1, 14, 1, -1, 1, 11, 1, -1, 1, 8, 1, -1, 2, 9, 3, -1, 1, 13, 8, -1, 1, 7 ) ].freeze ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z | if a > 0 and z < 0 MAX[ i ] %= 0x10000 end end @decision = 122 def description <<-'__dfa_description__'.strip! 629:1: constraint_statement returns [key, val] : ( reference | 'not' reference | reference equals_op value | reference equals_op NULL | reference not_equals_op value | reference not_equals_op NULL | conditional_constraint | reference ( 'is' )? 'in' set_value | reference ( 'isnot' | 'isnt' | 'not' ) 'in' set_value | reference 'has' value | reference binary_comp comp_value | total_constraint ); __dfa_description__ end end class DFA138 < ANTLR3::DFA EOT = unpack( 19, -1 ) EOF = unpack( 19, -1 ) MIN = unpack( 1, 9, 1, 21, 1, -1, 1, 13, 1, 9, 1, 4, 1, -1, 1, 4, 2, -1, 1, 35, 1, 21, 3, -1, 1, 21, 1, 13, 1, 35, 1, 21 ) MAX = unpack( 1, 49, 1, 75, 1, -1, 1, 13, 1, 9, 1, 71, 1, -1, 1, 40, 2, -1, 1, 35, 1, 75, 3, -1, 1, 75, 1, 13, 1, 35, 1, 75 ) ACCEPT = unpack( 2, -1, 1, 5, 3, -1, 1, 3, 1, -1, 1, 6, 1, 7, 2, -1, 1, 4, 1, 1, 1, 2, 4, -1 ) SPECIAL = unpack( 19, -1 ) TRANSITION = [ unpack( 1, 1, 39, -1, 1, 2 ), unpack( 2, 6, 1, -1, 1, 6, 1, 4, 1, 6, 4, -1, 1, 7, 2, -1, 1, 3, 2, -1, 1, 8, 27, -1, 1, 5, 9, -1, 1, 9 ), unpack( ), unpack( 1, 10 ), unpack( 1, 11 ), unpack( 1, 13, 4, -1, 2, 13, 1, -1, 1, 14, 1, 13, 1, -1, 1, 13, 3, -1, 1, 13, 20, -1, 1, 13, 30, -1, 1, 12 ), unpack( ), unpack( 1, 13, 4, -1, 2, 13, 1, -1, 1, 14, 1, 13, 1, -1, 1, 13, 3, -1, 1, 13, 20, -1, 1, 13 ), unpack( ), unpack( ), unpack( 1, 15 ), unpack( 2, 6, 1, -1, 1, 6, 1, 4, 1, 6, 4, -1, 1, 7, 2, -1, 1, 16, 2, -1, 1, 8, 27, -1, 1, 5, 9, -1, 1, 9 ), unpack( ), unpack( ), unpack( ), unpack( 2, 6, 1, -1, 1, 6, 1, 4, 1, 6, 4, -1, 1, 7, 5, -1, 1, 8, 27, -1, 1, 5, 9, -1, 1, 9 ), unpack( 1, 17 ), unpack( 1, 18 ), unpack( 2, 6, 1, -1, 1, 6, 1, 4, 1, 6, 4, -1, 1, 7, 5, -1, 1, 8, 27, -1, 1, 5, 9, -1, 1, 9 ) ].freeze ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z | if a > 0 and z < 0 MAX[ i ] %= 0x10000 end end @decision = 138 def description <<-'__dfa_description__'.strip! 802:1: mutation returns [key, val] : ( reference equals_op value | reference equals_op NULL | reference binary_op NUMBER | reference 'is' 'new' path ( object_body )? | 'delete' path | reference 'add(' value ')' | reference 'remove(' value ')' ); __dfa_description__ end end private def initialize_dfas super rescue nil @dfa41 = DFA41.new( self, 41 ) @dfa75 = DFA75.new( self, 75 ) @dfa102 = DFA102.new( self, 102 ) @dfa122 = DFA122.new( self, 122 ) @dfa138 = DFA138.new( self, 138 ) end TOKENS_FOLLOWING_NL_IN_sfp_49 = Set[ 1, 9, 11, 36, 39, 44, 59, 60, 64, 74, 76, 77, 79, 80 ] TOKENS_FOLLOWING_object_def_IN_sfp_57 = Set[ 1, 9, 11, 36, 39, 44, 59, 60, 64, 74, 76, 77, 79, 80 ] TOKENS_FOLLOWING_abstract_object_IN_sfp_61 = Set[ 1, 9, 11, 36, 39, 44, 59, 60, 64, 74, 76, 77, 79, 80 ] TOKENS_FOLLOWING_state_IN_sfp_65 = Set[ 1, 9, 11, 36, 39, 44, 59, 60, 64, 74, 76, 77, 79, 80 ] TOKENS_FOLLOWING_constraint_def_IN_sfp_69 = Set[ 1, 9, 11, 36, 39, 44, 59, 60, 64, 74, 76, 77, 79, 80 ] TOKENS_FOLLOWING_class_def_IN_sfp_73 = Set[ 1, 9, 11, 36, 39, 44, 59, 60, 64, 74, 76, 77, 79, 80 ] TOKENS_FOLLOWING_procedure_IN_sfp_77 = Set[ 1, 9, 11, 36, 39, 44, 59, 60, 64, 74, 76, 77, 79, 80 ] TOKENS_FOLLOWING_NL_IN_sfp_80 = Set[ 1, 9, 11, 36, 39, 44, 59, 60, 64, 74, 76, 77, 79, 80 ] TOKENS_FOLLOWING_include_IN_sfp_87 = Set[ 1, 9, 36, 39, 44, 59, 60, 64, 74, 76, 77, 79, 80 ] TOKENS_FOLLOWING_goal_constraint_IN_constraint_def_105 = Set[ 1 ] TOKENS_FOLLOWING_global_constraint_IN_constraint_def_110 = Set[ 1 ] TOKENS_FOLLOWING_sometime_constraint_IN_constraint_def_115 = Set[ 1 ] TOKENS_FOLLOWING_T__64_IN_include_126 = Set[ 15 ] TOKENS_FOLLOWING_include_file_IN_include_128 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_include_130 = Set[ 1, 11 ] TOKENS_FOLLOWING_STRING_IN_include_file_142 = Set[ 1 ] TOKENS_FOLLOWING_ID_IN_state_158 = Set[ 78 ] TOKENS_FOLLOWING_T__78_IN_state_160 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_state_162 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_state_171 = Set[ 9, 11, 55, 85 ] TOKENS_FOLLOWING_NL_IN_state_173 = Set[ 9, 11, 55, 85 ] TOKENS_FOLLOWING_attribute_IN_state_178 = Set[ 9, 55, 85 ] TOKENS_FOLLOWING_T__85_IN_state_183 = Set[ 1 ] TOKENS_FOLLOWING_set_IN_class_def_198 = Set[ 9 ] TOKENS_FOLLOWING_ID_IN_class_def_204 = Set[ 1, 54, 84 ] TOKENS_FOLLOWING_extends_class_IN_class_def_213 = Set[ 1, 84 ] TOKENS_FOLLOWING_T__84_IN_class_def_227 = Set[ 9, 11, 55, 74, 79, 80, 85 ] TOKENS_FOLLOWING_NL_IN_class_def_229 = Set[ 9, 11, 55, 74, 79, 80, 85 ] TOKENS_FOLLOWING_attribute_IN_class_def_234 = Set[ 9, 55, 74, 79, 80, 85 ] TOKENS_FOLLOWING_procedure_IN_class_def_238 = Set[ 9, 11, 55, 74, 79, 80, 85 ] TOKENS_FOLLOWING_NL_IN_class_def_240 = Set[ 9, 11, 55, 74, 79, 80, 85 ] TOKENS_FOLLOWING_T__85_IN_class_def_246 = Set[ 1 ] TOKENS_FOLLOWING_T__54_IN_extends_class_268 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_extends_class_270 = Set[ 1 ] TOKENS_FOLLOWING_T__55_IN_attribute_290 = Set[ 9 ] TOKENS_FOLLOWING_attribute_stmt_IN_attribute_296 = Set[ 1 ] TOKENS_FOLLOWING_T__55_IN_attribute_310 = Set[ 9 ] TOKENS_FOLLOWING_object_def_IN_attribute_316 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_attribute_318 = Set[ 1, 11 ] TOKENS_FOLLOWING_ID_IN_attribute_stmt_334 = Set[ 31, 65 ] TOKENS_FOLLOWING_equals_op_IN_attribute_stmt_336 = Set[ 4, 9, 10, 13, 15, 19, 40 ] TOKENS_FOLLOWING_value_IN_attribute_stmt_338 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_attribute_stmt_340 = Set[ 1, 11 ] TOKENS_FOLLOWING_ID_IN_attribute_stmt_350 = Set[ 69 ] TOKENS_FOLLOWING_reference_type_IN_attribute_stmt_352 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_attribute_stmt_354 = Set[ 1, 11 ] TOKENS_FOLLOWING_ID_IN_attribute_stmt_364 = Set[ 70 ] TOKENS_FOLLOWING_set_type_IN_attribute_stmt_366 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_attribute_stmt_368 = Set[ 1, 11 ] TOKENS_FOLLOWING_ID_IN_attribute_stmt_378 = Set[ 52 ] TOKENS_FOLLOWING_probability_op_IN_attribute_stmt_380 = Set[ 19 ] TOKENS_FOLLOWING_set_value_IN_attribute_stmt_382 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_attribute_stmt_384 = Set[ 1, 11 ] TOKENS_FOLLOWING_ID_IN_attribute_stmt_394 = Set[ 27 ] TOKENS_FOLLOWING_T__27_IN_attribute_stmt_396 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_attribute_stmt_398 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_attribute_stmt_400 = Set[ 1, 11 ] TOKENS_FOLLOWING_path_IN_object_schema_416 = Set[ 1, 34 ] TOKENS_FOLLOWING_T__34_IN_object_schema_418 = Set[ 13 ] TOKENS_FOLLOWING_NUMBER_IN_object_schema_420 = Set[ 35 ] TOKENS_FOLLOWING_T__35_IN_object_schema_424 = Set[ 1 ] TOKENS_FOLLOWING_T__23_IN_object_schemata_441 = Set[ 9 ] TOKENS_FOLLOWING_object_schema_IN_object_schemata_443 = Set[ 1 ] TOKENS_FOLLOWING_T__36_IN_abstract_object_454 = Set[ 9 ] TOKENS_FOLLOWING_object_def_IN_abstract_object_456 = Set[ 1 ] TOKENS_FOLLOWING_ID_IN_object_def_475 = Set[ 1, 54, 66, 84 ] TOKENS_FOLLOWING_T__54_IN_object_def_486 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_object_def_488 = Set[ 1, 66, 84 ] TOKENS_FOLLOWING_T__66_IN_object_def_506 = Set[ 9 ] TOKENS_FOLLOWING_object_schema_IN_object_def_508 = Set[ 1, 23, 84 ] TOKENS_FOLLOWING_object_schemata_IN_object_def_511 = Set[ 1, 23, 84 ] TOKENS_FOLLOWING_object_body_IN_object_def_520 = Set[ 1 ] TOKENS_FOLLOWING_T__84_IN_object_body_536 = Set[ 9, 11, 55, 74, 79, 80, 85 ] TOKENS_FOLLOWING_NL_IN_object_body_538 = Set[ 9, 11, 55, 74, 79, 80, 85 ] TOKENS_FOLLOWING_object_attribute_IN_object_body_543 = Set[ 9, 55, 74, 79, 80, 85 ] TOKENS_FOLLOWING_procedure_IN_object_body_547 = Set[ 9, 11, 55, 74, 79, 80, 85 ] TOKENS_FOLLOWING_NL_IN_object_body_549 = Set[ 9, 11, 55, 74, 79, 80, 85 ] TOKENS_FOLLOWING_T__85_IN_object_body_555 = Set[ 1 ] TOKENS_FOLLOWING_attribute_IN_object_attribute_566 = Set[ 1 ] TOKENS_FOLLOWING_ID_IN_object_attribute_571 = Set[ 31, 65 ] TOKENS_FOLLOWING_equals_op_IN_object_attribute_573 = Set[ 12 ] TOKENS_FOLLOWING_NULL_IN_object_attribute_575 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_object_attribute_577 = Set[ 1, 11 ] TOKENS_FOLLOWING_T__62_IN_state_dependency_593 = Set[ 9 ] TOKENS_FOLLOWING_dep_effect_IN_state_dependency_597 = Set[ 11, 81 ] TOKENS_FOLLOWING_NL_IN_state_dependency_599 = Set[ 11, 81 ] TOKENS_FOLLOWING_T__81_IN_state_dependency_602 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_state_dependency_604 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_state_dependency_607 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_state_dependency_611 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_state_dependency_614 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_state_dependency_619 = Set[ 11, 73 ] TOKENS_FOLLOWING_NL_IN_state_dependency_625 = Set[ 11, 73 ] TOKENS_FOLLOWING_T__73_IN_state_dependency_628 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_state_dependency_630 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_state_dependency_633 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_state_dependency_637 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_state_dependency_640 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_state_dependency_644 = Set[ 11, 73 ] TOKENS_FOLLOWING_NL_IN_state_dependency_650 = Set[ 1, 11 ] TOKENS_FOLLOWING_reference_IN_dep_effect_662 = Set[ 31, 65 ] TOKENS_FOLLOWING_equals_op_IN_dep_effect_664 = Set[ 4, 9, 10, 12, 13, 15, 19, 40 ] TOKENS_FOLLOWING_value_IN_dep_effect_671 = Set[ 1 ] TOKENS_FOLLOWING_NULL_IN_dep_effect_677 = Set[ 1 ] TOKENS_FOLLOWING_ID_IN_op_param_693 = Set[ 31, 65 ] TOKENS_FOLLOWING_equals_op_IN_op_param_695 = Set[ 9 ] TOKENS_FOLLOWING_reference_IN_op_param_697 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_op_param_699 = Set[ 1, 11 ] TOKENS_FOLLOWING_set_IN_op_conditions_715 = Set[ 84 ] TOKENS_FOLLOWING_T__84_IN_op_conditions_723 = Set[ 9, 11, 85 ] TOKENS_FOLLOWING_NL_IN_op_conditions_725 = Set[ 9, 11, 85 ] TOKENS_FOLLOWING_op_statement_IN_op_conditions_734 = Set[ 9, 85 ] TOKENS_FOLLOWING_T__85_IN_op_conditions_739 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_op_conditions_741 = Set[ 1, 11 ] TOKENS_FOLLOWING_T__51_IN_op_effects_757 = Set[ 84 ] TOKENS_FOLLOWING_T__84_IN_op_effects_759 = Set[ 9, 11, 85 ] TOKENS_FOLLOWING_NL_IN_op_effects_761 = Set[ 9, 11, 85 ] TOKENS_FOLLOWING_op_statement_IN_op_effects_770 = Set[ 9, 85 ] TOKENS_FOLLOWING_T__85_IN_op_effects_775 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_op_effects_777 = Set[ 1, 11 ] TOKENS_FOLLOWING_reference_IN_op_statement_793 = Set[ 31, 65 ] TOKENS_FOLLOWING_equals_op_IN_op_statement_795 = Set[ 4, 9, 10, 13, 15, 19, 40 ] TOKENS_FOLLOWING_value_IN_op_statement_797 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_op_statement_799 = Set[ 1, 11 ] TOKENS_FOLLOWING_T__80_IN_procedure_820 = Set[ 74, 79 ] TOKENS_FOLLOWING_set_IN_procedure_828 = Set[ 9 ] TOKENS_FOLLOWING_ID_IN_procedure_834 = Set[ 19, 84 ] TOKENS_FOLLOWING_parameters_IN_procedure_842 = Set[ 84 ] TOKENS_FOLLOWING_T__84_IN_procedure_845 = Set[ 11, 45, 46, 48, 50, 51 ] TOKENS_FOLLOWING_NL_IN_procedure_847 = Set[ 11, 45, 46, 48, 50, 51 ] TOKENS_FOLLOWING_T__48_IN_procedure_855 = Set[ 31, 65 ] TOKENS_FOLLOWING_equals_op_IN_procedure_857 = Set[ 13 ] TOKENS_FOLLOWING_NUMBER_IN_procedure_859 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_procedure_869 = Set[ 11, 45, 46, 50, 51 ] TOKENS_FOLLOWING_conditions_IN_procedure_879 = Set[ 50, 51 ] TOKENS_FOLLOWING_effects_IN_procedure_882 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_procedure_884 = Set[ 1 ] TOKENS_FOLLOWING_T__19_IN_parameters_899 = Set[ 9 ] TOKENS_FOLLOWING_parameter_IN_parameters_901 = Set[ 20, 23 ] TOKENS_FOLLOWING_T__23_IN_parameters_904 = Set[ 9, 11 ] TOKENS_FOLLOWING_NL_IN_parameters_906 = Set[ 9, 11 ] TOKENS_FOLLOWING_parameter_IN_parameters_909 = Set[ 20, 23 ] TOKENS_FOLLOWING_T__20_IN_parameters_913 = Set[ 1 ] TOKENS_FOLLOWING_ID_IN_parameter_925 = Set[ 27 ] TOKENS_FOLLOWING_T__27_IN_parameter_927 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_parameter_929 = Set[ 1 ] TOKENS_FOLLOWING_ID_IN_parameter_938 = Set[ 69 ] TOKENS_FOLLOWING_reference_type_IN_parameter_940 = Set[ 1 ] TOKENS_FOLLOWING_ID_IN_parameter_949 = Set[ 41 ] TOKENS_FOLLOWING_T__41_IN_parameter_951 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_parameter_953 = Set[ 1 ] TOKENS_FOLLOWING_ID_IN_parameter_962 = Set[ 70 ] TOKENS_FOLLOWING_T__70_IN_parameter_964 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_parameter_966 = Set[ 1 ] TOKENS_FOLLOWING_set_IN_conditions_981 = Set[ 84 ] TOKENS_FOLLOWING_T__84_IN_conditions_995 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_conditions_997 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_conditions_1000 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_conditions_1002 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_conditions_1004 = Set[ 1, 11 ] TOKENS_FOLLOWING_set_IN_effects_1021 = Set[ 84 ] TOKENS_FOLLOWING_T__84_IN_effects_1035 = Set[ 9, 11, 49, 57, 85 ] TOKENS_FOLLOWING_NL_IN_effects_1037 = Set[ 9, 11, 49, 57, 85 ] TOKENS_FOLLOWING_effect_body_IN_effects_1043 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_effects_1048 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_effects_1050 = Set[ 1, 11 ] TOKENS_FOLLOWING_T__60_IN_goal_constraint_1066 = Set[ 11, 47, 84 ] TOKENS_FOLLOWING_T__47_IN_goal_constraint_1068 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_goal_constraint_1071 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_goal_constraint_1080 = Set[ 9, 11, 38, 39, 43, 53, 56, 57, 58, 59, 62, 72, 77, 82, 83, 85 ] TOKENS_FOLLOWING_NL_IN_goal_constraint_1082 = Set[ 9, 11, 38, 39, 43, 53, 56, 57, 58, 59, 62, 72, 77, 82, 83, 85 ] TOKENS_FOLLOWING_goal_body_IN_goal_constraint_1085 = Set[ 9, 38, 39, 43, 53, 56, 57, 58, 59, 62, 72, 77, 82, 83, 85 ] TOKENS_FOLLOWING_T__85_IN_goal_constraint_1088 = Set[ 1 ] TOKENS_FOLLOWING_set_IN_global_constraint_1103 = Set[ 11, 47, 84 ] TOKENS_FOLLOWING_T__47_IN_global_constraint_1109 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_global_constraint_1112 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_global_constraint_1121 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_global_constraint_1123 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_global_constraint_1126 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_global_constraint_1128 = Set[ 1 ] TOKENS_FOLLOWING_T__77_IN_sometime_constraint_1143 = Set[ 11, 47, 84 ] TOKENS_FOLLOWING_T__47_IN_sometime_constraint_1145 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_sometime_constraint_1148 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_sometime_constraint_1157 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_sometime_constraint_1159 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_sometime_constraint_1162 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_sometime_constraint_1164 = Set[ 1 ] TOKENS_FOLLOWING_constraint_statement_IN_goal_body_1187 = Set[ 11 ] TOKENS_FOLLOWING_constraint_namespace_IN_goal_body_1200 = Set[ 11 ] TOKENS_FOLLOWING_constraint_iterator_IN_goal_body_1207 = Set[ 11 ] TOKENS_FOLLOWING_constraint_class_quantification_IN_goal_body_1214 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_goal_body_1223 = Set[ 1, 11 ] TOKENS_FOLLOWING_set_IN_goal_body_1230 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_goal_body_1236 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_goal_body_1245 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_goal_body_1247 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_goal_body_1250 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_goal_body_1252 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_goal_body_1254 = Set[ 1, 11 ] TOKENS_FOLLOWING_T__77_IN_goal_body_1264 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_goal_body_1266 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_goal_body_1275 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_goal_body_1277 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_goal_body_1280 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_goal_body_1282 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_goal_body_1284 = Set[ 1, 11 ] TOKENS_FOLLOWING_T__83_IN_goal_body_1298 = Set[ 13 ] TOKENS_FOLLOWING_NUMBER_IN_goal_body_1300 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_goal_body_1302 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_goal_body_1311 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_goal_body_1313 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_goal_body_1316 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_goal_body_1318 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_goal_body_1320 = Set[ 1, 11 ] TOKENS_FOLLOWING_T__38_IN_goal_body_1330 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_goal_body_1332 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_goal_body_1341 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_goal_body_1343 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_goal_body_1346 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_goal_body_1348 = Set[ 11, 81, 83 ] TOKENS_FOLLOWING_NL_IN_goal_body_1350 = Set[ 11, 81, 83 ] TOKENS_FOLLOWING_T__81_IN_goal_body_1361 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__83_IN_goal_body_1368 = Set[ 13 ] TOKENS_FOLLOWING_NUMBER_IN_goal_body_1370 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_goal_body_1382 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_goal_body_1391 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_goal_body_1393 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_goal_body_1396 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_goal_body_1398 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_goal_body_1400 = Set[ 1, 11 ] TOKENS_FOLLOWING_T__43_IN_goal_body_1418 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_goal_body_1420 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_goal_body_1429 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_goal_body_1431 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_goal_body_1434 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_goal_body_1436 = Set[ 11, 81 ] TOKENS_FOLLOWING_NL_IN_goal_body_1438 = Set[ 11, 81 ] TOKENS_FOLLOWING_T__81_IN_goal_body_1447 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_goal_body_1449 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_goal_body_1458 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_goal_body_1460 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_goal_body_1463 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_goal_body_1465 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_goal_body_1467 = Set[ 1, 11 ] TOKENS_FOLLOWING_T__84_IN_nested_constraint_1487 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_nested_constraint_1489 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_nested_constraint_1492 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_nested_constraint_1494 = Set[ 1 ] TOKENS_FOLLOWING_T__47_IN_constraint_1505 = Set[ 9 ] TOKENS_FOLLOWING_ID_IN_constraint_1507 = Set[ 84 ] TOKENS_FOLLOWING_T__84_IN_constraint_1515 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_constraint_1517 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_constraint_1520 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_constraint_1522 = Set[ 1 ] TOKENS_FOLLOWING_constraint_statement_IN_constraint_body_1544 = Set[ 11 ] TOKENS_FOLLOWING_constraint_namespace_IN_constraint_body_1557 = Set[ 11 ] TOKENS_FOLLOWING_constraint_iterator_IN_constraint_body_1564 = Set[ 11 ] TOKENS_FOLLOWING_constraint_class_quantification_IN_constraint_body_1571 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_constraint_body_1580 = Set[ 1, 9, 11, 53, 56, 57, 58, 62, 72, 82 ] TOKENS_FOLLOWING_path_IN_constraint_namespace_1594 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_constraint_namespace_1596 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_constraint_namespace_1599 = Set[ 9, 11, 62, 72, 82, 85 ] TOKENS_FOLLOWING_NL_IN_constraint_namespace_1601 = Set[ 9, 11, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_statement_IN_constraint_namespace_1605 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_constraint_namespace_1613 = Set[ 9, 11, 62, 72, 82, 85 ] TOKENS_FOLLOWING_T__85_IN_constraint_namespace_1618 = Set[ 1 ] TOKENS_FOLLOWING_T__57_IN_constraint_iterator_1629 = Set[ 19 ] TOKENS_FOLLOWING_T__19_IN_constraint_iterator_1631 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_constraint_iterator_1633 = Set[ 42 ] TOKENS_FOLLOWING_T__42_IN_constraint_iterator_1635 = Set[ 9 ] TOKENS_FOLLOWING_ID_IN_constraint_iterator_1637 = Set[ 20 ] TOKENS_FOLLOWING_T__20_IN_constraint_iterator_1639 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_constraint_iterator_1641 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_constraint_iterator_1644 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_constraint_iterator_1646 = Set[ 9, 11, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_statement_IN_constraint_iterator_1656 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_constraint_iterator_1664 = Set[ 9, 11, 62, 72, 82, 85 ] TOKENS_FOLLOWING_T__85_IN_constraint_iterator_1671 = Set[ 1 ] TOKENS_FOLLOWING_quantification_keyword_IN_constraint_class_quantification_1707 = Set[ 19 ] TOKENS_FOLLOWING_T__19_IN_constraint_class_quantification_1709 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_constraint_class_quantification_1711 = Set[ 42 ] TOKENS_FOLLOWING_T__42_IN_constraint_class_quantification_1713 = Set[ 9 ] TOKENS_FOLLOWING_ID_IN_constraint_class_quantification_1715 = Set[ 20 ] TOKENS_FOLLOWING_T__20_IN_constraint_class_quantification_1717 = Set[ 11, 29, 30, 31, 32, 33, 84 ] TOKENS_FOLLOWING_binary_comp_IN_constraint_class_quantification_1729 = Set[ 13 ] TOKENS_FOLLOWING_T__31_IN_constraint_class_quantification_1742 = Set[ 13 ] TOKENS_FOLLOWING_NUMBER_IN_constraint_class_quantification_1758 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1772 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_constraint_class_quantification_1775 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1777 = Set[ 9, 11, 28, 57, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_statement_IN_constraint_class_quantification_1784 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1794 = Set[ 9, 11, 28, 57, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_different_IN_constraint_class_quantification_1801 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1803 = Set[ 9, 11, 28, 57, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_iterator_IN_constraint_class_quantification_1810 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1812 = Set[ 9, 11, 28, 57, 62, 72, 82, 85 ] TOKENS_FOLLOWING_T__85_IN_constraint_class_quantification_1820 = Set[ 1 ] TOKENS_FOLLOWING_T__28_IN_constraint_different_1839 = Set[ 19 ] TOKENS_FOLLOWING_T__19_IN_constraint_different_1841 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_constraint_different_1843 = Set[ 20 ] TOKENS_FOLLOWING_T__20_IN_constraint_different_1845 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_constraint_statement_1864 = Set[ 1 ] TOKENS_FOLLOWING_T__72_IN_constraint_statement_1873 = Set[ 9 ] TOKENS_FOLLOWING_reference_IN_constraint_statement_1875 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_constraint_statement_1884 = Set[ 31, 65 ] TOKENS_FOLLOWING_equals_op_IN_constraint_statement_1886 = Set[ 4, 9, 10, 13, 15, 19, 40 ] TOKENS_FOLLOWING_value_IN_constraint_statement_1888 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_constraint_statement_1897 = Set[ 31, 65 ] TOKENS_FOLLOWING_equals_op_IN_constraint_statement_1899 = Set[ 12 ] TOKENS_FOLLOWING_NULL_IN_constraint_statement_1901 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_constraint_statement_1910 = Set[ 18, 67, 68 ] TOKENS_FOLLOWING_not_equals_op_IN_constraint_statement_1912 = Set[ 4, 9, 10, 13, 15, 19, 40 ] TOKENS_FOLLOWING_value_IN_constraint_statement_1914 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_constraint_statement_1923 = Set[ 18, 67, 68 ] TOKENS_FOLLOWING_not_equals_op_IN_constraint_statement_1925 = Set[ 12 ] TOKENS_FOLLOWING_NULL_IN_constraint_statement_1927 = Set[ 1 ] TOKENS_FOLLOWING_conditional_constraint_IN_constraint_statement_1936 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_constraint_statement_1945 = Set[ 63, 65 ] TOKENS_FOLLOWING_T__65_IN_constraint_statement_1947 = Set[ 63 ] TOKENS_FOLLOWING_T__63_IN_constraint_statement_1950 = Set[ 19 ] TOKENS_FOLLOWING_set_value_IN_constraint_statement_1952 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_constraint_statement_1961 = Set[ 67, 68, 72 ] TOKENS_FOLLOWING_set_IN_constraint_statement_1963 = Set[ 63 ] TOKENS_FOLLOWING_T__63_IN_constraint_statement_1971 = Set[ 19 ] TOKENS_FOLLOWING_set_value_IN_constraint_statement_1973 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_constraint_statement_1982 = Set[ 61 ] TOKENS_FOLLOWING_T__61_IN_constraint_statement_1984 = Set[ 4, 9, 10, 13, 15, 19, 40 ] TOKENS_FOLLOWING_value_IN_constraint_statement_1986 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_constraint_statement_1995 = Set[ 29, 30, 32, 33 ] TOKENS_FOLLOWING_binary_comp_IN_constraint_statement_1997 = Set[ 9, 13 ] TOKENS_FOLLOWING_comp_value_IN_constraint_statement_1999 = Set[ 1 ] TOKENS_FOLLOWING_total_constraint_IN_constraint_statement_2008 = Set[ 1 ] TOKENS_FOLLOWING_T__82_IN_total_constraint_2019 = Set[ 9 ] TOKENS_FOLLOWING_total_statement_IN_total_constraint_2021 = Set[ 20 ] TOKENS_FOLLOWING_T__20_IN_total_constraint_2023 = Set[ 29, 30, 32, 33 ] TOKENS_FOLLOWING_binary_comp_IN_total_constraint_2025 = Set[ 13 ] TOKENS_FOLLOWING_NUMBER_IN_total_constraint_2027 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_total_statement_2038 = Set[ 31, 65 ] TOKENS_FOLLOWING_equals_op_IN_total_statement_2040 = Set[ 4, 9, 10, 13, 15, 19, 40 ] TOKENS_FOLLOWING_value_IN_total_statement_2042 = Set[ 1 ] TOKENS_FOLLOWING_NUMBER_IN_comp_value_2057 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_comp_value_2066 = Set[ 1 ] TOKENS_FOLLOWING_T__62_IN_conditional_constraint_2085 = Set[ 9, 62, 72, 82, 84 ] TOKENS_FOLLOWING_conditional_constraint_if_part_IN_conditional_constraint_2093 = Set[ 81 ] TOKENS_FOLLOWING_conditional_constraint_then_part_IN_conditional_constraint_2097 = Set[ 1 ] TOKENS_FOLLOWING_constraint_statement_IN_conditional_constraint_if_part_2112 = Set[ 1, 11 ] TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2114 = Set[ 1, 11 ] TOKENS_FOLLOWING_T__84_IN_conditional_constraint_if_part_2124 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2132 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_conditional_constraint_if_part_2135 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_conditional_constraint_if_part_2139 = Set[ 1, 11 ] TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2141 = Set[ 1, 11 ] TOKENS_FOLLOWING_T__81_IN_conditional_constraint_then_part_2157 = Set[ 9, 62, 72, 82 ] TOKENS_FOLLOWING_constraint_statement_IN_conditional_constraint_then_part_2159 = Set[ 1 ] TOKENS_FOLLOWING_T__81_IN_conditional_constraint_then_part_2168 = Set[ 84 ] TOKENS_FOLLOWING_T__84_IN_conditional_constraint_then_part_2176 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_conditional_constraint_then_part_2178 = Set[ 9, 11, 53, 56, 57, 58, 62, 72, 82, 85 ] TOKENS_FOLLOWING_constraint_body_IN_conditional_constraint_then_part_2181 = Set[ 85 ] TOKENS_FOLLOWING_T__85_IN_conditional_constraint_then_part_2183 = Set[ 1 ] TOKENS_FOLLOWING_mutation_IN_effect_body_2205 = Set[ 11 ] TOKENS_FOLLOWING_mutation_iterator_IN_effect_body_2218 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_effect_body_2227 = Set[ 1, 9, 11, 49, 57 ] TOKENS_FOLLOWING_T__57_IN_mutation_iterator_2242 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_mutation_iterator_2244 = Set[ 42 ] TOKENS_FOLLOWING_T__42_IN_mutation_iterator_2246 = Set[ 9 ] TOKENS_FOLLOWING_ID_IN_mutation_iterator_2248 = Set[ 11, 84 ] TOKENS_FOLLOWING_NL_IN_mutation_iterator_2250 = Set[ 11, 84 ] TOKENS_FOLLOWING_T__84_IN_mutation_iterator_2253 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_mutation_iterator_2255 = Set[ 9, 11, 49, 85 ] TOKENS_FOLLOWING_mutation_IN_mutation_iterator_2265 = Set[ 11 ] TOKENS_FOLLOWING_NL_IN_mutation_iterator_2273 = Set[ 9, 11, 49, 85 ] TOKENS_FOLLOWING_T__85_IN_mutation_iterator_2280 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_mutation_2299 = Set[ 31, 65 ] TOKENS_FOLLOWING_equals_op_IN_mutation_2301 = Set[ 4, 9, 10, 13, 15, 19, 40 ] TOKENS_FOLLOWING_value_IN_mutation_2303 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_mutation_2312 = Set[ 31, 65 ] TOKENS_FOLLOWING_equals_op_IN_mutation_2314 = Set[ 12 ] TOKENS_FOLLOWING_NULL_IN_mutation_2316 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_mutation_2325 = Set[ 21, 22, 24, 26 ] TOKENS_FOLLOWING_binary_op_IN_mutation_2327 = Set[ 13 ] TOKENS_FOLLOWING_NUMBER_IN_mutation_2329 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_mutation_2338 = Set[ 65 ] TOKENS_FOLLOWING_T__65_IN_mutation_2340 = Set[ 71 ] TOKENS_FOLLOWING_T__71_IN_mutation_2342 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_mutation_2344 = Set[ 1, 84 ] TOKENS_FOLLOWING_object_body_IN_mutation_2352 = Set[ 1 ] TOKENS_FOLLOWING_T__49_IN_mutation_2362 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_mutation_2364 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_mutation_2373 = Set[ 37 ] TOKENS_FOLLOWING_T__37_IN_mutation_2375 = Set[ 4, 9, 10, 13, 15, 19, 40 ] TOKENS_FOLLOWING_value_IN_mutation_2377 = Set[ 20 ] TOKENS_FOLLOWING_T__20_IN_mutation_2379 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_mutation_2388 = Set[ 75 ] TOKENS_FOLLOWING_T__75_IN_mutation_2390 = Set[ 4, 9, 10, 13, 15, 19, 40 ] TOKENS_FOLLOWING_value_IN_mutation_2392 = Set[ 20 ] TOKENS_FOLLOWING_T__20_IN_mutation_2394 = Set[ 1 ] TOKENS_FOLLOWING_T__19_IN_set_value_2413 = Set[ 4, 9, 10, 13, 15, 19, 20, 40 ] TOKENS_FOLLOWING_set_item_IN_set_value_2422 = Set[ 20, 23 ] TOKENS_FOLLOWING_T__23_IN_set_value_2425 = Set[ 4, 9, 10, 11, 13, 15, 19, 40 ] TOKENS_FOLLOWING_NL_IN_set_value_2427 = Set[ 4, 9, 10, 11, 13, 15, 19, 40 ] TOKENS_FOLLOWING_set_item_IN_set_value_2430 = Set[ 20, 23 ] TOKENS_FOLLOWING_T__20_IN_set_value_2442 = Set[ 1 ] TOKENS_FOLLOWING_value_IN_set_item_2453 = Set[ 1 ] TOKENS_FOLLOWING_primitive_value_IN_value_2472 = Set[ 1 ] TOKENS_FOLLOWING_reference_IN_value_2481 = Set[ 1 ] TOKENS_FOLLOWING_set_value_IN_value_2490 = Set[ 1 ] TOKENS_FOLLOWING_T__40_IN_value_2499 = Set[ 1 ] TOKENS_FOLLOWING_BOOLEAN_IN_primitive_value_2518 = Set[ 1 ] TOKENS_FOLLOWING_NUMBER_IN_primitive_value_2527 = Set[ 1 ] TOKENS_FOLLOWING_STRING_IN_primitive_value_2536 = Set[ 1 ] TOKENS_FOLLOWING_MULTILINE_STRING_IN_primitive_value_2545 = Set[ 1 ] TOKENS_FOLLOWING_ID_IN_path_2560 = Set[ 1, 25 ] TOKENS_FOLLOWING_T__25_IN_path_2562 = Set[ 9 ] TOKENS_FOLLOWING_ID_IN_path_2563 = Set[ 1, 25 ] TOKENS_FOLLOWING_id_ref_IN_path_with_index_2576 = Set[ 1, 25 ] TOKENS_FOLLOWING_T__25_IN_path_with_index_2578 = Set[ 9 ] TOKENS_FOLLOWING_id_ref_IN_path_with_index_2579 = Set[ 1, 25 ] TOKENS_FOLLOWING_ID_IN_id_ref_2592 = Set[ 1, 34 ] TOKENS_FOLLOWING_T__34_IN_id_ref_2594 = Set[ 13 ] TOKENS_FOLLOWING_NUMBER_IN_id_ref_2596 = Set[ 35 ] TOKENS_FOLLOWING_T__35_IN_id_ref_2598 = Set[ 1 ] TOKENS_FOLLOWING_path_with_index_IN_reference_2615 = Set[ 1 ] TOKENS_FOLLOWING_T__69_IN_reference_type_2634 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_reference_type_2636 = Set[ 1 ] TOKENS_FOLLOWING_T__70_IN_set_type_2655 = Set[ 9 ] TOKENS_FOLLOWING_path_IN_set_type_2657 = Set[ 1 ] TOKENS_FOLLOWING_T__52_IN_probability_op_2672 = Set[ 1 ] end # class Parser < ANTLR3::Parser at_exit { Parser.main( ARGV ) } if __FILE__ == $0 end