class SfpLang::Parser

Constants

AbstractObjectReturnValue
AssignmentReturnValue
AttributeReturnValue
BinaryCompReturnValue
BinaryOpReturnValue
ClassDefReturnValue
CompValueReturnValue
ConditionalConstraintIfPartReturnValue
ConditionalConstraintReturnValue
ConditionalConstraintThenPartReturnValue
ConditionsReturnValue
ConstraintBodyReturnValue
ConstraintClassQuantificationReturnValue
ConstraintDefReturnValue
ConstraintDifferentReturnValue
ConstraintIteratorReturnValue
ConstraintNamespaceReturnValue
ConstraintReturnValue
ConstraintStatementReturnValue
DepEffectReturnValue
EffectBodyReturnValue
EffectsReturnValue
EqualsOpReturnValue
ExtendsClassReturnValue
GlobalConstraintReturnValue
GoalBodyReturnValue
GoalConstraintReturnValue
IdRefReturnValue
IncludeFileReturnValue
IncludeReturnValue
MutationIteratorReturnValue
MutationReturnValue
NestedConstraintReturnValue
NotEqualsOpReturnValue
ObjectAttributeReturnValue
ObjectBodyReturnValue
ObjectDefReturnValue
ObjectSchemaReturnValue
ObjectSchemataReturnValue
OpConditionsReturnValue
OpEffectsReturnValue
OpParamReturnValue
OpStatementReturnValue
ParameterReturnValue
ParametersReturnValue
PathReturnValue
PathWithIndexReturnValue
PlacementReturnValue
PrimitiveValueReturnValue
ProbabilityOpReturnValue
ProcedureReturnValue
QuantificationKeywordReturnValue
RULE_METHODS
ReferenceReturnValue
ReferenceTypeReturnValue
SetItemReturnValue
SetTypeReturnValue
SetValueReturnValue
SfpReturnValue
                        • Rules - - - - - - - - - - - - -

SometimeConstraintReturnValue
StateDependencyReturnValue
StateReturnValue
TOKENS_FOLLOWING_BOOLEAN_IN_primitive_value_2556
TOKENS_FOLLOWING_ID_IN_attribute_332
TOKENS_FOLLOWING_ID_IN_class_def_238
TOKENS_FOLLOWING_ID_IN_constraint_1537
TOKENS_FOLLOWING_ID_IN_constraint_class_quantification_1745
TOKENS_FOLLOWING_ID_IN_constraint_iterator_1667
TOKENS_FOLLOWING_ID_IN_id_ref_2630
TOKENS_FOLLOWING_ID_IN_mutation_iterator_2278
TOKENS_FOLLOWING_ID_IN_object_attribute_601
TOKENS_FOLLOWING_ID_IN_object_def_505
TOKENS_FOLLOWING_ID_IN_op_param_723
TOKENS_FOLLOWING_ID_IN_parameter_955
TOKENS_FOLLOWING_ID_IN_parameter_968
TOKENS_FOLLOWING_ID_IN_parameter_979
TOKENS_FOLLOWING_ID_IN_parameter_992
TOKENS_FOLLOWING_ID_IN_path_2598
TOKENS_FOLLOWING_ID_IN_path_2601
TOKENS_FOLLOWING_ID_IN_procedure_864
TOKENS_FOLLOWING_ID_IN_state_192
TOKENS_FOLLOWING_MULTILINE_STRING_IN_primitive_value_2583
TOKENS_FOLLOWING_NL_IN_assignment_374
TOKENS_FOLLOWING_NL_IN_assignment_386
TOKENS_FOLLOWING_NL_IN_assignment_398
TOKENS_FOLLOWING_NL_IN_assignment_412
TOKENS_FOLLOWING_NL_IN_assignment_426
TOKENS_FOLLOWING_NL_IN_attribute_357
TOKENS_FOLLOWING_NL_IN_class_def_263
TOKENS_FOLLOWING_NL_IN_class_def_274
TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2144
TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2162
TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2171
TOKENS_FOLLOWING_NL_IN_conditional_constraint_then_part_2208
TOKENS_FOLLOWING_NL_IN_conditions_1027
TOKENS_FOLLOWING_NL_IN_conditions_1034
TOKENS_FOLLOWING_NL_IN_constraint_1547
TOKENS_FOLLOWING_NL_IN_constraint_body_1610
TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1802
TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1807
TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1824
TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1833
TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1842
TOKENS_FOLLOWING_NL_IN_constraint_iterator_1671
TOKENS_FOLLOWING_NL_IN_constraint_iterator_1676
TOKENS_FOLLOWING_NL_IN_constraint_iterator_1694
TOKENS_FOLLOWING_NL_IN_constraint_namespace_1626
TOKENS_FOLLOWING_NL_IN_constraint_namespace_1631
TOKENS_FOLLOWING_NL_IN_constraint_namespace_1643
TOKENS_FOLLOWING_NL_IN_effect_body_2257
TOKENS_FOLLOWING_NL_IN_effects_1067
TOKENS_FOLLOWING_NL_IN_effects_1080
TOKENS_FOLLOWING_NL_IN_global_constraint_1142
TOKENS_FOLLOWING_NL_IN_global_constraint_1153
TOKENS_FOLLOWING_NL_IN_goal_body_1253
TOKENS_FOLLOWING_NL_IN_goal_body_1266
TOKENS_FOLLOWING_NL_IN_goal_body_1277
TOKENS_FOLLOWING_NL_IN_goal_body_1284
TOKENS_FOLLOWING_NL_IN_goal_body_1296
TOKENS_FOLLOWING_NL_IN_goal_body_1307
TOKENS_FOLLOWING_NL_IN_goal_body_1314
TOKENS_FOLLOWING_NL_IN_goal_body_1332
TOKENS_FOLLOWING_NL_IN_goal_body_1343
TOKENS_FOLLOWING_NL_IN_goal_body_1350
TOKENS_FOLLOWING_NL_IN_goal_body_1362
TOKENS_FOLLOWING_NL_IN_goal_body_1373
TOKENS_FOLLOWING_NL_IN_goal_body_1380
TOKENS_FOLLOWING_NL_IN_goal_body_1412
TOKENS_FOLLOWING_NL_IN_goal_body_1423
TOKENS_FOLLOWING_NL_IN_goal_body_1430
TOKENS_FOLLOWING_NL_IN_goal_body_1450
TOKENS_FOLLOWING_NL_IN_goal_body_1461
TOKENS_FOLLOWING_NL_IN_goal_body_1468
TOKENS_FOLLOWING_NL_IN_goal_body_1479
TOKENS_FOLLOWING_NL_IN_goal_body_1490
TOKENS_FOLLOWING_NL_IN_goal_body_1497
TOKENS_FOLLOWING_NL_IN_goal_constraint_1101
TOKENS_FOLLOWING_NL_IN_goal_constraint_1112
TOKENS_FOLLOWING_NL_IN_include_164
TOKENS_FOLLOWING_NL_IN_mutation_iterator_2280
TOKENS_FOLLOWING_NL_IN_mutation_iterator_2285
TOKENS_FOLLOWING_NL_IN_mutation_iterator_2303
TOKENS_FOLLOWING_NL_IN_nested_constraint_1519
TOKENS_FOLLOWING_NL_IN_object_attribute_607
TOKENS_FOLLOWING_NL_IN_object_body_568
TOKENS_FOLLOWING_NL_IN_object_body_579
TOKENS_FOLLOWING_NL_IN_op_conditions_755
TOKENS_FOLLOWING_NL_IN_op_conditions_771
TOKENS_FOLLOWING_NL_IN_op_effects_791
TOKENS_FOLLOWING_NL_IN_op_effects_807
TOKENS_FOLLOWING_NL_IN_op_param_729
TOKENS_FOLLOWING_NL_IN_op_statement_829
TOKENS_FOLLOWING_NL_IN_parameters_936
TOKENS_FOLLOWING_NL_IN_procedure_877
TOKENS_FOLLOWING_NL_IN_procedure_899
TOKENS_FOLLOWING_NL_IN_set_value_2461
TOKENS_FOLLOWING_NL_IN_sfp_49
TOKENS_FOLLOWING_NL_IN_sfp_80
TOKENS_FOLLOWING_NL_IN_sometime_constraint_1178
TOKENS_FOLLOWING_NL_IN_sometime_constraint_1189
TOKENS_FOLLOWING_NL_IN_state_196
TOKENS_FOLLOWING_NL_IN_state_207
TOKENS_FOLLOWING_NL_IN_state_dependency_629
TOKENS_FOLLOWING_NL_IN_state_dependency_634
TOKENS_FOLLOWING_NL_IN_state_dependency_641
TOKENS_FOLLOWING_NL_IN_state_dependency_655
TOKENS_FOLLOWING_NL_IN_state_dependency_660
TOKENS_FOLLOWING_NL_IN_state_dependency_667
TOKENS_FOLLOWING_NL_IN_state_dependency_680
TOKENS_FOLLOWING_NULL_IN_constraint_statement_1931
TOKENS_FOLLOWING_NULL_IN_constraint_statement_1957
TOKENS_FOLLOWING_NULL_IN_dep_effect_707
TOKENS_FOLLOWING_NULL_IN_mutation_2346
TOKENS_FOLLOWING_NULL_IN_object_attribute_605
TOKENS_FOLLOWING_NUMBER_IN_comp_value_2087
TOKENS_FOLLOWING_NUMBER_IN_constraint_class_quantification_1788
TOKENS_FOLLOWING_NUMBER_IN_goal_body_1330
TOKENS_FOLLOWING_NUMBER_IN_goal_body_1400
TOKENS_FOLLOWING_NUMBER_IN_id_ref_2634
TOKENS_FOLLOWING_NUMBER_IN_mutation_2359
TOKENS_FOLLOWING_NUMBER_IN_object_schema_446
TOKENS_FOLLOWING_NUMBER_IN_primitive_value_2565
TOKENS_FOLLOWING_NUMBER_IN_procedure_889
TOKENS_FOLLOWING_NUMBER_IN_total_constraint_2057
TOKENS_FOLLOWING_STRING_IN_include_file_176
TOKENS_FOLLOWING_STRING_IN_primitive_value_2574
TOKENS_FOLLOWING_T__18_IN_placement_113
TOKENS_FOLLOWING_T__20_IN_constraint_class_quantification_1739
TOKENS_FOLLOWING_T__20_IN_constraint_different_1871
TOKENS_FOLLOWING_T__20_IN_constraint_iterator_1661
TOKENS_FOLLOWING_T__20_IN_parameters_929
TOKENS_FOLLOWING_T__21_IN_constraint_class_quantification_1747
TOKENS_FOLLOWING_T__21_IN_constraint_different_1875
TOKENS_FOLLOWING_T__21_IN_constraint_iterator_1669
TOKENS_FOLLOWING_T__21_IN_mutation_2409
TOKENS_FOLLOWING_T__21_IN_mutation_2424
TOKENS_FOLLOWING_T__21_IN_parameters_943
TOKENS_FOLLOWING_T__21_IN_total_constraint_2053
TOKENS_FOLLOWING_T__24_IN_object_schemata_467
TOKENS_FOLLOWING_T__24_IN_parameters_934
TOKENS_FOLLOWING_T__24_IN_set_value_2459
TOKENS_FOLLOWING_T__26_IN_path_2600
TOKENS_FOLLOWING_T__26_IN_path_with_index_2616
TOKENS_FOLLOWING_T__28_IN_assignment_422
TOKENS_FOLLOWING_T__28_IN_parameter_957
TOKENS_FOLLOWING_T__29_IN_constraint_different_1869
TOKENS_FOLLOWING_T__32_IN_constraint_class_quantification_1772
TOKENS_FOLLOWING_T__35_IN_id_ref_2632
TOKENS_FOLLOWING_T__35_IN_object_schema_444
TOKENS_FOLLOWING_T__36_IN_id_ref_2636
TOKENS_FOLLOWING_T__36_IN_object_schema_450
TOKENS_FOLLOWING_T__37_IN_abstract_object_484
TOKENS_FOLLOWING_T__38_IN_mutation_2405
TOKENS_FOLLOWING_T__39_IN_goal_body_1360
TOKENS_FOLLOWING_T__41_IN_value_2537
TOKENS_FOLLOWING_T__42_IN_parameter_981
TOKENS_FOLLOWING_T__43_IN_constraint_class_quantification_1743
TOKENS_FOLLOWING_T__43_IN_constraint_iterator_1665
TOKENS_FOLLOWING_T__43_IN_mutation_iterator_2276
TOKENS_FOLLOWING_T__44_IN_goal_body_1448
TOKENS_FOLLOWING_T__48_IN_constraint_1535
TOKENS_FOLLOWING_T__48_IN_global_constraint_1139
TOKENS_FOLLOWING_T__48_IN_goal_constraint_1098
TOKENS_FOLLOWING_T__48_IN_sometime_constraint_1175
TOKENS_FOLLOWING_T__49_IN_procedure_885
TOKENS_FOLLOWING_T__50_IN_mutation_2392
TOKENS_FOLLOWING_T__52_IN_op_effects_787
TOKENS_FOLLOWING_T__53_IN_probability_op_2710
TOKENS_FOLLOWING_T__55_IN_extends_class_302
TOKENS_FOLLOWING_T__55_IN_object_def_516
TOKENS_FOLLOWING_T__56_IN_attribute_324
TOKENS_FOLLOWING_T__56_IN_attribute_349
TOKENS_FOLLOWING_T__58_IN_constraint_iterator_1659
TOKENS_FOLLOWING_T__58_IN_mutation_iterator_2272
TOKENS_FOLLOWING_T__61_IN_goal_constraint_1096
TOKENS_FOLLOWING_T__62_IN_constraint_statement_2014
TOKENS_FOLLOWING_T__63_IN_conditional_constraint_2115
TOKENS_FOLLOWING_T__63_IN_state_dependency_623
TOKENS_FOLLOWING_T__64_IN_constraint_statement_1980
TOKENS_FOLLOWING_T__64_IN_constraint_statement_2001
TOKENS_FOLLOWING_T__65_IN_include_160
TOKENS_FOLLOWING_T__66_IN_constraint_statement_1977
TOKENS_FOLLOWING_T__66_IN_mutation_2370
TOKENS_FOLLOWING_T__67_IN_object_def_536
TOKENS_FOLLOWING_T__70_IN_reference_type_2672
TOKENS_FOLLOWING_T__71_IN_parameter_994
TOKENS_FOLLOWING_T__71_IN_set_type_2693
TOKENS_FOLLOWING_T__72_IN_mutation_2372
TOKENS_FOLLOWING_T__73_IN_constraint_statement_1903
TOKENS_FOLLOWING_T__74_IN_state_dependency_658
TOKENS_FOLLOWING_T__76_IN_mutation_2420
TOKENS_FOLLOWING_T__78_IN_goal_body_1294
TOKENS_FOLLOWING_T__78_IN_sometime_constraint_1173
TOKENS_FOLLOWING_T__79_IN_state_194
TOKENS_FOLLOWING_T__81_IN_procedure_850
TOKENS_FOLLOWING_T__82_IN_conditional_constraint_then_part_2187
TOKENS_FOLLOWING_T__82_IN_conditional_constraint_then_part_2198
TOKENS_FOLLOWING_T__82_IN_goal_body_1391
TOKENS_FOLLOWING_T__82_IN_goal_body_1477
TOKENS_FOLLOWING_T__82_IN_state_dependency_632
TOKENS_FOLLOWING_T__83_IN_total_constraint_2049
TOKENS_FOLLOWING_T__84_IN_goal_body_1328
TOKENS_FOLLOWING_T__84_IN_goal_body_1398
TOKENS_FOLLOWING_T__85_IN_class_def_261
TOKENS_FOLLOWING_T__85_IN_conditional_constraint_if_part_2154
TOKENS_FOLLOWING_T__85_IN_conditional_constraint_then_part_2206
TOKENS_FOLLOWING_T__85_IN_conditions_1025
TOKENS_FOLLOWING_T__85_IN_constraint_1545
TOKENS_FOLLOWING_T__85_IN_constraint_class_quantification_1805
TOKENS_FOLLOWING_T__85_IN_constraint_iterator_1674
TOKENS_FOLLOWING_T__85_IN_constraint_namespace_1629
TOKENS_FOLLOWING_T__85_IN_effects_1065
TOKENS_FOLLOWING_T__85_IN_global_constraint_1151
TOKENS_FOLLOWING_T__85_IN_goal_body_1275
TOKENS_FOLLOWING_T__85_IN_goal_body_1305
TOKENS_FOLLOWING_T__85_IN_goal_body_1341
TOKENS_FOLLOWING_T__85_IN_goal_body_1371
TOKENS_FOLLOWING_T__85_IN_goal_body_1421
TOKENS_FOLLOWING_T__85_IN_goal_body_1459
TOKENS_FOLLOWING_T__85_IN_goal_body_1488
TOKENS_FOLLOWING_T__85_IN_goal_constraint_1110
TOKENS_FOLLOWING_T__85_IN_mutation_iterator_2283
TOKENS_FOLLOWING_T__85_IN_nested_constraint_1517
TOKENS_FOLLOWING_T__85_IN_object_body_566
TOKENS_FOLLOWING_T__85_IN_op_conditions_753
TOKENS_FOLLOWING_T__85_IN_op_effects_789
TOKENS_FOLLOWING_T__85_IN_procedure_875
TOKENS_FOLLOWING_T__85_IN_sometime_constraint_1187
TOKENS_FOLLOWING_T__85_IN_state_205
TOKENS_FOLLOWING_T__85_IN_state_dependency_637
TOKENS_FOLLOWING_T__85_IN_state_dependency_663
TOKENS_FOLLOWING_T__86_IN_class_def_280
TOKENS_FOLLOWING_T__86_IN_conditional_constraint_if_part_2169
TOKENS_FOLLOWING_T__86_IN_conditional_constraint_then_part_2213
TOKENS_FOLLOWING_T__86_IN_conditions_1032
TOKENS_FOLLOWING_T__86_IN_constraint_1552
TOKENS_FOLLOWING_T__86_IN_constraint_class_quantification_1850
TOKENS_FOLLOWING_T__86_IN_constraint_iterator_1701
TOKENS_FOLLOWING_T__86_IN_constraint_namespace_1648
TOKENS_FOLLOWING_T__86_IN_effects_1078
TOKENS_FOLLOWING_T__86_IN_global_constraint_1158
TOKENS_FOLLOWING_T__86_IN_goal_body_1282
TOKENS_FOLLOWING_T__86_IN_goal_body_1312
TOKENS_FOLLOWING_T__86_IN_goal_body_1348
TOKENS_FOLLOWING_T__86_IN_goal_body_1378
TOKENS_FOLLOWING_T__86_IN_goal_body_1428
TOKENS_FOLLOWING_T__86_IN_goal_body_1466
TOKENS_FOLLOWING_T__86_IN_goal_body_1495
TOKENS_FOLLOWING_T__86_IN_goal_constraint_1118
TOKENS_FOLLOWING_T__86_IN_mutation_iterator_2310
TOKENS_FOLLOWING_T__86_IN_nested_constraint_1524
TOKENS_FOLLOWING_T__86_IN_object_body_585
TOKENS_FOLLOWING_T__86_IN_op_conditions_769
TOKENS_FOLLOWING_T__86_IN_op_effects_805
TOKENS_FOLLOWING_T__86_IN_procedure_914
TOKENS_FOLLOWING_T__86_IN_sometime_constraint_1194
TOKENS_FOLLOWING_T__86_IN_state_217
TOKENS_FOLLOWING_T__86_IN_state_dependency_649
TOKENS_FOLLOWING_T__86_IN_state_dependency_674
TOKENS_FOLLOWING_abstract_object_IN_sfp_61
TOKENS_FOLLOWING_assignment_IN_attribute_334
TOKENS_FOLLOWING_assignment_IN_placement_123
TOKENS_FOLLOWING_attribute_IN_class_def_268
TOKENS_FOLLOWING_attribute_IN_object_attribute_596
TOKENS_FOLLOWING_attribute_IN_state_212
TOKENS_FOLLOWING_binary_comp_IN_constraint_class_quantification_1759
TOKENS_FOLLOWING_binary_comp_IN_constraint_statement_2027
TOKENS_FOLLOWING_binary_comp_IN_total_constraint_2055
TOKENS_FOLLOWING_binary_op_IN_mutation_2357
TOKENS_FOLLOWING_class_def_IN_sfp_73
TOKENS_FOLLOWING_comp_value_IN_constraint_statement_2029
TOKENS_FOLLOWING_conditional_constraint_IN_constraint_statement_1966
TOKENS_FOLLOWING_conditional_constraint_if_part_IN_conditional_constraint_2123
TOKENS_FOLLOWING_conditional_constraint_then_part_IN_conditional_constraint_2127
TOKENS_FOLLOWING_conditions_IN_procedure_909
TOKENS_FOLLOWING_constraint_body_IN_conditional_constraint_if_part_2165
TOKENS_FOLLOWING_constraint_body_IN_conditional_constraint_then_part_2211
TOKENS_FOLLOWING_constraint_body_IN_conditions_1030
TOKENS_FOLLOWING_constraint_body_IN_constraint_1550
TOKENS_FOLLOWING_constraint_body_IN_global_constraint_1156
TOKENS_FOLLOWING_constraint_body_IN_goal_body_1280
TOKENS_FOLLOWING_constraint_body_IN_goal_body_1310
TOKENS_FOLLOWING_constraint_body_IN_goal_body_1346
TOKENS_FOLLOWING_constraint_body_IN_goal_body_1376
TOKENS_FOLLOWING_constraint_body_IN_goal_body_1426
TOKENS_FOLLOWING_constraint_body_IN_goal_body_1464
TOKENS_FOLLOWING_constraint_body_IN_goal_body_1493
TOKENS_FOLLOWING_constraint_body_IN_nested_constraint_1522
TOKENS_FOLLOWING_constraint_body_IN_sometime_constraint_1192
TOKENS_FOLLOWING_constraint_body_IN_state_dependency_644
TOKENS_FOLLOWING_constraint_body_IN_state_dependency_670
TOKENS_FOLLOWING_constraint_class_quantification_IN_constraint_body_1601
TOKENS_FOLLOWING_constraint_class_quantification_IN_goal_body_1244
TOKENS_FOLLOWING_constraint_def_IN_sfp_69
TOKENS_FOLLOWING_constraint_different_IN_constraint_class_quantification_1831
TOKENS_FOLLOWING_constraint_iterator_IN_constraint_body_1594
TOKENS_FOLLOWING_constraint_iterator_IN_constraint_class_quantification_1840
TOKENS_FOLLOWING_constraint_iterator_IN_goal_body_1237
TOKENS_FOLLOWING_constraint_namespace_IN_constraint_body_1587
TOKENS_FOLLOWING_constraint_namespace_IN_goal_body_1230
TOKENS_FOLLOWING_constraint_statement_IN_conditional_constraint_if_part_2142
TOKENS_FOLLOWING_constraint_statement_IN_conditional_constraint_then_part_2189
TOKENS_FOLLOWING_constraint_statement_IN_constraint_body_1574
TOKENS_FOLLOWING_constraint_statement_IN_constraint_class_quantification_1814
TOKENS_FOLLOWING_constraint_statement_IN_constraint_iterator_1686
TOKENS_FOLLOWING_constraint_statement_IN_constraint_namespace_1635
TOKENS_FOLLOWING_constraint_statement_IN_goal_body_1217
TOKENS_FOLLOWING_dep_effect_IN_state_dependency_627
TOKENS_FOLLOWING_effect_body_IN_effects_1073
TOKENS_FOLLOWING_effects_IN_procedure_912
TOKENS_FOLLOWING_equals_op_IN_assignment_370
TOKENS_FOLLOWING_equals_op_IN_constraint_statement_1916
TOKENS_FOLLOWING_equals_op_IN_constraint_statement_1929
TOKENS_FOLLOWING_equals_op_IN_dep_effect_694
TOKENS_FOLLOWING_equals_op_IN_mutation_2331
TOKENS_FOLLOWING_equals_op_IN_mutation_2344
TOKENS_FOLLOWING_equals_op_IN_object_attribute_603
TOKENS_FOLLOWING_equals_op_IN_op_param_725
TOKENS_FOLLOWING_equals_op_IN_op_statement_825
TOKENS_FOLLOWING_equals_op_IN_procedure_887
TOKENS_FOLLOWING_equals_op_IN_total_statement_2070
TOKENS_FOLLOWING_extends_class_IN_class_def_247
TOKENS_FOLLOWING_global_constraint_IN_constraint_def_144
TOKENS_FOLLOWING_goal_body_IN_goal_constraint_1115
TOKENS_FOLLOWING_goal_constraint_IN_constraint_def_139
TOKENS_FOLLOWING_id_ref_IN_path_with_index_2614
TOKENS_FOLLOWING_id_ref_IN_path_with_index_2617
TOKENS_FOLLOWING_include_IN_sfp_87
TOKENS_FOLLOWING_include_file_IN_include_162
TOKENS_FOLLOWING_mutation_IN_effect_body_2235
TOKENS_FOLLOWING_mutation_IN_mutation_iterator_2295
TOKENS_FOLLOWING_mutation_iterator_IN_effect_body_2248
TOKENS_FOLLOWING_not_equals_op_IN_constraint_statement_1942
TOKENS_FOLLOWING_not_equals_op_IN_constraint_statement_1955
TOKENS_FOLLOWING_object_attribute_IN_object_body_573
TOKENS_FOLLOWING_object_body_IN_mutation_2382
TOKENS_FOLLOWING_object_body_IN_object_def_550
TOKENS_FOLLOWING_object_def_IN_abstract_object_486
TOKENS_FOLLOWING_object_def_IN_attribute_355
TOKENS_FOLLOWING_object_def_IN_sfp_57
TOKENS_FOLLOWING_object_schema_IN_object_def_538
TOKENS_FOLLOWING_object_schema_IN_object_schemata_469
TOKENS_FOLLOWING_object_schemata_IN_object_def_541
TOKENS_FOLLOWING_op_statement_IN_op_conditions_764
TOKENS_FOLLOWING_op_statement_IN_op_effects_800
TOKENS_FOLLOWING_parameter_IN_parameters_931
TOKENS_FOLLOWING_parameter_IN_parameters_939
TOKENS_FOLLOWING_parameters_IN_procedure_872
TOKENS_FOLLOWING_path_IN_assignment_424
TOKENS_FOLLOWING_path_IN_constraint_class_quantification_1741
TOKENS_FOLLOWING_path_IN_constraint_different_1873
TOKENS_FOLLOWING_path_IN_constraint_iterator_1663
TOKENS_FOLLOWING_path_IN_constraint_namespace_1624
TOKENS_FOLLOWING_path_IN_extends_class_304
TOKENS_FOLLOWING_path_IN_mutation_2374
TOKENS_FOLLOWING_path_IN_mutation_2394
TOKENS_FOLLOWING_path_IN_mutation_iterator_2274
TOKENS_FOLLOWING_path_IN_object_def_518
TOKENS_FOLLOWING_path_IN_object_schema_442
TOKENS_FOLLOWING_path_IN_parameter_959
TOKENS_FOLLOWING_path_IN_parameter_983
TOKENS_FOLLOWING_path_IN_parameter_996
TOKENS_FOLLOWING_path_IN_placement_115
TOKENS_FOLLOWING_path_IN_reference_type_2674
TOKENS_FOLLOWING_path_IN_set_type_2695
TOKENS_FOLLOWING_path_with_index_IN_reference_2653
TOKENS_FOLLOWING_placement_IN_sfp_93
TOKENS_FOLLOWING_primitive_value_IN_value_2510
TOKENS_FOLLOWING_probability_op_IN_assignment_408
TOKENS_FOLLOWING_procedure_IN_class_def_272
TOKENS_FOLLOWING_procedure_IN_object_body_577
TOKENS_FOLLOWING_procedure_IN_sfp_77
TOKENS_FOLLOWING_quantification_keyword_IN_constraint_class_quantification_1737
TOKENS_FOLLOWING_reference_IN_comp_value_2096
TOKENS_FOLLOWING_reference_IN_constraint_statement_1894
TOKENS_FOLLOWING_reference_IN_constraint_statement_1905
TOKENS_FOLLOWING_reference_IN_constraint_statement_1914
TOKENS_FOLLOWING_reference_IN_constraint_statement_1927
TOKENS_FOLLOWING_reference_IN_constraint_statement_1940
TOKENS_FOLLOWING_reference_IN_constraint_statement_1953
TOKENS_FOLLOWING_reference_IN_constraint_statement_1975
TOKENS_FOLLOWING_reference_IN_constraint_statement_1991
TOKENS_FOLLOWING_reference_IN_constraint_statement_2012
TOKENS_FOLLOWING_reference_IN_constraint_statement_2025
TOKENS_FOLLOWING_reference_IN_dep_effect_692
TOKENS_FOLLOWING_reference_IN_mutation_2329
TOKENS_FOLLOWING_reference_IN_mutation_2342
TOKENS_FOLLOWING_reference_IN_mutation_2355
TOKENS_FOLLOWING_reference_IN_mutation_2368
TOKENS_FOLLOWING_reference_IN_mutation_2403
TOKENS_FOLLOWING_reference_IN_mutation_2418
TOKENS_FOLLOWING_reference_IN_op_param_727
TOKENS_FOLLOWING_reference_IN_op_statement_823
TOKENS_FOLLOWING_reference_IN_total_statement_2068
TOKENS_FOLLOWING_reference_IN_value_2519
TOKENS_FOLLOWING_reference_type_IN_assignment_384
TOKENS_FOLLOWING_reference_type_IN_parameter_970
TOKENS_FOLLOWING_set_IN_class_def_232
TOKENS_FOLLOWING_set_IN_conditions_1011
TOKENS_FOLLOWING_set_IN_constraint_statement_1993
TOKENS_FOLLOWING_set_IN_effects_1051
TOKENS_FOLLOWING_set_IN_global_constraint_1133
TOKENS_FOLLOWING_set_IN_goal_body_1260
TOKENS_FOLLOWING_set_IN_op_conditions_745
TOKENS_FOLLOWING_set_IN_procedure_858
TOKENS_FOLLOWING_set_IN_set_value_2443
TOKENS_FOLLOWING_set_IN_set_value_2476
TOKENS_FOLLOWING_set_item_IN_set_value_2456
TOKENS_FOLLOWING_set_item_IN_set_value_2464
TOKENS_FOLLOWING_set_type_IN_assignment_396
TOKENS_FOLLOWING_set_value_IN_assignment_410
TOKENS_FOLLOWING_set_value_IN_constraint_statement_1982
TOKENS_FOLLOWING_set_value_IN_constraint_statement_2003
TOKENS_FOLLOWING_set_value_IN_value_2528
TOKENS_FOLLOWING_sometime_constraint_IN_constraint_def_149
TOKENS_FOLLOWING_state_IN_sfp_65
TOKENS_FOLLOWING_total_constraint_IN_constraint_statement_2038
TOKENS_FOLLOWING_total_statement_IN_total_constraint_2051
TOKENS_FOLLOWING_value_IN_assignment_372
TOKENS_FOLLOWING_value_IN_constraint_statement_1918
TOKENS_FOLLOWING_value_IN_constraint_statement_1944
TOKENS_FOLLOWING_value_IN_constraint_statement_2016
TOKENS_FOLLOWING_value_IN_dep_effect_701
TOKENS_FOLLOWING_value_IN_mutation_2333
TOKENS_FOLLOWING_value_IN_mutation_2407
TOKENS_FOLLOWING_value_IN_mutation_2422
TOKENS_FOLLOWING_value_IN_op_statement_827
TOKENS_FOLLOWING_value_IN_set_item_2491
TOKENS_FOLLOWING_value_IN_total_statement_2072
TotalConstraintReturnValue
TotalStatementReturnValue
ValueReturnValue

Public Class Methods

new( input, options = {} ) click to toggle source
Calls superclass method
# File lib/sfp/SfpLangParser.rb, line 149
def initialize( input, options = {} )
  super( input, options )
end

Public Instance Methods

abstract_object() click to toggle source

parser rule abstract_object

(in SfpLang.g) 203:1: abstract_object : ‘abstract’ object_def ;

# File lib/sfp/SfpLangParser.rb, line 1980
def abstract_object
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 13 )


  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 204:4: 'abstract' object_def
  # --> action

                    @is_final = false
                    @now['_finals'] = [] if !@now.has_key? '_finals'
            
  # <-- action

  string_literal64 = match( T__37, TOKENS_FOLLOWING_T__37_IN_abstract_object_484 )
  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_486 )
  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__, 13 )


  end

  return return_value
end
assignment( id ) click to toggle source

parser rule assignment

(in SfpLang.g) 143:1: assignment : ( equals_op value ( NL )+ | reference_type ( NL )+ | set_type ( NL )+ | probability_op set_value ( NL )+ | ‘:’ path ( NL )+ );

# File lib/sfp/SfpLangParser.rb, line 1445
def assignment( id )
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 10 )


  return_value = AssignmentReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __NL47__ = nil
  __NL49__ = nil
  __NL51__ = nil
  __NL54__ = nil
  char_literal55 = nil
  __NL57__ = nil
  equals_op45 = nil
  value46 = nil
  reference_type48 = nil
  set_type50 = nil
  probability_op52 = nil
  set_value53 = nil
  path56 = nil


  tree_for_NL47 = nil
  tree_for_NL49 = nil
  tree_for_NL51 = nil
  tree_for_NL54 = nil
  tree_for_char_literal55 = nil
  tree_for_NL57 = nil

  begin
  # at line 144:2: ( equals_op value ( NL )+ | reference_type ( NL )+ | set_type ( NL )+ | probability_op set_value ( NL )+ | ':' path ( NL )+ )
  alt_24 = 5
  case look_24 = @input.peek( 1 )
  when T__32, T__66 then alt_24 = 1
  when T__70 then alt_24 = 2
  when T__71 then alt_24 = 3
  when T__53 then alt_24 = 4
  when T__28 then alt_24 = 5
  else
    raise NoViableAlternative( "", 24, 0 )

  end
  case alt_24
  when 1
    root_0 = @adaptor.create_flat_list


    # at line 144:4: equals_op value ( NL )+
    @state.following.push( TOKENS_FOLLOWING_equals_op_IN_assignment_370 )
    equals_op45 = equals_op
    @state.following.pop
    @adaptor.add_child( root_0, equals_op45.tree )

    @state.following.push( TOKENS_FOLLOWING_value_IN_assignment_372 )
    value46 = value
    @state.following.pop
    @adaptor.add_child( root_0, value46.tree )

    # at file 144:20: ( 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 144:20: NL
        __NL47__ = match( NL, TOKENS_FOLLOWING_NL_IN_assignment_374 )
        tree_for_NL47 = @adaptor.create_with_payload( __NL47__ )
        @adaptor.add_child( root_0, tree_for_NL47 )



      else
        match_count_19 > 0 and break
        eee = EarlyExit(19)


        raise eee
      end
      match_count_19 += 1
    end



    # --> action

                            if @now.has_key?(id) and @now[id].is_a?(Hash) and
                                            @now[id].isset and ( value46.nil? ? nil : value46.type ) == 'Set'
                                    ( value46.nil? ? nil : value46.val ).each { |v| @now[id]['_values'].push(v) }
                            else
                                    @now[id] = ( value46.nil? ? nil : value46.val )
                            end
                    
    # <-- action


  when 2
    root_0 = @adaptor.create_flat_list


    # at line 153:4: reference_type ( NL )+
    @state.following.push( TOKENS_FOLLOWING_reference_type_IN_assignment_384 )
    reference_type48 = reference_type
    @state.following.pop
    @adaptor.add_child( root_0, reference_type48.tree )

    # at file 153:19: ( 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 153:19: NL
        __NL49__ = match( NL, TOKENS_FOLLOWING_NL_IN_assignment_386 )
        tree_for_NL49 = @adaptor.create_with_payload( __NL49__ )
        @adaptor.add_child( root_0, tree_for_NL49 )



      else
        match_count_20 > 0 and break
        eee = EarlyExit(20)


        raise eee
      end
      match_count_20 += 1
    end



    # --> action

                            @now[id] = ( reference_type48.nil? ? nil : reference_type48.val )
                    
    # <-- action


  when 3
    root_0 = @adaptor.create_flat_list


    # at line 157:4: set_type ( NL )+
    @state.following.push( TOKENS_FOLLOWING_set_type_IN_assignment_396 )
    set_type50 = set_type
    @state.following.pop
    @adaptor.add_child( root_0, set_type50.tree )

    # at file 157:13: ( 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 157:13: NL
        __NL51__ = match( NL, TOKENS_FOLLOWING_NL_IN_assignment_398 )
        tree_for_NL51 = @adaptor.create_with_payload( __NL51__ )
        @adaptor.add_child( root_0, tree_for_NL51 )



      else
        match_count_21 > 0 and break
        eee = EarlyExit(21)


        raise eee
      end
      match_count_21 += 1
    end



    # --> action

                            @now[id] = ( set_type50.nil? ? nil : set_type50.val )
                    
    # <-- action


  when 4
    root_0 = @adaptor.create_flat_list


    # at line 161:4: probability_op set_value ( NL )+
    @state.following.push( TOKENS_FOLLOWING_probability_op_IN_assignment_408 )
    probability_op52 = probability_op
    @state.following.pop
    @adaptor.add_child( root_0, probability_op52.tree )

    @state.following.push( TOKENS_FOLLOWING_set_value_IN_assignment_410 )
    set_value53 = set_value
    @state.following.pop
    @adaptor.add_child( root_0, set_value53.tree )

    # at file 161:29: ( 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 161:29: NL
        __NL54__ = match( NL, TOKENS_FOLLOWING_NL_IN_assignment_412 )
        tree_for_NL54 = @adaptor.create_with_payload( __NL54__ )
        @adaptor.add_child( root_0, tree_for_NL54 )



      else
        match_count_22 > 0 and break
        eee = EarlyExit(22)


        raise eee
      end
      match_count_22 += 1
    end



    # --> action
            
                            @conformant = true
                            @now[id] = { '_self' => id,
                                    '_context' => 'either',
                                    '_parent' => @now,
                                    '_values' => ( set_value53.nil? ? nil : set_value53.val )
                            }
                    
    # <-- action


  when 5
    root_0 = @adaptor.create_flat_list


    # at line 170:4: ':' path ( NL )+
    char_literal55 = match( T__28, TOKENS_FOLLOWING_T__28_IN_assignment_422 )
    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_assignment_424 )
    path56 = path
    @state.following.pop
    @adaptor.add_child( root_0, path56.tree )

    # at file 170:13: ( 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 170:13: NL
        __NL57__ = match( NL, TOKENS_FOLLOWING_NL_IN_assignment_426 )
        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[id] = { '_context' => 'any_value',
                                            '_isa' => '$.String'
                                    }
                            when 'Bool'
                                    @now[id] = { '_context' => 'any_value',
                                            '_isa' => '$.Boolean'
                                    }
                            when 'Int'
                                    @now[id] = { '_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
                    
    # <-- 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__, 10 )


  end

  return return_value
end
attribute() click to toggle source

parser rule attribute

(in SfpLang.g) 126:1: attribute : ( ( ‘final’ )? ID assignment | ( ‘final’ )? object_def ( NL )+ );

# File lib/sfp/SfpLangParser.rb, line 1225
def attribute
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 9 )


  return_value = AttributeReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  string_literal39 = nil
  __ID40__ = nil
  string_literal42 = nil
  __NL44__ = nil
  assignment41 = nil
  object_def43 = nil


  tree_for_string_literal39 = nil
  tree_for_ID40 = nil
  tree_for_string_literal42 = nil
  tree_for_NL44 = nil

  begin
  # at line 127:2: ( ( 'final' )? ID assignment[$ID.text] | ( 'final' )? object_def ( NL )+ )
  alt_18 = 2
  look_18_0 = @input.peek( 1 )

  if ( look_18_0 == T__56 )
    look_18_1 = @input.peek( 2 )

    if ( look_18_1 == ID )
      look_18_2 = @input.peek( 3 )

      if ( look_18_2 == T__28 || look_18_2 == T__32 || look_18_2 == T__53 || look_18_2 == T__66 || look_18_2.between?( T__70, T__71 ) )
        alt_18 = 1
      elsif ( look_18_2 == NL || look_18_2 == T__55 || look_18_2 == T__67 || look_18_2 == T__85 )
        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__28 || look_18_2 == T__32 || look_18_2 == T__53 || look_18_2 == T__66 || look_18_2.between?( T__70, T__71 ) )
      alt_18 = 1
    elsif ( look_18_2 == NL || look_18_2 == T__55 || look_18_2 == T__67 || look_18_2 == T__85 )
      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 127:4: ( 'final' )? ID assignment[$ID.text]
    # --> action

                            @is_final = false
                            @now['_finals'] = [] if !@now.has_key? '_finals'
                    
    # <-- action

    # at line 131:3: ( 'final' )?
    alt_15 = 2
    look_15_0 = @input.peek( 1 )

    if ( look_15_0 == T__56 )
      alt_15 = 1
    end
    case alt_15
    when 1
      # at line 131:4: 'final'
      string_literal39 = match( T__56, TOKENS_FOLLOWING_T__56_IN_attribute_324 )
      tree_for_string_literal39 = @adaptor.create_with_payload( string_literal39 )
      @adaptor.add_child( root_0, tree_for_string_literal39 )



      # --> action
       @is_final = true 
      # <-- action


    end
    __ID40__ = match( ID, TOKENS_FOLLOWING_ID_IN_attribute_332 )
    tree_for_ID40 = @adaptor.create_with_payload( __ID40__ )
    @adaptor.add_child( root_0, tree_for_ID40 )


    @state.following.push( TOKENS_FOLLOWING_assignment_IN_attribute_334 )
    assignment41 = assignment( __ID40__.text )
    @state.following.pop
    @adaptor.add_child( root_0, assignment41.tree )


    # --> action

                            @now['_finals'] << __ID40__.text if @is_final
                    
    # <-- action


  when 2
    root_0 = @adaptor.create_flat_list


    # at line 136:4: ( 'final' )? object_def ( NL )+
    # --> action

                            @is_final = false
                            @now['_finals'] = [] if !@now.has_key? '_finals'
                    
    # <-- action

    # at line 140:3: ( 'final' )?
    alt_16 = 2
    look_16_0 = @input.peek( 1 )

    if ( look_16_0 == T__56 )
      alt_16 = 1
    end
    case alt_16
    when 1
      # at line 140:4: 'final'
      string_literal42 = match( T__56, TOKENS_FOLLOWING_T__56_IN_attribute_349 )
      tree_for_string_literal42 = @adaptor.create_with_payload( string_literal42 )
      @adaptor.add_child( root_0, tree_for_string_literal42 )



      # --> action
       @is_final = true 
      # <-- action


    end
    @state.following.push( TOKENS_FOLLOWING_object_def_IN_attribute_355 )
    object_def43 = object_def
    @state.following.pop
    @adaptor.add_child( root_0, object_def43.tree )

    # at file 140: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 140:46: NL
        __NL44__ = match( NL, TOKENS_FOLLOWING_NL_IN_attribute_357 )
        tree_for_NL44 = @adaptor.create_with_payload( __NL44__ )
        @adaptor.add_child( root_0, tree_for_NL44 )



      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__, 9 )


  end

  return return_value
end
binary_comp() click to toggle source

parser rule binary_comp

(in SfpLang.g) 1009:1: binary_comp : ( ‘>’ | ‘>=’ | ‘<’ | ‘<=’ );

# File lib/sfp/SfpLangParser.rb, line 10735
def binary_comp
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 64 )


  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__30, T__31 ) || @input.peek( 1 ).between?( T__33, T__34 )
    @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__, 64 )


  end

  return return_value
end
binary_op() click to toggle source

parser rule binary_op

(in SfpLang.g) 1002:1: binary_op : ( ‘+=’ | ‘-=’ | ‘*=’ | ‘/=’ );

# File lib/sfp/SfpLangParser.rb, line 10664
def binary_op
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 63 )


  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__22, T__23 ) || @input.peek(1) == T__25 || @input.peek(1) == T__27
    @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__, 63 )


  end

  return return_value
end
class_def() click to toggle source

parser rule class_def

(in SfpLang.g) 93:1: class_def : ( ‘class’ | ‘schema’ ) ID ( extends_class )? ( ‘{’ ( NL )* ( attribute | procedure ( NL )* )* ‘}’ )? ;

# File lib/sfp/SfpLangParser.rb, line 913
def class_def
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 7 )


  return_value = ClassDefReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  set28 = nil
  __ID29__ = nil
  char_literal31 = nil
  __NL32__ = nil
  __NL35__ = nil
  char_literal36 = nil
  extends_class30 = nil
  attribute33 = nil
  procedure34 = nil


  tree_for_set28 = nil
  tree_for_ID29 = nil
  tree_for_char_literal31 = nil
  tree_for_NL32 = nil
  tree_for_NL35 = nil
  tree_for_char_literal36 = nil

  begin
  root_0 = @adaptor.create_flat_list


  # at line 94:4: ( 'class' | 'schema' ) ID ( extends_class )? ( '{' ( NL )* ( attribute | procedure ( NL )* )* '}' )?
  set28 = @input.look

  if @input.peek(1) == T__45 || @input.peek(1) == T__77
    @input.consume
    @adaptor.add_child( root_0, @adaptor.create_with_payload( set28 ) )

    @state.error_recovery = false

  else
    mse = MismatchedSet( nil )
    raise mse

  end


  __ID29__ = match( ID, TOKENS_FOLLOWING_ID_IN_class_def_238 )
  tree_for_ID29 = @adaptor.create_with_payload( __ID29__ )
  @adaptor.add_child( root_0, tree_for_ID29 )



  # --> action

                    @now[__ID29__.text] = { '_self' => __ID29__.text,
                            '_context' => 'class',
                            '_parent' => @now,
                    }
                    @now = @now[__ID29__.text]
            
  # <-- action

  # at line 102:3: ( extends_class )?
  alt_10 = 2
  look_10_0 = @input.peek( 1 )

  if ( look_10_0 == T__55 )
    alt_10 = 1
  end
  case alt_10
  when 1
    # at line 102:4: extends_class
    @state.following.push( TOKENS_FOLLOWING_extends_class_IN_class_def_247 )
    extends_class30 = extends_class
    @state.following.pop
    @adaptor.add_child( root_0, extends_class30.tree )


    # --> action

                            @now['_extends'] = ( extends_class30.nil? ? nil : extends_class30.val )
                    
    # <-- action


  end
  # at line 107:3: ( '{' ( NL )* ( attribute | procedure ( NL )* )* '}' )?
  alt_14 = 2
  look_14_0 = @input.peek( 1 )

  if ( look_14_0 == T__85 )
    alt_14 = 1
  end
  case alt_14
  when 1
    # at line 107:4: '{' ( NL )* ( attribute | procedure ( NL )* )* '}'
    char_literal31 = match( T__85, TOKENS_FOLLOWING_T__85_IN_class_def_261 )
    tree_for_char_literal31 = @adaptor.create_with_payload( char_literal31 )
    @adaptor.add_child( root_0, tree_for_char_literal31 )


    # at line 107: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 107:8: NL
        __NL32__ = match( NL, TOKENS_FOLLOWING_NL_IN_class_def_263 )
        tree_for_NL32 = @adaptor.create_with_payload( __NL32__ )
        @adaptor.add_child( root_0, tree_for_NL32 )



      else
        break # out of loop for decision 11
      end
    end # loop for decision 11

    # at line 107: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__56 )
        alt_13 = 1
      elsif ( look_13_0 == T__75 || look_13_0.between?( T__80, T__81 ) )
        alt_13 = 2

      end
      case alt_13
      when 1
        # at line 107:14: attribute
        @state.following.push( TOKENS_FOLLOWING_attribute_IN_class_def_268 )
        attribute33 = attribute
        @state.following.pop
        @adaptor.add_child( root_0, attribute33.tree )


      when 2
        # at line 107:26: procedure ( NL )*
        @state.following.push( TOKENS_FOLLOWING_procedure_IN_class_def_272 )
        procedure34 = procedure
        @state.following.pop
        @adaptor.add_child( root_0, procedure34.tree )

        # at line 107: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 107:36: NL
            __NL35__ = match( NL, TOKENS_FOLLOWING_NL_IN_class_def_274 )
            tree_for_NL35 = @adaptor.create_with_payload( __NL35__ )
            @adaptor.add_child( root_0, tree_for_NL35 )



          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_literal36 = match( T__86, TOKENS_FOLLOWING_T__86_IN_class_def_280 )
    tree_for_char_literal36 = @adaptor.create_with_payload( char_literal36 )
    @adaptor.add_child( root_0, tree_for_char_literal36 )



  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__, 7 )


  end

  return return_value
end
comp_value() click to toggle source

parser rule comp_value

(in SfpLang.g) 734:1: comp_value returns [val] : ( NUMBER | reference );

# File lib/sfp/SfpLangParser.rb, line 8139
def comp_value
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 43 )


  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 735: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 735:4: NUMBER
    __NUMBER342__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_comp_value_2087 )
    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 737:4: reference
    @state.following.push( TOKENS_FOLLOWING_reference_IN_comp_value_2096 )
    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__, 43 )


  end

  return return_value
end
conditional_constraint() click to toggle source

parser rule conditional_constraint

(in SfpLang.g) 741:1: conditional_constraint returns [key, val] : ‘if’ conditional_constraint_if_part conditional_constraint_then_part ;

# File lib/sfp/SfpLangParser.rb, line 8237
def conditional_constraint
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 44 )


  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 742:4: 'if' conditional_constraint_if_part conditional_constraint_then_part
  string_literal344 = match( T__63, TOKENS_FOLLOWING_T__63_IN_conditional_constraint_2115 )
  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_2123 )
  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_2127 )
  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__, 44 )


  end

  return return_value
end
conditional_constraint_if_part() click to toggle source

parser rule conditional_constraint_if_part

(in SfpLang.g) 753:1: conditional_constraint_if_part : ( constraint_statement ( NL )* | ‘{’ ( NL )+ constraint_body ‘}’ ( NL )* );

# File lib/sfp/SfpLangParser.rb, line 8324
def conditional_constraint_if_part
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 45 )


  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 754: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__63 || look_127_0 == T__73 || look_127_0 == T__83 )
    alt_127 = 1
  elsif ( look_127_0 == T__85 )
    alt_127 = 2
  else
    raise NoViableAlternative( "", 127, 0 )

  end
  case alt_127
  when 1
    root_0 = @adaptor.create_flat_list


    # at line 754:4: constraint_statement ( NL )*
    @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_conditional_constraint_if_part_2142 )
    constraint_statement347 = constraint_statement
    @state.following.pop
    @adaptor.add_child( root_0, constraint_statement347.tree )

    # at line 754: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 754:25: NL
        __NL348__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2144 )
        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 761:4: '{' ( NL )+ constraint_body '}' ( NL )*
    char_literal349 = match( T__85, TOKENS_FOLLOWING_T__85_IN_conditional_constraint_if_part_2154 )
    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 768: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 768:3: NL
        __NL350__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2162 )
        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_2165 )
    constraint_body351 = constraint_body
    @state.following.pop
    @adaptor.add_child( root_0, constraint_body351.tree )

    char_literal352 = match( T__86, TOKENS_FOLLOWING_T__86_IN_conditional_constraint_if_part_2169 )
    tree_for_char_literal352 = @adaptor.create_with_payload( char_literal352 )
    @adaptor.add_child( root_0, tree_for_char_literal352 )


    # at line 769: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 769:7: NL
        __NL353__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditional_constraint_if_part_2171 )
        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__, 45 )


  end

  return return_value
end
conditional_constraint_then_part() click to toggle source

parser rule conditional_constraint_then_part

(in SfpLang.g) 773:1: conditional_constraint_then_part : ( ‘then’ constraint_statement | ‘then’ ‘{’ ( NL )+ constraint_body ‘}’ );

# File lib/sfp/SfpLangParser.rb, line 8532
def conditional_constraint_then_part
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 46 )


  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 774:2: ( 'then' constraint_statement | 'then' '{' ( NL )+ constraint_body '}' )
  alt_129 = 2
  look_129_0 = @input.peek( 1 )

  if ( look_129_0 == T__82 )
    look_129_1 = @input.peek( 2 )

    if ( look_129_1 == ID || look_129_1 == T__63 || look_129_1 == T__73 || look_129_1 == T__83 )
      alt_129 = 1
    elsif ( look_129_1 == T__85 )
      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 774:4: 'then' constraint_statement
    string_literal354 = match( T__82, TOKENS_FOLLOWING_T__82_IN_conditional_constraint_then_part_2187 )
    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_2189 )
    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 781:4: 'then' '{' ( NL )+ constraint_body '}'
    string_literal356 = match( T__82, TOKENS_FOLLOWING_T__82_IN_conditional_constraint_then_part_2198 )
    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__85, TOKENS_FOLLOWING_T__85_IN_conditional_constraint_then_part_2206 )
    tree_for_char_literal357 = @adaptor.create_with_payload( char_literal357 )
    @adaptor.add_child( root_0, tree_for_char_literal357 )


    # at file 788: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 788:7: NL
        __NL358__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditional_constraint_then_part_2208 )
        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_2211 )
    constraint_body359 = constraint_body
    @state.following.pop
    @adaptor.add_child( root_0, constraint_body359.tree )

    char_literal360 = match( T__86, TOKENS_FOLLOWING_T__86_IN_conditional_constraint_then_part_2213 )
    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__, 46 )


  end

  return return_value
end
conditions() click to toggle source

parser rule conditions

(in SfpLang.g) 381:1: conditions : ( ‘conditions’ | ‘condition’ ) ‘{’ ( NL )* constraint_body ‘}’ ( NL )+ ;

# File lib/sfp/SfpLangParser.rb, line 4179
def conditions
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 26 )


  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 382:4: ( 'conditions' | 'condition' ) '{' ( NL )* constraint_body '}' ( NL )+
  set155 = @input.look

  if @input.peek( 1 ).between?( T__46, T__47 )
    @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__85, TOKENS_FOLLOWING_T__85_IN_conditions_1025 )
  tree_for_char_literal156 = @adaptor.create_with_payload( char_literal156 )
  @adaptor.add_child( root_0, tree_for_char_literal156 )


  # at line 387: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 387:7: NL
      __NL157__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditions_1027 )
      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_1030 )
  constraint_body158 = constraint_body
  @state.following.pop
  @adaptor.add_child( root_0, constraint_body158.tree )

  char_literal159 = match( T__86, TOKENS_FOLLOWING_T__86_IN_conditions_1032 )
  tree_for_char_literal159 = @adaptor.create_with_payload( char_literal159 )
  @adaptor.add_child( root_0, tree_for_char_literal159 )


  # at file 387: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 387:31: NL
      __NL160__ = match( NL, TOKENS_FOLLOWING_NL_IN_conditions_1034 )
      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__, 26 )


  end

  return return_value
end
constraint() click to toggle source

parser rule constraint

(in SfpLang.g) 534:1: constraint : ‘constraint’ ID ‘{’ ( NL )* constraint_body ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 6242
def constraint
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 33 )


  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 535:4: 'constraint' ID '{' ( NL )* constraint_body '}'
  string_literal249 = match( T__48, TOKENS_FOLLOWING_T__48_IN_constraint_1535 )
  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_1537 )
  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__85, TOKENS_FOLLOWING_T__85_IN_constraint_1545 )
  tree_for_char_literal251 = @adaptor.create_with_payload( char_literal251 )
  @adaptor.add_child( root_0, tree_for_char_literal251 )


  # at line 540: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 540:7: NL
      __NL252__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_1547 )
      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_1550 )
  constraint_body253 = constraint_body
  @state.following.pop
  @adaptor.add_child( root_0, constraint_body253.tree )

  char_literal254 = match( T__86, TOKENS_FOLLOWING_T__86_IN_constraint_1552 )
  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__, 33 )


  end

  return return_value
end
constraint_body() click to toggle source

parser rule constraint_body

(in SfpLang.g) 544:1: constraint_body : ( ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ )* ;

# File lib/sfp/SfpLangParser.rb, line 6368
def constraint_body
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 34 )


  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 545:4: ( ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ )*
  # at line 545: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__54 || look_104_0.between?( T__57, T__59 ) || look_104_0 == T__63 || look_104_0 == T__73 || look_104_0 == T__83 )
      alt_104 = 1

    end
    case alt_104
    when 1
      # at line 546:4: ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+
      # at line 546: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 546:6: constraint_statement
        @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_constraint_body_1574 )
        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 550:6: constraint_namespace
        @state.following.push( TOKENS_FOLLOWING_constraint_namespace_IN_constraint_body_1587 )
        constraint_namespace256 = constraint_namespace
        @state.following.pop
        @adaptor.add_child( root_0, constraint_namespace256.tree )


      when 3
        # at line 551:6: constraint_iterator
        @state.following.push( TOKENS_FOLLOWING_constraint_iterator_IN_constraint_body_1594 )
        constraint_iterator257 = constraint_iterator
        @state.following.pop
        @adaptor.add_child( root_0, constraint_iterator257.tree )


      when 4
        # at line 552:6: constraint_class_quantification
        @state.following.push( TOKENS_FOLLOWING_constraint_class_quantification_IN_constraint_body_1601 )
        constraint_class_quantification258 = constraint_class_quantification
        @state.following.pop
        @adaptor.add_child( root_0, constraint_class_quantification258.tree )


      end
      # at file 554: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 554:3: NL
          __NL259__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_body_1610 )
          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__, 34 )


  end

  return return_value
end
constraint_class_quantification() click to toggle source

parser rule constraint_class_quantification

(in SfpLang.g) 597:1: constraint_class_quantification : quantification_keyword ‘(’ path ‘as’ ID ‘)’ ( ( binary_comp | ‘=’ ) NUMBER )? ( NL )* ‘{’ ( NL )+ ( constraint_statement ( NL )+ | constraint_different ( NL )+ | constraint_iterator ( NL )+ )* ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 7031
def constraint_class_quantification
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 38 )


  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 598: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_1737 )
  quantification_keyword280 = quantification_keyword
  @state.following.pop
  @adaptor.add_child( root_0, quantification_keyword280.tree )

  char_literal281 = match( T__20, TOKENS_FOLLOWING_T__20_IN_constraint_class_quantification_1739 )
  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_1741 )
  path282 = path
  @state.following.pop
  @adaptor.add_child( root_0, path282.tree )

  string_literal283 = match( T__43, TOKENS_FOLLOWING_T__43_IN_constraint_class_quantification_1743 )
  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_1745 )
  tree_for_ID284 = @adaptor.create_with_payload( __ID284__ )
  @adaptor.add_child( root_0, tree_for_ID284 )


  char_literal285 = match( T__21, TOKENS_FOLLOWING_T__21_IN_constraint_class_quantification_1747 )
  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 614:3: ( ( binary_comp | '=' ) NUMBER )?
  alt_114 = 2
  look_114_0 = @input.peek( 1 )

  if ( look_114_0.between?( T__30, T__34 ) )
    alt_114 = 1
  end
  case alt_114
  when 1
    # at line 614:5: ( binary_comp | '=' ) NUMBER
    # at line 614:5: ( binary_comp | '=' )
    alt_113 = 2
    look_113_0 = @input.peek( 1 )

    if ( look_113_0.between?( T__30, T__31 ) || look_113_0.between?( T__33, T__34 ) )
      alt_113 = 1
    elsif ( look_113_0 == T__32 )
      alt_113 = 2
    else
      raise NoViableAlternative( "", 113, 0 )

    end
    case alt_113
    when 1
      # at line 614:7: binary_comp
      @state.following.push( TOKENS_FOLLOWING_binary_comp_IN_constraint_class_quantification_1759 )
      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 616:6: '='
      char_literal287 = match( T__32, TOKENS_FOLLOWING_T__32_IN_constraint_class_quantification_1772 )
      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_1788 )
    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 622: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 622:3: NL
      __NL289__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1802 )
      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__85, TOKENS_FOLLOWING_T__85_IN_constraint_class_quantification_1805 )
  tree_for_char_literal290 = @adaptor.create_with_payload( char_literal290 )
  @adaptor.add_child( root_0, tree_for_char_literal290 )


  # at file 622: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 622:11: NL
      __NL291__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1807 )
      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 623: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__63, T__73, T__83 then alt_120 = 1
    when T__29 then alt_120 = 2
    when T__58 then alt_120 = 3
    end
    case alt_120
    when 1
      # at line 623:5: constraint_statement ( NL )+
      @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_constraint_class_quantification_1814 )
      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 625: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 625:4: NL
          __NL293__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1824 )
          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 626:5: constraint_different ( NL )+
      @state.following.push( TOKENS_FOLLOWING_constraint_different_IN_constraint_class_quantification_1831 )
      constraint_different294 = constraint_different
      @state.following.pop
      @adaptor.add_child( root_0, constraint_different294.tree )

      # at file 626: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 626:26: NL
          __NL295__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1833 )
          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 627:5: constraint_iterator ( NL )+
      @state.following.push( TOKENS_FOLLOWING_constraint_iterator_IN_constraint_class_quantification_1840 )
      constraint_iterator296 = constraint_iterator
      @state.following.pop
      @adaptor.add_child( root_0, constraint_iterator296.tree )

      # at file 627: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 627:25: NL
          __NL297__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_class_quantification_1842 )
          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__86, TOKENS_FOLLOWING_T__86_IN_constraint_class_quantification_1850 )
  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__, 38 )


  end

  return return_value
end
constraint_def() click to toggle source

parser rule constraint_def

(in SfpLang.g) 63:1: constraint_def : ( goal_constraint | global_constraint | sometime_constraint );

# File lib/sfp/SfpLangParser.rb, line 479
def constraint_def
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 3 )


  return_value = ConstraintDefReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  goal_constraint14 = nil
  global_constraint15 = nil
  sometime_constraint16 = nil



  begin
  # at line 64:2: ( goal_constraint | global_constraint | sometime_constraint )
  alt_5 = 3
  case look_5 = @input.peek( 1 )
  when T__61 then alt_5 = 1
  when T__40, T__60 then alt_5 = 2
  when T__78 then alt_5 = 3
  else
    raise NoViableAlternative( "", 5, 0 )

  end
  case alt_5
  when 1
    root_0 = @adaptor.create_flat_list


    # at line 64:4: goal_constraint
    @state.following.push( TOKENS_FOLLOWING_goal_constraint_IN_constraint_def_139 )
    goal_constraint14 = goal_constraint
    @state.following.pop
    @adaptor.add_child( root_0, goal_constraint14.tree )


  when 2
    root_0 = @adaptor.create_flat_list


    # at line 65:4: global_constraint
    @state.following.push( TOKENS_FOLLOWING_global_constraint_IN_constraint_def_144 )
    global_constraint15 = global_constraint
    @state.following.pop
    @adaptor.add_child( root_0, global_constraint15.tree )


  when 3
    root_0 = @adaptor.create_flat_list


    # at line 66:4: sometime_constraint
    @state.following.push( TOKENS_FOLLOWING_sometime_constraint_IN_constraint_def_149 )
    sometime_constraint16 = sometime_constraint
    @state.following.pop
    @adaptor.add_child( root_0, sometime_constraint16.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__, 3 )


  end

  return return_value
end
constraint_different() click to toggle source

parser rule constraint_different

(in SfpLang.g) 633:1: constraint_different : ‘:different’ ‘(’ path ‘)’ ;

# File lib/sfp/SfpLangParser.rb, line 7434
def constraint_different
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 39 )


  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 634:4: ':different' '(' path ')'
  string_literal299 = match( T__29, TOKENS_FOLLOWING_T__29_IN_constraint_different_1869 )
  tree_for_string_literal299 = @adaptor.create_with_payload( string_literal299 )
  @adaptor.add_child( root_0, tree_for_string_literal299 )


  char_literal300 = match( T__20, TOKENS_FOLLOWING_T__20_IN_constraint_different_1871 )
  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_1873 )
  path301 = path
  @state.following.pop
  @adaptor.add_child( root_0, path301.tree )

  char_literal302 = match( T__21, TOKENS_FOLLOWING_T__21_IN_constraint_different_1875 )
  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__, 39 )


  end

  return return_value
end
constraint_iterator() click to toggle source

parser rule constraint_iterator

(in SfpLang.g) 566:1: constraint_iterator : ‘foreach’ ‘(’ path ‘as’ ID ‘)’ ( NL )* ‘{’ ( NL )+ ( constraint_statement ( NL )+ )* ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 6708
def constraint_iterator
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 36 )


  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 567:4: 'foreach' '(' path 'as' ID ')' ( NL )* '{' ( NL )+ ( constraint_statement ( NL )+ )* '}'
  string_literal267 = match( T__58, TOKENS_FOLLOWING_T__58_IN_constraint_iterator_1659 )
  tree_for_string_literal267 = @adaptor.create_with_payload( string_literal267 )
  @adaptor.add_child( root_0, tree_for_string_literal267 )


  char_literal268 = match( T__20, TOKENS_FOLLOWING_T__20_IN_constraint_iterator_1661 )
  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_1663 )
  path269 = path
  @state.following.pop
  @adaptor.add_child( root_0, path269.tree )

  string_literal270 = match( T__43, TOKENS_FOLLOWING_T__43_IN_constraint_iterator_1665 )
  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_1667 )
  tree_for_ID271 = @adaptor.create_with_payload( __ID271__ )
  @adaptor.add_child( root_0, tree_for_ID271 )


  char_literal272 = match( T__21, TOKENS_FOLLOWING_T__21_IN_constraint_iterator_1669 )
  tree_for_char_literal272 = @adaptor.create_with_payload( char_literal272 )
  @adaptor.add_child( root_0, tree_for_char_literal272 )


  # at line 567: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 567:35: NL
      __NL273__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_iterator_1671 )
      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__85, TOKENS_FOLLOWING_T__85_IN_constraint_iterator_1674 )
  tree_for_char_literal274 = @adaptor.create_with_payload( char_literal274 )
  @adaptor.add_child( root_0, tree_for_char_literal274 )


  # at file 567: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 567:43: NL
      __NL275__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_iterator_1676 )
      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 579: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__63 || look_112_0 == T__73 || look_112_0 == T__83 )
      alt_112 = 1

    end
    case alt_112
    when 1
      # at line 579:4: constraint_statement ( NL )+
      @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_constraint_iterator_1686 )
      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 583: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 583:3: NL
          __NL277__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_iterator_1694 )
          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__86, TOKENS_FOLLOWING_T__86_IN_constraint_iterator_1701 )
  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__, 36 )


  end

  return return_value
end
constraint_namespace() click to toggle source

parser rule constraint_namespace

(in SfpLang.g) 557:1: constraint_namespace : path ( NL )* ‘{’ ( NL )* ( constraint_statement ( NL )+ )* ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 6520
def constraint_namespace
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 35 )


  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 558:4: path ( NL )* '{' ( NL )* ( constraint_statement ( NL )+ )* '}'
  @state.following.push( TOKENS_FOLLOWING_path_IN_constraint_namespace_1624 )
  path260 = path
  @state.following.pop
  @adaptor.add_child( root_0, path260.tree )

  # at line 558: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 558:9: NL
      __NL261__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_namespace_1626 )
      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__85, TOKENS_FOLLOWING_T__85_IN_constraint_namespace_1629 )
  tree_for_char_literal262 = @adaptor.create_with_payload( char_literal262 )
  @adaptor.add_child( root_0, tree_for_char_literal262 )


  # at line 558: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 558:17: NL
      __NL263__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_namespace_1631 )
      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 558: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__63 || look_108_0 == T__73 || look_108_0 == T__83 )
      alt_108 = 1

    end
    case alt_108
    when 1
      # at line 558:22: constraint_statement ( NL )+
      @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_constraint_namespace_1635 )
      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 563: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 563:3: NL
          __NL265__ = match( NL, TOKENS_FOLLOWING_NL_IN_constraint_namespace_1643 )
          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__86, TOKENS_FOLLOWING_T__86_IN_constraint_namespace_1648 )
  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__, 35 )


  end

  return return_value
end
constraint_statement() click to toggle source

parser rule constraint_statement

(in SfpLang.g) 646: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 );

# File lib/sfp/SfpLangParser.rb, line 7528
def constraint_statement
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 40 )


  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 647: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 647:4: reference
    @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1894 )
    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 652:4: 'not' reference
    string_literal304 = match( T__73, TOKENS_FOLLOWING_T__73_IN_constraint_statement_1903 )
    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_1905 )
    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 657:4: reference equals_op value
    @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1914 )
    reference306 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference306.tree )

    @state.following.push( TOKENS_FOLLOWING_equals_op_IN_constraint_statement_1916 )
    equals_op307 = equals_op
    @state.following.pop
    @adaptor.add_child( root_0, equals_op307.tree )

    @state.following.push( TOKENS_FOLLOWING_value_IN_constraint_statement_1918 )
    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 662:4: reference equals_op NULL
    @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1927 )
    reference309 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference309.tree )

    @state.following.push( TOKENS_FOLLOWING_equals_op_IN_constraint_statement_1929 )
    equals_op310 = equals_op
    @state.following.pop
    @adaptor.add_child( root_0, equals_op310.tree )

    __NULL311__ = match( NULL, TOKENS_FOLLOWING_NULL_IN_constraint_statement_1931 )
    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 667:4: reference not_equals_op value
    @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1940 )
    reference312 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference312.tree )

    @state.following.push( TOKENS_FOLLOWING_not_equals_op_IN_constraint_statement_1942 )
    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_1944 )
    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 672:4: reference not_equals_op NULL
    @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1953 )
    reference315 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference315.tree )

    @state.following.push( TOKENS_FOLLOWING_not_equals_op_IN_constraint_statement_1955 )
    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_1957 )
    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 677:4: conditional_constraint
    @state.following.push( TOKENS_FOLLOWING_conditional_constraint_IN_constraint_statement_1966 )
    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 682:4: reference ( 'is' )? 'in' set_value
    @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1975 )
    reference319 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference319.tree )

    # at line 682:14: ( 'is' )?
    alt_121 = 2
    look_121_0 = @input.peek( 1 )

    if ( look_121_0 == T__66 )
      alt_121 = 1
    end
    case alt_121
    when 1
      # at line 682:14: 'is'
      string_literal320 = match( T__66, TOKENS_FOLLOWING_T__66_IN_constraint_statement_1977 )
      tree_for_string_literal320 = @adaptor.create_with_payload( string_literal320 )
      @adaptor.add_child( root_0, tree_for_string_literal320 )



    end
    string_literal321 = match( T__64, TOKENS_FOLLOWING_T__64_IN_constraint_statement_1980 )
    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_1982 )
    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 694:4: reference ( 'isnot' | 'isnt' | 'not' ) 'in' set_value
    @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_1991 )
    reference323 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference323.tree )


    set324 = @input.look

    if @input.peek( 1 ).between?( T__68, T__69 ) || @input.peek(1) == T__73
      @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__64, TOKENS_FOLLOWING_T__64_IN_constraint_statement_2001 )
    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_2003 )
    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 709:4: reference 'has' value
    @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_2012 )
    reference327 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference327.tree )

    string_literal328 = match( T__62, TOKENS_FOLLOWING_T__62_IN_constraint_statement_2014 )
    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_2016 )
    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 718:4: reference binary_comp comp_value
    @state.following.push( TOKENS_FOLLOWING_reference_IN_constraint_statement_2025 )
    reference330 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference330.tree )

    @state.following.push( TOKENS_FOLLOWING_binary_comp_IN_constraint_statement_2027 )
    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_2029 )
    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 723:4: total_constraint
    @state.following.push( TOKENS_FOLLOWING_total_constraint_IN_constraint_statement_2038 )
    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__, 40 )


  end

  return return_value
end
dep_effect() click to toggle source

parser rule dep_effect

(in SfpLang.g) 289:1: dep_effect : reference equals_op ( value | NULL ) ;

# File lib/sfp/SfpLangParser.rb, line 2906
def dep_effect
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 18 )


  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 290:4: reference equals_op ( value | NULL )
  @state.following.push( TOKENS_FOLLOWING_reference_IN_dep_effect_692 )
  reference101 = reference
  @state.following.pop
  @adaptor.add_child( root_0, reference101.tree )

  @state.following.push( TOKENS_FOLLOWING_equals_op_IN_dep_effect_694 )
  equals_op102 = equals_op
  @state.following.pop
  @adaptor.add_child( root_0, equals_op102.tree )

  # at line 291: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__20 || look_43_0 == T__35 || look_43_0 == T__41 )
    alt_43 = 1
  elsif ( look_43_0 == NULL )
    alt_43 = 2
  else
    raise NoViableAlternative( "", 43, 0 )

  end
  case alt_43
  when 1
    # at line 291:5: value
    @state.following.push( TOKENS_FOLLOWING_value_IN_dep_effect_701 )
    value103 = value
    @state.following.pop
    @adaptor.add_child( root_0, value103.tree )


  when 2
    # at line 292:5: NULL
    __NULL104__ = match( NULL, TOKENS_FOLLOWING_NULL_IN_dep_effect_707 )
    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__, 18 )


  end

  return return_value
end
effect_body() click to toggle source

parser rule effect_body

(in SfpLang.g) 792:1: effect_body : ( ( mutation | mutation_iterator ) ( NL )+ )* ;

# File lib/sfp/SfpLangParser.rb, line 8711
def effect_body
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 47 )


  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 793:4: ( ( mutation | mutation_iterator ) ( NL )+ )*
  # at line 793: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__50 || look_132_0 == T__58 )
      alt_132 = 1

    end
    case alt_132
    when 1
      # at line 794:4: ( mutation | mutation_iterator ) ( NL )+
      # at line 794:4: ( mutation | mutation_iterator )
      alt_130 = 2
      look_130_0 = @input.peek( 1 )

      if ( look_130_0 == ID || look_130_0 == T__50 )
        alt_130 = 1
      elsif ( look_130_0 == T__58 )
        alt_130 = 2
      else
        raise NoViableAlternative( "", 130, 0 )

      end
      case alt_130
      when 1
        # at line 794:6: mutation
        @state.following.push( TOKENS_FOLLOWING_mutation_IN_effect_body_2235 )
        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 796:6: mutation_iterator
        @state.following.push( TOKENS_FOLLOWING_mutation_iterator_IN_effect_body_2248 )
        mutation_iterator362 = mutation_iterator
        @state.following.pop
        @adaptor.add_child( root_0, mutation_iterator362.tree )


      end
      # at file 798: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 798:3: NL
          __NL363__ = match( NL, TOKENS_FOLLOWING_NL_IN_effect_body_2257 )
          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__, 47 )


  end

  return return_value
end
effects() click to toggle source

parser rule effects

(in SfpLang.g) 392:1: effects : ( ‘effects’ | ‘effect’ ) ‘{’ ( NL )* effect_body ‘}’ ( NL )+ ;

# File lib/sfp/SfpLangParser.rb, line 4340
def effects
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 27 )


  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 393:4: ( 'effects' | 'effect' ) '{' ( NL )* effect_body '}' ( NL )+
  set161 = @input.look

  if @input.peek( 1 ).between?( T__51, T__52 )
    @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__85, TOKENS_FOLLOWING_T__85_IN_effects_1065 )
  tree_for_char_literal162 = @adaptor.create_with_payload( char_literal162 )
  @adaptor.add_child( root_0, tree_for_char_literal162 )


  # at line 399: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 399:7: NL
      __NL163__ = match( NL, TOKENS_FOLLOWING_NL_IN_effects_1067 )
      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_1073 )
  effect_body164 = effect_body
  @state.following.pop
  @adaptor.add_child( root_0, effect_body164.tree )

  char_literal165 = match( T__86, TOKENS_FOLLOWING_T__86_IN_effects_1078 )
  tree_for_char_literal165 = @adaptor.create_with_payload( char_literal165 )
  @adaptor.add_child( root_0, tree_for_char_literal165 )


  # at file 401: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 401:7: NL
      __NL166__ = match( NL, TOKENS_FOLLOWING_NL_IN_effects_1080 )
      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__, 27 )


  end

  return return_value
end
equals_op() click to toggle source

parser rule equals_op

(in SfpLang.g) 991:1: equals_op : ( ‘=’ | ‘is’ );

# File lib/sfp/SfpLangParser.rb, line 10522
def equals_op
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 61 )


  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__32 || @input.peek(1) == T__66
    @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__, 61 )


  end

  return return_value
end
extends_class() click to toggle source

parser rule extends_class

(in SfpLang.g) 118:1: extends_class returns [val] : ‘extends’ path ;

# File lib/sfp/SfpLangParser.rb, line 1150
def extends_class
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 8 )


  return_value = ExtendsClassReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  string_literal37 = nil
  path38 = nil


  tree_for_string_literal37 = nil

  begin
  root_0 = @adaptor.create_flat_list


  # at line 119:4: 'extends' path
  string_literal37 = match( T__55, TOKENS_FOLLOWING_T__55_IN_extends_class_302 )
  tree_for_string_literal37 = @adaptor.create_with_payload( string_literal37 )
  @adaptor.add_child( root_0, tree_for_string_literal37 )


  @state.following.push( TOKENS_FOLLOWING_path_IN_extends_class_304 )
  path38 = path
  @state.following.pop
  @adaptor.add_child( root_0, path38.tree )


  # --> action

                    return_value.val = self.to_ref(( path38 && @input.to_s( path38.start, path38.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__, 8 )


  end

  return return_value
end
global_constraint() click to toggle source

parser rule global_constraint

(in SfpLang.g) 422:1: global_constraint : ( ‘global’ | ‘always’ ) ( ‘constraint’ )? ( NL )* ‘{’ ( NL )* constraint_body ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 4690
def global_constraint
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 29 )


  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 423:4: ( 'global' | 'always' ) ( 'constraint' )? ( NL )* '{' ( NL )* constraint_body '}'
  set174 = @input.look

  if @input.peek(1) == T__40 || @input.peek(1) == T__60
    @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 423:24: ( 'constraint' )?
  alt_69 = 2
  look_69_0 = @input.peek( 1 )

  if ( look_69_0 == T__48 )
    alt_69 = 1
  end
  case alt_69
  when 1
    # at line 423:24: 'constraint'
    string_literal175 = match( T__48, TOKENS_FOLLOWING_T__48_IN_global_constraint_1139 )
    tree_for_string_literal175 = @adaptor.create_with_payload( string_literal175 )
    @adaptor.add_child( root_0, tree_for_string_literal175 )



  end
  # at line 423: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 423:38: NL
      __NL176__ = match( NL, TOKENS_FOLLOWING_NL_IN_global_constraint_1142 )
      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__85, TOKENS_FOLLOWING_T__85_IN_global_constraint_1151 )
  tree_for_char_literal177 = @adaptor.create_with_payload( char_literal177 )
  @adaptor.add_child( root_0, tree_for_char_literal177 )


  # at line 428: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 428:7: NL
      __NL178__ = match( NL, TOKENS_FOLLOWING_NL_IN_global_constraint_1153 )
      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_1156 )
  constraint_body179 = constraint_body
  @state.following.pop
  @adaptor.add_child( root_0, constraint_body179.tree )

  char_literal180 = match( T__86, TOKENS_FOLLOWING_T__86_IN_global_constraint_1158 )
  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__, 29 )


  end

  return return_value
end
goal_body() click to toggle source

parser rule goal_body

(in SfpLang.g) 443: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 )+ );

# File lib/sfp/SfpLangParser.rb, line 5026
def goal_body
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 31 )


  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 444: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__54, T__57, T__58, T__59, T__63, T__73, T__83 then alt_99 = 1
  when T__40, T__60 then alt_99 = 2
  when T__78 then alt_99 = 3
  when T__84 then alt_99 = 4
  when T__39 then alt_99 = 5
  when T__44 then alt_99 = 6
  else
    raise NoViableAlternative( "", 99, 0 )

  end
  case alt_99
  when 1
    root_0 = @adaptor.create_flat_list


    # at line 444:4: ( ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ )
    # at line 444:4: ( ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+ )
    # at line 445:4: ( constraint_statement | constraint_namespace | constraint_iterator | constraint_class_quantification ) ( NL )+
    # at line 445: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 445:6: constraint_statement
      @state.following.push( TOKENS_FOLLOWING_constraint_statement_IN_goal_body_1217 )
      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 449:6: constraint_namespace
      @state.following.push( TOKENS_FOLLOWING_constraint_namespace_IN_goal_body_1230 )
      constraint_namespace189 = constraint_namespace
      @state.following.pop
      @adaptor.add_child( root_0, constraint_namespace189.tree )


    when 3
      # at line 450:6: constraint_iterator
      @state.following.push( TOKENS_FOLLOWING_constraint_iterator_IN_goal_body_1237 )
      constraint_iterator190 = constraint_iterator
      @state.following.pop
      @adaptor.add_child( root_0, constraint_iterator190.tree )


    when 4
      # at line 451:6: constraint_class_quantification
      @state.following.push( TOKENS_FOLLOWING_constraint_class_quantification_IN_goal_body_1244 )
      constraint_class_quantification191 = constraint_class_quantification
      @state.following.pop
      @adaptor.add_child( root_0, constraint_class_quantification191.tree )


    end
    # at file 453: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 453:3: NL
        __NL192__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1253 )
        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 454:4: ( 'always' | 'global' ) ( NL )* '{' ( NL )* constraint_body '}' ( NL )+
    set193 = @input.look

    if @input.peek(1) == T__40 || @input.peek(1) == T__60
      @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 454: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 454:24: NL
        __NL194__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1266 )
        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__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1275 )
    tree_for_char_literal195 = @adaptor.create_with_payload( char_literal195 )
    @adaptor.add_child( root_0, tree_for_char_literal195 )


    # at line 460: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 460:7: NL
        __NL196__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1277 )
        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_1280 )
    constraint_body197 = constraint_body
    @state.following.pop
    @adaptor.add_child( root_0, constraint_body197.tree )

    char_literal198 = match( T__86, TOKENS_FOLLOWING_T__86_IN_goal_body_1282 )
    tree_for_char_literal198 = @adaptor.create_with_payload( char_literal198 )
    @adaptor.add_child( root_0, tree_for_char_literal198 )


    # at file 460: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 460:31: NL
        __NL199__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1284 )
        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 462:4: 'sometime' ( NL )* '{' ( NL )* constraint_body '}' ( NL )+
    string_literal200 = match( T__78, TOKENS_FOLLOWING_T__78_IN_goal_body_1294 )
    tree_for_string_literal200 = @adaptor.create_with_payload( string_literal200 )
    @adaptor.add_child( root_0, tree_for_string_literal200 )


    # at line 462: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 462:15: NL
        __NL201__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1296 )
        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__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1305 )
    tree_for_char_literal202 = @adaptor.create_with_payload( char_literal202 )
    @adaptor.add_child( root_0, tree_for_char_literal202 )


    # at line 471: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 471:7: NL
        __NL203__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1307 )
        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_1310 )
    constraint_body204 = constraint_body
    @state.following.pop
    @adaptor.add_child( root_0, constraint_body204.tree )

    char_literal205 = match( T__86, TOKENS_FOLLOWING_T__86_IN_goal_body_1312 )
    tree_for_char_literal205 = @adaptor.create_with_payload( char_literal205 )
    @adaptor.add_child( root_0, tree_for_char_literal205 )


    # at file 471: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 471:31: NL
        __NL206__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1314 )
        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 474:4: 'within' NUMBER ( NL )* '{' ( NL )* constraint_body '}' ( NL )+
    string_literal207 = match( T__84, TOKENS_FOLLOWING_T__84_IN_goal_body_1328 )
    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_1330 )
    tree_for_NUMBER208 = @adaptor.create_with_payload( __NUMBER208__ )
    @adaptor.add_child( root_0, tree_for_NUMBER208 )


    # at line 474: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 474:20: NL
        __NL209__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1332 )
        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__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1341 )
    tree_for_char_literal210 = @adaptor.create_with_payload( char_literal210 )
    @adaptor.add_child( root_0, tree_for_char_literal210 )


    # at line 481: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 481:7: NL
        __NL211__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1343 )
        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_1346 )
    constraint_body212 = constraint_body
    @state.following.pop
    @adaptor.add_child( root_0, constraint_body212.tree )

    char_literal213 = match( T__86, TOKENS_FOLLOWING_T__86_IN_goal_body_1348 )
    tree_for_char_literal213 = @adaptor.create_with_payload( char_literal213 )
    @adaptor.add_child( root_0, tree_for_char_literal213 )


    # at file 481: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 481:31: NL
        __NL214__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1350 )
        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 483:4: 'after' ( NL )* '{' ( NL )* constraint_body '}' ( NL )* ( 'then' | 'within' NUMBER ) ( NL )* '{' ( NL )* constraint_body '}' ( NL )+
    string_literal215 = match( T__39, TOKENS_FOLLOWING_T__39_IN_goal_body_1360 )
    tree_for_string_literal215 = @adaptor.create_with_payload( string_literal215 )
    @adaptor.add_child( root_0, tree_for_string_literal215 )


    # at line 483: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 483:12: NL
        __NL216__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1362 )
        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__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1371 )
    tree_for_char_literal217 = @adaptor.create_with_payload( char_literal217 )
    @adaptor.add_child( root_0, tree_for_char_literal217 )


    # at line 496: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 496:7: NL
        __NL218__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1373 )
        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_1376 )
    constraint_body219 = constraint_body
    @state.following.pop
    @adaptor.add_child( root_0, constraint_body219.tree )

    char_literal220 = match( T__86, TOKENS_FOLLOWING_T__86_IN_goal_body_1378 )
    tree_for_char_literal220 = @adaptor.create_with_payload( char_literal220 )
    @adaptor.add_child( root_0, tree_for_char_literal220 )


    # at line 496: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 496:31: NL
        __NL221__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1380 )
        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 498:3: ( 'then' | 'within' NUMBER )
    alt_89 = 2
    look_89_0 = @input.peek( 1 )

    if ( look_89_0 == T__82 )
      alt_89 = 1
    elsif ( look_89_0 == T__84 )
      alt_89 = 2
    else
      raise NoViableAlternative( "", 89, 0 )

    end
    case alt_89
    when 1
      # at line 498:5: 'then'
      string_literal222 = match( T__82, TOKENS_FOLLOWING_T__82_IN_goal_body_1391 )
      tree_for_string_literal222 = @adaptor.create_with_payload( string_literal222 )
      @adaptor.add_child( root_0, tree_for_string_literal222 )



    when 2
      # at line 499:6: 'within' NUMBER
      string_literal223 = match( T__84, TOKENS_FOLLOWING_T__84_IN_goal_body_1398 )
      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_1400 )
      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 501: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 501:5: NL
        __NL225__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1412 )
        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__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1421 )
    tree_for_char_literal226 = @adaptor.create_with_payload( char_literal226 )
    @adaptor.add_child( root_0, tree_for_char_literal226 )


    # at line 506: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 506:7: NL
        __NL227__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1423 )
        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_1426 )
    constraint_body228 = constraint_body
    @state.following.pop
    @adaptor.add_child( root_0, constraint_body228.tree )

    char_literal229 = match( T__86, TOKENS_FOLLOWING_T__86_IN_goal_body_1428 )
    tree_for_char_literal229 = @adaptor.create_with_payload( char_literal229 )
    @adaptor.add_child( root_0, tree_for_char_literal229 )


    # at file 506: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 506:31: NL
        __NL230__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1430 )
        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 510:4: 'before' ( NL )* '{' ( NL )* constraint_body '}' ( NL )* 'then' ( NL )* '{' ( NL )* constraint_body '}' ( NL )+
    string_literal231 = match( T__44, TOKENS_FOLLOWING_T__44_IN_goal_body_1448 )
    tree_for_string_literal231 = @adaptor.create_with_payload( string_literal231 )
    @adaptor.add_child( root_0, tree_for_string_literal231 )


    # at line 510: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 510:13: NL
        __NL232__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1450 )
        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__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1459 )
    tree_for_char_literal233 = @adaptor.create_with_payload( char_literal233 )
    @adaptor.add_child( root_0, tree_for_char_literal233 )


    # at line 518: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 518:7: NL
        __NL234__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1461 )
        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_1464 )
    constraint_body235 = constraint_body
    @state.following.pop
    @adaptor.add_child( root_0, constraint_body235.tree )

    char_literal236 = match( T__86, TOKENS_FOLLOWING_T__86_IN_goal_body_1466 )
    tree_for_char_literal236 = @adaptor.create_with_payload( char_literal236 )
    @adaptor.add_child( root_0, tree_for_char_literal236 )


    # at line 518: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 518:31: NL
        __NL237__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1468 )
        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__82, TOKENS_FOLLOWING_T__82_IN_goal_body_1477 )
    tree_for_string_literal238 = @adaptor.create_with_payload( string_literal238 )
    @adaptor.add_child( root_0, tree_for_string_literal238 )


    # at line 520: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 520:10: NL
        __NL239__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1479 )
        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__85, TOKENS_FOLLOWING_T__85_IN_goal_body_1488 )
    tree_for_char_literal240 = @adaptor.create_with_payload( char_literal240 )
    @adaptor.add_child( root_0, tree_for_char_literal240 )


    # at line 525: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 525:7: NL
        __NL241__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1490 )
        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_1493 )
    constraint_body242 = constraint_body
    @state.following.pop
    @adaptor.add_child( root_0, constraint_body242.tree )

    char_literal243 = match( T__86, TOKENS_FOLLOWING_T__86_IN_goal_body_1495 )
    tree_for_char_literal243 = @adaptor.create_with_payload( char_literal243 )
    @adaptor.add_child( root_0, tree_for_char_literal243 )


    # at file 525: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 525:31: NL
        __NL244__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_body_1497 )
        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__, 31 )


  end

  return return_value
end
goal_constraint() click to toggle source

parser rule goal_constraint

(in SfpLang.g) 408:1: goal_constraint : ‘goal’ ( ‘constraint’ )? ( NL )* ‘{’ ( NL )* ( goal_body )* ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 4505
def goal_constraint
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 28 )


  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 409:4: 'goal' ( 'constraint' )? ( NL )* '{' ( NL )* ( goal_body )* '}'
  string_literal167 = match( T__61, TOKENS_FOLLOWING_T__61_IN_goal_constraint_1096 )
  tree_for_string_literal167 = @adaptor.create_with_payload( string_literal167 )
  @adaptor.add_child( root_0, tree_for_string_literal167 )


  # at line 409:11: ( 'constraint' )?
  alt_65 = 2
  look_65_0 = @input.peek( 1 )

  if ( look_65_0 == T__48 )
    alt_65 = 1
  end
  case alt_65
  when 1
    # at line 409:11: 'constraint'
    string_literal168 = match( T__48, TOKENS_FOLLOWING_T__48_IN_goal_constraint_1098 )
    tree_for_string_literal168 = @adaptor.create_with_payload( string_literal168 )
    @adaptor.add_child( root_0, tree_for_string_literal168 )



  end
  # at line 409: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 409:25: NL
      __NL169__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_constraint_1101 )
      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__85, TOKENS_FOLLOWING_T__85_IN_goal_constraint_1110 )
  tree_for_char_literal170 = @adaptor.create_with_payload( char_literal170 )
  @adaptor.add_child( root_0, tree_for_char_literal170 )


  # at line 418: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 418:7: NL
      __NL171__ = match( NL, TOKENS_FOLLOWING_NL_IN_goal_constraint_1112 )
      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 418: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__39, T__40 ) || look_68_0 == T__44 || look_68_0 == T__54 || look_68_0.between?( T__57, T__60 ) || look_68_0 == T__63 || look_68_0 == T__73 || look_68_0 == T__78 || look_68_0.between?( T__83, T__84 ) )
      alt_68 = 1

    end
    case alt_68
    when 1
      # at line 418:11: goal_body
      @state.following.push( TOKENS_FOLLOWING_goal_body_IN_goal_constraint_1115 )
      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__86, TOKENS_FOLLOWING_T__86_IN_goal_constraint_1118 )
  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__, 28 )


  end

  return return_value
end
id_ref() click to toggle source

parser rule id_ref

(in SfpLang.g) 959:1: id_ref : ID ( ‘[’ NUMBER ‘]’ )? ;

# File lib/sfp/SfpLangParser.rb, line 10149
def id_ref
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 56 )


  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 960:4: ID ( '[' NUMBER ']' )?
  __ID419__ = match( ID, TOKENS_FOLLOWING_ID_IN_id_ref_2630 )
  tree_for_ID419 = @adaptor.create_with_payload( __ID419__ )
  @adaptor.add_child( root_0, tree_for_ID419 )


  # at line 960:6: ( '[' NUMBER ']' )?
  alt_146 = 2
  look_146_0 = @input.peek( 1 )

  if ( look_146_0 == T__35 )
    alt_146 = 1
  end
  case alt_146
  when 1
    # at line 960:7: '[' NUMBER ']'
    char_literal420 = match( T__35, TOKENS_FOLLOWING_T__35_IN_id_ref_2632 )
    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_2634 )
    tree_for_NUMBER421 = @adaptor.create_with_payload( __NUMBER421__ )
    @adaptor.add_child( root_0, tree_for_NUMBER421 )


    char_literal422 = match( T__36, TOKENS_FOLLOWING_T__36_IN_id_ref_2636 )
    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__, 56 )


  end

  return return_value
end
include() click to toggle source

parser rule include

(in SfpLang.g) 69:1: include : ‘include’ include_file ( NL )+ ;

# File lib/sfp/SfpLangParser.rb, line 576
def include
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 4 )


  return_value = IncludeReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  string_literal17 = nil
  __NL19__ = nil
  include_file18 = nil


  tree_for_string_literal17 = nil
  tree_for_NL19 = nil

  begin
  root_0 = @adaptor.create_flat_list


  # at line 70:4: 'include' include_file ( NL )+
  string_literal17 = match( T__65, TOKENS_FOLLOWING_T__65_IN_include_160 )
  tree_for_string_literal17 = @adaptor.create_with_payload( string_literal17 )
  @adaptor.add_child( root_0, tree_for_string_literal17 )


  @state.following.push( TOKENS_FOLLOWING_include_file_IN_include_162 )
  include_file18 = include_file
  @state.following.pop
  @adaptor.add_child( root_0, include_file18.tree )

  # at file 70: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 70:27: NL
      __NL19__ = match( NL, TOKENS_FOLLOWING_NL_IN_include_164 )
      tree_for_NL19 = @adaptor.create_with_payload( __NL19__ )
      @adaptor.add_child( root_0, tree_for_NL19 )



    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__, 4 )


  end

  return return_value
end
include_file() click to toggle source

parser rule include_file

(in SfpLang.g) 73:1: include_file : STRING ;

# File lib/sfp/SfpLangParser.rb, line 675
def include_file
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 5 )


  return_value = IncludeFileReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __STRING20__ = nil


  tree_for_STRING20 = nil

  begin
  root_0 = @adaptor.create_flat_list


  # at line 74:4: STRING
  __STRING20__ = match( STRING, TOKENS_FOLLOWING_STRING_IN_include_file_176 )
  tree_for_STRING20 = @adaptor.create_with_payload( __STRING20__ )
  @adaptor.add_child( root_0, tree_for_STRING20 )



  # --> action
   self.process_file(__STRING20__.text[1,__STRING20__.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__, 5 )


  end

  return return_value
end
mutation() click to toggle source

parser rule mutation

(in SfpLang.g) 819: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 ‘)’ );

# File lib/sfp/SfpLangParser.rb, line 9083
def mutation
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 49 )


  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 820: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 820:4: reference equals_op value
    @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2329 )
    reference374 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference374.tree )

    @state.following.push( TOKENS_FOLLOWING_equals_op_IN_mutation_2331 )
    equals_op375 = equals_op
    @state.following.pop
    @adaptor.add_child( root_0, equals_op375.tree )

    @state.following.push( TOKENS_FOLLOWING_value_IN_mutation_2333 )
    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 828:4: reference equals_op NULL
    @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2342 )
    reference377 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference377.tree )

    @state.following.push( TOKENS_FOLLOWING_equals_op_IN_mutation_2344 )
    equals_op378 = equals_op
    @state.following.pop
    @adaptor.add_child( root_0, equals_op378.tree )

    __NULL379__ = match( NULL, TOKENS_FOLLOWING_NULL_IN_mutation_2346 )
    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 836:4: reference binary_op NUMBER
    @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2355 )
    reference380 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference380.tree )

    @state.following.push( TOKENS_FOLLOWING_binary_op_IN_mutation_2357 )
    binary_op381 = binary_op
    @state.following.pop
    @adaptor.add_child( root_0, binary_op381.tree )

    __NUMBER382__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_mutation_2359 )
    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 844:4: reference 'is' 'new' path ( object_body )?
    @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2368 )
    reference383 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference383.tree )

    string_literal384 = match( T__66, TOKENS_FOLLOWING_T__66_IN_mutation_2370 )
    tree_for_string_literal384 = @adaptor.create_with_payload( string_literal384 )
    @adaptor.add_child( root_0, tree_for_string_literal384 )


    string_literal385 = match( T__72, TOKENS_FOLLOWING_T__72_IN_mutation_2372 )
    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_2374 )
    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 854:3: ( object_body )?
    alt_137 = 2
    look_137_0 = @input.peek( 1 )

    if ( look_137_0 == T__85 )
      alt_137 = 1
    end
    case alt_137
    when 1
      # at line 854:3: object_body
      @state.following.push( TOKENS_FOLLOWING_object_body_IN_mutation_2382 )
      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 861:4: 'delete' path
    string_literal388 = match( T__50, TOKENS_FOLLOWING_T__50_IN_mutation_2392 )
    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_2394 )
    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 870:4: reference 'add(' value ')'
    @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2403 )
    reference390 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference390.tree )

    string_literal391 = match( T__38, TOKENS_FOLLOWING_T__38_IN_mutation_2405 )
    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_2407 )
    value392 = value
    @state.following.pop
    @adaptor.add_child( root_0, value392.tree )

    char_literal393 = match( T__21, TOKENS_FOLLOWING_T__21_IN_mutation_2409 )
    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 878:4: reference 'remove(' value ')'
    @state.following.push( TOKENS_FOLLOWING_reference_IN_mutation_2418 )
    reference394 = reference
    @state.following.pop
    @adaptor.add_child( root_0, reference394.tree )

    string_literal395 = match( T__76, TOKENS_FOLLOWING_T__76_IN_mutation_2420 )
    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_2422 )
    value396 = value
    @state.following.pop
    @adaptor.add_child( root_0, value396.tree )

    char_literal397 = match( T__21, TOKENS_FOLLOWING_T__21_IN_mutation_2424 )
    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__, 49 )


  end

  return return_value
end
mutation_iterator() click to toggle source

parser rule mutation_iterator

(in SfpLang.g) 801:1: mutation_iterator : ‘foreach’ path ‘as’ ID ( NL )* ‘{’ ( NL )+ ( mutation ( NL )+ )* ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 8852
def mutation_iterator
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 48 )


  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 802:4: 'foreach' path 'as' ID ( NL )* '{' ( NL )+ ( mutation ( NL )+ )* '}'
  string_literal364 = match( T__58, TOKENS_FOLLOWING_T__58_IN_mutation_iterator_2272 )
  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_2274 )
  path365 = path
  @state.following.pop
  @adaptor.add_child( root_0, path365.tree )

  string_literal366 = match( T__43, TOKENS_FOLLOWING_T__43_IN_mutation_iterator_2276 )
  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_2278 )
  tree_for_ID367 = @adaptor.create_with_payload( __ID367__ )
  @adaptor.add_child( root_0, tree_for_ID367 )


  # at line 802: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 802:27: NL
      __NL368__ = match( NL, TOKENS_FOLLOWING_NL_IN_mutation_iterator_2280 )
      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__85, TOKENS_FOLLOWING_T__85_IN_mutation_iterator_2283 )
  tree_for_char_literal369 = @adaptor.create_with_payload( char_literal369 )
  @adaptor.add_child( root_0, tree_for_char_literal369 )


  # at file 802: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 802:35: NL
      __NL370__ = match( NL, TOKENS_FOLLOWING_NL_IN_mutation_iterator_2285 )
      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 812: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__50 )
      alt_136 = 1

    end
    case alt_136
    when 1
      # at line 812:4: mutation ( NL )+
      @state.following.push( TOKENS_FOLLOWING_mutation_IN_mutation_iterator_2295 )
      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 814: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 814:3: NL
          __NL372__ = match( NL, TOKENS_FOLLOWING_NL_IN_mutation_iterator_2303 )
          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__86, TOKENS_FOLLOWING_T__86_IN_mutation_iterator_2310 )
  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__, 48 )


  end

  return return_value
end
nested_constraint() click to toggle source

parser rule nested_constraint

(in SfpLang.g) 530:1: nested_constraint : ‘{’ ( NL )* constraint_body ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 6143
def nested_constraint
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 32 )


  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 531:4: '{' ( NL )* constraint_body '}'
  char_literal245 = match( T__85, TOKENS_FOLLOWING_T__85_IN_nested_constraint_1517 )
  tree_for_char_literal245 = @adaptor.create_with_payload( char_literal245 )
  @adaptor.add_child( root_0, tree_for_char_literal245 )


  # at line 531: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 531:8: NL
      __NL246__ = match( NL, TOKENS_FOLLOWING_NL_IN_nested_constraint_1519 )
      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_1522 )
  constraint_body247 = constraint_body
  @state.following.pop
  @adaptor.add_child( root_0, constraint_body247.tree )

  char_literal248 = match( T__86, TOKENS_FOLLOWING_T__86_IN_nested_constraint_1524 )
  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__, 32 )


  end

  return return_value
end
not_equals_op() click to toggle source

parser rule not_equals_op

(in SfpLang.g) 996:1: not_equals_op : ( ‘!=’ | ‘isnt’ | ‘isnot’ );

# File lib/sfp/SfpLangParser.rb, line 10593
def not_equals_op
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 62 )


  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__19 || @input.peek( 1 ).between?( T__68, T__69 )
    @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__, 62 )


  end

  return return_value
end
object_attribute() click to toggle source

parser rule object_attribute

(in SfpLang.g) 272:1: object_attribute : ( attribute | ID equals_op NULL ( NL )+ );

# File lib/sfp/SfpLangParser.rb, line 2434
def object_attribute
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 16 )


  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 273:2: ( attribute | ID equals_op NULL ( NL )+ )
  alt_34 = 2
  look_34_0 = @input.peek( 1 )

  if ( look_34_0 == T__56 )
    alt_34 = 1
  elsif ( look_34_0 == ID )
    look_34_2 = @input.peek( 2 )

    if ( look_34_2 == T__32 || look_34_2 == T__66 )
      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__20 || look_34_3 == T__35 || look_34_3 == T__41 )
        alt_34 = 1
      elsif ( look_34_3 == NULL )
        alt_34 = 2
      else
        raise NoViableAlternative( "", 34, 3 )

      end
    elsif ( look_34_2 == NL || look_34_2 == T__28 || look_34_2 == T__53 || look_34_2 == T__55 || look_34_2 == T__67 || look_34_2.between?( T__70, T__71 ) || look_34_2 == T__85 )
      alt_34 = 1
    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 273:4: attribute
    @state.following.push( TOKENS_FOLLOWING_attribute_IN_object_attribute_596 )
    attribute79 = attribute
    @state.following.pop
    @adaptor.add_child( root_0, attribute79.tree )


  when 2
    root_0 = @adaptor.create_flat_list


    # at line 274:4: ID equals_op NULL ( NL )+
    __ID80__ = match( ID, TOKENS_FOLLOWING_ID_IN_object_attribute_601 )
    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_603 )
    equals_op81 = equals_op
    @state.following.pop
    @adaptor.add_child( root_0, equals_op81.tree )

    __NULL82__ = match( NULL, TOKENS_FOLLOWING_NULL_IN_object_attribute_605 )
    tree_for_NULL82 = @adaptor.create_with_payload( __NULL82__ )
    @adaptor.add_child( root_0, tree_for_NULL82 )


    # at file 274: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 274:22: NL
        __NL83__ = match( NL, TOKENS_FOLLOWING_NL_IN_object_attribute_607 )
        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__, 16 )


  end

  return return_value
end
object_body() click to toggle source

parser rule object_body

(in SfpLang.g) 268:1: object_body : ‘{’ ( NL )* ( object_attribute | procedure ( NL )* )* ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 2281
def object_body
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 15 )


  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 269:4: '{' ( NL )* ( object_attribute | procedure ( NL )* )* '}'
  char_literal73 = match( T__85, TOKENS_FOLLOWING_T__85_IN_object_body_566 )
  tree_for_char_literal73 = @adaptor.create_with_payload( char_literal73 )
  @adaptor.add_child( root_0, tree_for_char_literal73 )


  # at line 269: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 269:8: NL
      __NL74__ = match( NL, TOKENS_FOLLOWING_NL_IN_object_body_568 )
      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 269: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__56 )
      alt_32 = 1
    elsif ( look_32_0 == T__75 || look_32_0.between?( T__80, T__81 ) )
      alt_32 = 2

    end
    case alt_32
    when 1
      # at line 269:14: object_attribute
      @state.following.push( TOKENS_FOLLOWING_object_attribute_IN_object_body_573 )
      object_attribute75 = object_attribute
      @state.following.pop
      @adaptor.add_child( root_0, object_attribute75.tree )


    when 2
      # at line 269:33: procedure ( NL )*
      @state.following.push( TOKENS_FOLLOWING_procedure_IN_object_body_577 )
      procedure76 = procedure
      @state.following.pop
      @adaptor.add_child( root_0, procedure76.tree )

      # at line 269: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 269:43: NL
          __NL77__ = match( NL, TOKENS_FOLLOWING_NL_IN_object_body_579 )
          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__86, TOKENS_FOLLOWING_T__86_IN_object_body_585 )
  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__, 15 )


  end

  return return_value
end
object_def() click to toggle source

parser rule object_def

(in SfpLang.g) 212:1: object_def returns [id] : ID ( ‘extends’ path )? ( ‘isa’ object_schema ( object_schemata )* )? ( object_body )? ;

# File lib/sfp/SfpLangParser.rb, line 2059
def object_def
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 14 )


  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 213:4: ID ( 'extends' path )? ( 'isa' object_schema ( object_schemata )* )? ( object_body )?
  __ID66__ = match( ID, TOKENS_FOLLOWING_ID_IN_object_def_505 )
  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'] = [] if !@now.has_key? '_finals'
                    @now['_finals'] << __ID66__.text if @is_final
            
  # <-- action

  # at line 219:3: ( 'extends' path )?
  alt_26 = 2
  look_26_0 = @input.peek( 1 )

  if ( look_26_0 == T__55 )
    alt_26 = 1
  end
  case alt_26
  when 1
    # at line 219:4: 'extends' path
    string_literal67 = match( T__55, TOKENS_FOLLOWING_T__55_IN_object_def_516 )
    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_518 )
    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 247:3: ( 'isa' object_schema ( object_schemata )* )?
  alt_28 = 2
  look_28_0 = @input.peek( 1 )

  if ( look_28_0 == T__67 )
    alt_28 = 1
  end
  case alt_28
  when 1
    # at line 247:4: 'isa' object_schema ( object_schemata )*
    string_literal69 = match( T__67, TOKENS_FOLLOWING_T__67_IN_object_def_536 )
    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_538 )
    object_schema70 = object_schema
    @state.following.pop
    @adaptor.add_child( root_0, object_schema70.tree )

    # at line 247:24: ( object_schemata )*
    while true # decision 27
      alt_27 = 2
      look_27_0 = @input.peek( 1 )

      if ( look_27_0 == T__24 )
        alt_27 = 1

      end
      case alt_27
      when 1
        # at line 247:25: object_schemata
        @state.following.push( TOKENS_FOLLOWING_object_schemata_IN_object_def_541 )
        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 248:3: ( object_body )?
  alt_29 = 2
  look_29_0 = @input.peek( 1 )

  if ( look_29_0 == T__85 )
    alt_29 = 1
  end
  case alt_29
  when 1
    # at line 248:3: object_body
    @state.following.push( TOKENS_FOLLOWING_object_body_IN_object_def_550 )
    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__, 14 )


  end

  return return_value
end
object_schema() click to toggle source

parser rule object_schema

(in SfpLang.g) 191:1: object_schema : path ( ‘[’ NUMBER ‘]’ )? ;

# File lib/sfp/SfpLangParser.rb, line 1807
def object_schema
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 11 )


  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 192:4: path ( '[' NUMBER ']' )?
  @state.following.push( TOKENS_FOLLOWING_path_IN_object_schema_442 )
  path58 = path
  @state.following.pop
  @adaptor.add_child( root_0, path58.tree )

  # at line 192:8: ( '[' NUMBER ']' )?
  alt_25 = 2
  look_25_0 = @input.peek( 1 )

  if ( look_25_0 == T__35 )
    alt_25 = 1
  end
  case alt_25
  when 1
    # at line 192:9: '[' NUMBER ']'
    char_literal59 = match( T__35, TOKENS_FOLLOWING_T__35_IN_object_schema_444 )
    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_446 )
    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__36, TOKENS_FOLLOWING_T__36_IN_object_schema_450 )
    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__, 11 )


  end

  return return_value
end
object_schemata() click to toggle source

parser rule object_schemata

(in SfpLang.g) 199:1: object_schemata : ‘,’ object_schema ;

# File lib/sfp/SfpLangParser.rb, line 1913
def object_schemata
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 12 )


  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 200:4: ',' object_schema
  char_literal62 = match( T__24, TOKENS_FOLLOWING_T__24_IN_object_schemata_467 )
  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_469 )
  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__, 12 )


  end

  return return_value
end
op_conditions() click to toggle source

parser rule op_conditions

(in SfpLang.g) 301:1: op_conditions : ( ‘conditions’ | ‘condition’ ) ‘{’ ( NL )* ( op_statement )* ‘}’ ( NL )+ ;

# File lib/sfp/SfpLangParser.rb, line 3115
def op_conditions
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 20 )


  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 302:4: ( 'conditions' | 'condition' ) '{' ( NL )* ( op_statement )* '}' ( NL )+
  set109 = @input.look

  if @input.peek( 1 ).between?( T__46, T__47 )
    @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__85, TOKENS_FOLLOWING_T__85_IN_op_conditions_753 )
  tree_for_char_literal110 = @adaptor.create_with_payload( char_literal110 )
  @adaptor.add_child( root_0, tree_for_char_literal110 )


  # at line 302: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 302:37: NL
      __NL111__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_conditions_755 )
      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 307: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 307:3: op_statement
      @state.following.push( TOKENS_FOLLOWING_op_statement_IN_op_conditions_764 )
      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__86, TOKENS_FOLLOWING_T__86_IN_op_conditions_769 )
  tree_for_char_literal113 = @adaptor.create_with_payload( char_literal113 )
  @adaptor.add_child( root_0, tree_for_char_literal113 )


  # at file 308: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 308:7: NL
      __NL114__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_conditions_771 )
      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__, 20 )


  end

  return return_value
end
op_effects() click to toggle source

parser rule op_effects

(in SfpLang.g) 312:1: op_effects : ‘effects’ ‘{’ ( NL )* ( op_statement )* ‘}’ ( NL )+ ;

# File lib/sfp/SfpLangParser.rb, line 3294
def op_effects
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 21 )


  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 313:4: 'effects' '{' ( NL )* ( op_statement )* '}' ( NL )+
  string_literal115 = match( T__52, TOKENS_FOLLOWING_T__52_IN_op_effects_787 )
  tree_for_string_literal115 = @adaptor.create_with_payload( string_literal115 )
  @adaptor.add_child( root_0, tree_for_string_literal115 )


  char_literal116 = match( T__85, TOKENS_FOLLOWING_T__85_IN_op_effects_789 )
  tree_for_char_literal116 = @adaptor.create_with_payload( char_literal116 )
  @adaptor.add_child( root_0, tree_for_char_literal116 )


  # at line 313: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 313:18: NL
      __NL117__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_effects_791 )
      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 318: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 318:3: op_statement
      @state.following.push( TOKENS_FOLLOWING_op_statement_IN_op_effects_800 )
      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__86, TOKENS_FOLLOWING_T__86_IN_op_effects_805 )
  tree_for_char_literal119 = @adaptor.create_with_payload( char_literal119 )
  @adaptor.add_child( root_0, tree_for_char_literal119 )


  # at file 319: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 319:7: NL
      __NL120__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_effects_807 )
      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__, 21 )


  end

  return return_value
end
op_param() click to toggle source

parser rule op_param

(in SfpLang.g) 296:1: op_param : ID equals_op reference ( NL )+ ;

# File lib/sfp/SfpLangParser.rb, line 3005
def op_param
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 19 )


  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 297:4: ID equals_op reference ( NL )+
  __ID105__ = match( ID, TOKENS_FOLLOWING_ID_IN_op_param_723 )
  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_725 )
  equals_op106 = equals_op
  @state.following.pop
  @adaptor.add_child( root_0, equals_op106.tree )

  @state.following.push( TOKENS_FOLLOWING_reference_IN_op_param_727 )
  reference107 = reference
  @state.following.pop
  @adaptor.add_child( root_0, reference107.tree )

  # at file 297: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 297:27: NL
      __NL108__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_param_729 )
      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__, 19 )


  end

  return return_value
end
op_statement() click to toggle source

parser rule op_statement

(in SfpLang.g) 323:1: op_statement : reference equals_op value ( NL )+ ;

# File lib/sfp/SfpLangParser.rb, line 3463
def op_statement
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 22 )


  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 324:4: reference equals_op value ( NL )+
  @state.following.push( TOKENS_FOLLOWING_reference_IN_op_statement_823 )
  reference121 = reference
  @state.following.pop
  @adaptor.add_child( root_0, reference121.tree )

  @state.following.push( TOKENS_FOLLOWING_equals_op_IN_op_statement_825 )
  equals_op122 = equals_op
  @state.following.pop
  @adaptor.add_child( root_0, equals_op122.tree )

  @state.following.push( TOKENS_FOLLOWING_value_IN_op_statement_827 )
  value123 = value
  @state.following.pop
  @adaptor.add_child( root_0, value123.tree )

  # at file 324: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 324:30: NL
      __NL124__ = match( NL, TOKENS_FOLLOWING_NL_IN_op_statement_829 )
      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__, 22 )


  end

  return return_value
end
parameter() click to toggle source

parser rule parameter

(in SfpLang.g) 356:1: parameter : ( ID ‘:’ path | ID reference_type | ID ‘areall’ path | ID ‘isset’ path );

# File lib/sfp/SfpLangParser.rb, line 3979
def parameter
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 25 )


  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 357: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__28 then alt_60 = 1
    when T__42 then alt_60 = 3
    when T__71 then alt_60 = 4
    when T__70 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 357:4: ID ':' path
    __ID144__ = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_955 )
    tree_for_ID144 = @adaptor.create_with_payload( __ID144__ )
    @adaptor.add_child( root_0, tree_for_ID144 )


    char_literal145 = match( T__28, TOKENS_FOLLOWING_T__28_IN_parameter_957 )
    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_959 )
    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 363:4: ID reference_type
    __ID147__ = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_968 )
    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_970 )
    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 365:4: ID 'areall' path
    __ID149__ = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_979 )
    tree_for_ID149 = @adaptor.create_with_payload( __ID149__ )
    @adaptor.add_child( root_0, tree_for_ID149 )


    string_literal150 = match( T__42, TOKENS_FOLLOWING_T__42_IN_parameter_981 )
    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_983 )
    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 372:4: ID 'isset' path
    __ID152__ = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_992 )
    tree_for_ID152 = @adaptor.create_with_payload( __ID152__ )
    @adaptor.add_child( root_0, tree_for_ID152 )


    string_literal153 = match( T__71, TOKENS_FOLLOWING_T__71_IN_parameter_994 )
    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_996 )
    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__, 25 )


  end

  return return_value
end
parameters() click to toggle source

parser rule parameters

(in SfpLang.g) 352:1: parameters : ‘(’ parameter ( ‘,’ ( NL )* parameter )* ‘)’ ;

# File lib/sfp/SfpLangParser.rb, line 3849
def parameters
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 24 )


  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 353:4: '(' parameter ( ',' ( NL )* parameter )* ')'
  char_literal138 = match( T__20, TOKENS_FOLLOWING_T__20_IN_parameters_929 )
  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_931 )
  parameter139 = parameter
  @state.following.pop
  @adaptor.add_child( root_0, parameter139.tree )

  # at line 353:18: ( ',' ( NL )* parameter )*
  while true # decision 59
    alt_59 = 2
    look_59_0 = @input.peek( 1 )

    if ( look_59_0 == T__24 )
      alt_59 = 1

    end
    case alt_59
    when 1
      # at line 353:19: ',' ( NL )* parameter
      char_literal140 = match( T__24, TOKENS_FOLLOWING_T__24_IN_parameters_934 )
      tree_for_char_literal140 = @adaptor.create_with_payload( char_literal140 )
      @adaptor.add_child( root_0, tree_for_char_literal140 )


      # at line 353: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 353:23: NL
          __NL141__ = match( NL, TOKENS_FOLLOWING_NL_IN_parameters_936 )
          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_939 )
      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__21, TOKENS_FOLLOWING_T__21_IN_parameters_943 )
  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__, 24 )


  end

  return return_value
end
path() click to toggle source

parser rule path

(in SfpLang.g) 951:1: path : ID ( ‘.’ ID )* ;

# File lib/sfp/SfpLangParser.rb, line 9965
def path
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 54 )


  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 952:4: ID ( '.' ID )*
  __ID413__ = match( ID, TOKENS_FOLLOWING_ID_IN_path_2598 )
  tree_for_ID413 = @adaptor.create_with_payload( __ID413__ )
  @adaptor.add_child( root_0, tree_for_ID413 )


  # at line 952:6: ( '.' ID )*
  while true # decision 144
    alt_144 = 2
    look_144_0 = @input.peek( 1 )

    if ( look_144_0 == T__26 )
      alt_144 = 1

    end
    case alt_144
    when 1
      # at line 952:7: '.' ID
      char_literal414 = match( T__26, TOKENS_FOLLOWING_T__26_IN_path_2600 )
      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_2601 )
      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__, 54 )


  end

  return return_value
end
path_with_index() click to toggle source

parser rule path_with_index

(in SfpLang.g) 955:1: path_with_index : id_ref ( ‘.’ id_ref )* ;

# File lib/sfp/SfpLangParser.rb, line 10058
def path_with_index
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 55 )


  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 956:4: id_ref ( '.' id_ref )*
  @state.following.push( TOKENS_FOLLOWING_id_ref_IN_path_with_index_2614 )
  id_ref416 = id_ref
  @state.following.pop
  @adaptor.add_child( root_0, id_ref416.tree )

  # at line 956:10: ( '.' id_ref )*
  while true # decision 145
    alt_145 = 2
    look_145_0 = @input.peek( 1 )

    if ( look_145_0 == T__26 )
      alt_145 = 1

    end
    case alt_145
    when 1
      # at line 956:11: '.' id_ref
      char_literal417 = match( T__26, TOKENS_FOLLOWING_T__26_IN_path_with_index_2616 )
      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_2617 )
      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__, 55 )


  end

  return return_value
end
placement() click to toggle source

parser rule placement

(in SfpLang.g) 49:1: placement : ‘!’ path assignment ;

# File lib/sfp/SfpLangParser.rb, line 389
def placement
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 2 )


  return_value = PlacementReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  char_literal11 = nil
  path12 = nil
  assignment13 = nil


  tree_for_char_literal11 = nil

  begin
  root_0 = @adaptor.create_flat_list


  # at line 50:4: '!' path assignment[id]
  char_literal11 = match( T__18, TOKENS_FOLLOWING_T__18_IN_placement_113 )
  tree_for_char_literal11 = @adaptor.create_with_payload( char_literal11 )
  @adaptor.add_child( root_0, tree_for_char_literal11 )


  @state.following.push( TOKENS_FOLLOWING_path_IN_placement_115 )
  path12 = path
  @state.following.pop
  @adaptor.add_child( root_0, path12.tree )


  # --> action

                    ref = "$.#{( path12 && @input.to_s( path12.start, path12.stop ) )}"
                    parent, id = ref.pop_ref
                    @now = @root.at?(parent)
                    fail "parent #{parent} is not exist" if not @now.is_a?(Hash)
            
  # <-- action

  @state.following.push( TOKENS_FOLLOWING_assignment_IN_placement_123 )
  assignment13 = assignment( id )
  @state.following.pop
  @adaptor.add_child( root_0, assignment13.tree )


  # --> action

                    @now = @root
            
  # <-- 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__, 2 )


  end

  return return_value
end
primitive_value() click to toggle source

parser rule primitive_value

(in SfpLang.g) 924:1: primitive_value returns [val, type] : ( BOOLEAN | NUMBER | STRING | MULTILINE_STRING );

# File lib/sfp/SfpLangParser.rb, line 9815
def primitive_value
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 53 )


  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 925: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 925:4: BOOLEAN
    __BOOLEAN409__ = match( BOOLEAN, TOKENS_FOLLOWING_BOOLEAN_IN_primitive_value_2556 )
    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 934:4: NUMBER
    __NUMBER410__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_primitive_value_2565 )
    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 939:4: STRING
    __STRING411__ = match( STRING, TOKENS_FOLLOWING_STRING_IN_primitive_value_2574 )
    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 944:4: MULTILINE_STRING
    __MULTILINE_STRING412__ = match( MULTILINE_STRING, TOKENS_FOLLOWING_MULTILINE_STRING_IN_primitive_value_2583 )
    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__, 53 )


  end

  return return_value
end
probability_op() click to toggle source

parser rule probability_op

(in SfpLang.g) 987:1: probability_op : ‘either’ ;

# File lib/sfp/SfpLangParser.rb, line 10461
def probability_op
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 60 )


  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 988:4: 'either'
  string_literal428 = match( T__53, TOKENS_FOLLOWING_T__53_IN_probability_op_2710 )
  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__, 60 )


  end

  return return_value
end
procedure() click to toggle source

parser rule procedure

(in SfpLang.g) 328:1: procedure : ( ‘synchronized’ )? ( ‘procedure’ | ‘sub’ ) ID ( parameters )? ‘{’ ( NL )* ( ‘cost’ equals_op NUMBER ( NL )+ )? ( conditions )? effects ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 3572
def procedure
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 23 )


  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 329:4: ( 'synchronized' )? ( 'procedure' | 'sub' ) ID ( parameters )? '{' ( NL )* ( 'cost' equals_op NUMBER ( NL )+ )? ( conditions )? effects '}'
  # --> action
    @synchronized = false  
  # <-- action

  # at line 330:3: ( 'synchronized' )?
  alt_52 = 2
  look_52_0 = @input.peek( 1 )

  if ( look_52_0 == T__81 )
    alt_52 = 1
  end
  case alt_52
  when 1
    # at line 330:4: 'synchronized'
    string_literal125 = match( T__81, TOKENS_FOLLOWING_T__81_IN_procedure_850 )
    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__75 || @input.peek(1) == T__80
    @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_864 )
  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 343:3: ( parameters )?
  alt_53 = 2
  look_53_0 = @input.peek( 1 )

  if ( look_53_0 == T__20 )
    alt_53 = 1
  end
  case alt_53
  when 1
    # at line 343:3: parameters
    @state.following.push( TOKENS_FOLLOWING_parameters_IN_procedure_872 )
    parameters128 = parameters
    @state.following.pop
    @adaptor.add_child( root_0, parameters128.tree )


  end
  char_literal129 = match( T__85, TOKENS_FOLLOWING_T__85_IN_procedure_875 )
  tree_for_char_literal129 = @adaptor.create_with_payload( char_literal129 )
  @adaptor.add_child( root_0, tree_for_char_literal129 )


  # at line 343: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 343:19: NL
      __NL130__ = match( NL, TOKENS_FOLLOWING_NL_IN_procedure_877 )
      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 344:3: ( 'cost' equals_op NUMBER ( NL )+ )?
  alt_56 = 2
  look_56_0 = @input.peek( 1 )

  if ( look_56_0 == T__49 )
    alt_56 = 1
  end
  case alt_56
  when 1
    # at line 344:5: 'cost' equals_op NUMBER ( NL )+
    string_literal131 = match( T__49, TOKENS_FOLLOWING_T__49_IN_procedure_885 )
    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_887 )
    equals_op132 = equals_op
    @state.following.pop
    @adaptor.add_child( root_0, equals_op132.tree )

    __NUMBER133__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_procedure_889 )
    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 346: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 346:4: NL
        __NL134__ = match( NL, TOKENS_FOLLOWING_NL_IN_procedure_899 )
        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 348:3: ( conditions )?
  alt_57 = 2
  look_57_0 = @input.peek( 1 )

  if ( look_57_0.between?( T__46, T__47 ) )
    alt_57 = 1
  end
  case alt_57
  when 1
    # at line 348:3: conditions
    @state.following.push( TOKENS_FOLLOWING_conditions_IN_procedure_909 )
    conditions135 = conditions
    @state.following.pop
    @adaptor.add_child( root_0, conditions135.tree )


  end
  @state.following.push( TOKENS_FOLLOWING_effects_IN_procedure_912 )
  effects136 = effects
  @state.following.pop
  @adaptor.add_child( root_0, effects136.tree )

  char_literal137 = match( T__86, TOKENS_FOLLOWING_T__86_IN_procedure_914 )
  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__, 23 )


  end

  return return_value
end
quantification_keyword() click to toggle source

parser rule quantification_keyword

(in SfpLang.g) 591:1: quantification_keyword : ( ‘forall’ | ‘exist’ | ‘forsome’ );

# File lib/sfp/SfpLangParser.rb, line 6960
def quantification_keyword
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 37 )


  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__54 || @input.peek(1) == T__57 || @input.peek(1) == T__59
    @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__, 37 )


  end

  return return_value
end
reference() click to toggle source

parser rule reference

(in SfpLang.g) 963:1: reference returns [val] : path_with_index ;

# File lib/sfp/SfpLangParser.rb, line 10243
def reference
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 57 )


  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 964:4: path_with_index
  @state.following.push( TOKENS_FOLLOWING_path_with_index_IN_reference_2653 )
  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__, 57 )


  end

  return return_value
end
reference_type() click to toggle source

parser rule reference_type

(in SfpLang.g) 968:1: reference_type returns [val] : ‘isref’ path ;

# File lib/sfp/SfpLangParser.rb, line 10308
def reference_type
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 58 )


  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 969:4: 'isref' path
  string_literal424 = match( T__70, TOKENS_FOLLOWING_T__70_IN_reference_type_2672 )
  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_2674 )
  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__, 58 )


  end

  return return_value
end
set_item() click to toggle source

parser rule set_item

(in SfpLang.g) 896:1: set_item : value ;

# File lib/sfp/SfpLangParser.rb, line 9607
def set_item
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 51 )


  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 897:4: value
  @state.following.push( TOKENS_FOLLOWING_value_IN_set_item_2491 )
  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__, 51 )


  end

  return return_value
end
set_type() click to toggle source

parser rule set_type

(in SfpLang.g) 977:1: set_type returns [val] : ‘isset’ path ;

# File lib/sfp/SfpLangParser.rb, line 10384
def set_type
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 59 )


  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 978:4: 'isset' path
  string_literal426 = match( T__71, TOKENS_FOLLOWING_T__71_IN_set_type_2693 )
  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_2695 )
  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__, 59 )


  end

  return return_value
end
set_value() click to toggle source

parser rule set_value

(in SfpLang.g) 888:1: set_value returns [val] : ( ‘(’ | ‘[’ ) ( set_item ( ‘,’ ( NL )* set_item )* )? ( ‘)’ | ‘]’ ) ;

# File lib/sfp/SfpLangParser.rb, line 9434
def set_value
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 50 )


  return_value = SetValueReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  set398 = nil
  char_literal400 = nil
  __NL401__ = nil
  set403 = nil
  set_item399 = nil
  set_item402 = nil


  tree_for_set398 = nil
  tree_for_char_literal400 = nil
  tree_for_NL401 = nil
  tree_for_set403 = nil

  begin
  root_0 = @adaptor.create_flat_list


  # at line 889:4: ( '(' | '[' ) ( set_item ( ',' ( NL )* set_item )* )? ( ')' | ']' )
  set398 = @input.look

  if @input.peek(1) == T__20 || @input.peek(1) == T__35
    @input.consume
    @adaptor.add_child( root_0, @adaptor.create_with_payload( set398 ) )

    @state.error_recovery = false

  else
    mse = MismatchedSet( nil )
    raise mse

  end



  # --> action
    @set = Array.new 
  # <-- action

  # at line 891: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__20 || look_141_0 == T__35 || look_141_0 == T__41 )
    alt_141 = 1
  end
  case alt_141
  when 1
    # at line 891:4: set_item ( ',' ( NL )* set_item )*
    @state.following.push( TOKENS_FOLLOWING_set_item_IN_set_value_2456 )
    set_item399 = set_item
    @state.following.pop
    @adaptor.add_child( root_0, set_item399.tree )

    # at line 891:13: ( ',' ( NL )* set_item )*
    while true # decision 140
      alt_140 = 2
      look_140_0 = @input.peek( 1 )

      if ( look_140_0 == T__24 )
        alt_140 = 1

      end
      case alt_140
      when 1
        # at line 891:14: ',' ( NL )* set_item
        char_literal400 = match( T__24, TOKENS_FOLLOWING_T__24_IN_set_value_2459 )
        tree_for_char_literal400 = @adaptor.create_with_payload( char_literal400 )
        @adaptor.add_child( root_0, tree_for_char_literal400 )


        # at line 891: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 891:18: NL
            __NL401__ = match( NL, TOKENS_FOLLOWING_NL_IN_set_value_2461 )
            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_2464 )
        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


  set403 = @input.look

  if @input.peek(1) == T__21 || @input.peek(1) == T__36
    @input.consume
    @adaptor.add_child( root_0, @adaptor.create_with_payload( set403 ) )

    @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__, 50 )


  end

  return return_value
end
sfp() click to toggle source

parser rule sfp

(in SfpLang.g) 39:1: sfp : ( NL )* ( ( object_def | abstract_object | state | constraint_def | class_def | procedure ) ( NL )* | include | placement )* ;

# File lib/sfp/SfpLangParser.rb, line 164
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
  placement10 = 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 | placement )*
  # --> 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 | placement )*
  while true # decision 4
    alt_4 = 4
    case look_4 = @input.peek( 1 )
    when ID, T__37, T__40, T__45, T__60, T__61, T__75, T__77, T__78, T__80, T__81 then alt_4 = 1
    when T__65 then alt_4 = 2
    when T__18 then alt_4 = 3
    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__79 )
        alt_2 = 3
      elsif ( look_2_1 == EOF || look_2_1 == ID || look_2_1 == NL || look_2_1 == T__18 || look_2_1 == T__37 || look_2_1 == T__40 || look_2_1 == T__45 || look_2_1 == T__55 || look_2_1.between?( T__60, T__61 ) || look_2_1 == T__65 || look_2_1 == T__67 || look_2_1 == T__75 || look_2_1.between?( T__77, T__78 ) || look_2_1.between?( T__80, T__81 ) || look_2_1 == T__85 )
        alt_2 = 1
      else
        raise NoViableAlternative( "", 2, 1 )

      end
      when T__37 then alt_2 = 2
      when T__40, T__60, T__61, T__78 then alt_2 = 4
      when T__45, T__77 then alt_2 = 5
      when T__75, T__80, T__81 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 )


    when 3
      # at line 44:5: placement
      @state.following.push( TOKENS_FOLLOWING_placement_IN_sfp_93 )
      placement10 = placement
      @state.following.pop
      @adaptor.add_child( root_0, placement10.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
sometime_constraint() click to toggle source

parser rule sometime_constraint

(in SfpLang.g) 432:1: sometime_constraint : ‘sometime’ ( ‘constraint’ )? ( NL )* ‘{’ ( NL )* constraint_body ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 4863
def sometime_constraint
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 30 )


  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 433:4: 'sometime' ( 'constraint' )? ( NL )* '{' ( NL )* constraint_body '}'
  string_literal181 = match( T__78, TOKENS_FOLLOWING_T__78_IN_sometime_constraint_1173 )
  tree_for_string_literal181 = @adaptor.create_with_payload( string_literal181 )
  @adaptor.add_child( root_0, tree_for_string_literal181 )


  # at line 433:15: ( 'constraint' )?
  alt_72 = 2
  look_72_0 = @input.peek( 1 )

  if ( look_72_0 == T__48 )
    alt_72 = 1
  end
  case alt_72
  when 1
    # at line 433:15: 'constraint'
    string_literal182 = match( T__48, TOKENS_FOLLOWING_T__48_IN_sometime_constraint_1175 )
    tree_for_string_literal182 = @adaptor.create_with_payload( string_literal182 )
    @adaptor.add_child( root_0, tree_for_string_literal182 )



  end
  # at line 433: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 433:29: NL
      __NL183__ = match( NL, TOKENS_FOLLOWING_NL_IN_sometime_constraint_1178 )
      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__85, TOKENS_FOLLOWING_T__85_IN_sometime_constraint_1187 )
  tree_for_char_literal184 = @adaptor.create_with_payload( char_literal184 )
  @adaptor.add_child( root_0, tree_for_char_literal184 )


  # at line 438: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 438:7: NL
      __NL185__ = match( NL, TOKENS_FOLLOWING_NL_IN_sometime_constraint_1189 )
      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_1192 )
  constraint_body186 = constraint_body
  @state.following.pop
  @adaptor.add_child( root_0, constraint_body186.tree )

  char_literal187 = match( T__86, TOKENS_FOLLOWING_T__86_IN_sometime_constraint_1194 )
  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__, 30 )


  end

  return return_value
end
state() click to toggle source

parser rule state

(in SfpLang.g) 78:1: state : ID ‘state’ ( NL )* ‘{’ ( NL )* ( attribute )* ‘}’ ;

# File lib/sfp/SfpLangParser.rb, line 741
def state
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 6 )


  return_value = StateReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __ID21__ = nil
  string_literal22 = nil
  __NL23__ = nil
  char_literal24 = nil
  __NL25__ = nil
  char_literal27 = nil
  attribute26 = nil


  tree_for_ID21 = nil
  tree_for_string_literal22 = nil
  tree_for_NL23 = nil
  tree_for_char_literal24 = nil
  tree_for_NL25 = nil
  tree_for_char_literal27 = nil

  begin
  root_0 = @adaptor.create_flat_list


  # at line 79:4: ID 'state' ( NL )* '{' ( NL )* ( attribute )* '}'
  __ID21__ = match( ID, TOKENS_FOLLOWING_ID_IN_state_192 )
  tree_for_ID21 = @adaptor.create_with_payload( __ID21__ )
  @adaptor.add_child( root_0, tree_for_ID21 )


  string_literal22 = match( T__79, TOKENS_FOLLOWING_T__79_IN_state_194 )
  tree_for_string_literal22 = @adaptor.create_with_payload( string_literal22 )
  @adaptor.add_child( root_0, tree_for_string_literal22 )


  # at line 79: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 79:15: NL
      __NL23__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_196 )
      tree_for_NL23 = @adaptor.create_with_payload( __NL23__ )
      @adaptor.add_child( root_0, tree_for_NL23 )



    else
      break # out of loop for decision 7
    end
  end # loop for decision 7


  # --> action

                    @now[__ID21__.text] = { '_self' => __ID21__.text,
                            '_context' => 'state',
                            '_parent' => @now
                    }
                    @now = @now[__ID21__.text]
            
  # <-- action

  char_literal24 = match( T__85, TOKENS_FOLLOWING_T__85_IN_state_205 )
  tree_for_char_literal24 = @adaptor.create_with_payload( char_literal24 )
  @adaptor.add_child( root_0, tree_for_char_literal24 )


  # at line 87: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 87:7: NL
      __NL25__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_207 )
      tree_for_NL25 = @adaptor.create_with_payload( __NL25__ )
      @adaptor.add_child( root_0, tree_for_NL25 )



    else
      break # out of loop for decision 8
    end
  end # loop for decision 8

  # at line 88:3: ( attribute )*
  while true # decision 9
    alt_9 = 2
    look_9_0 = @input.peek( 1 )

    if ( look_9_0 == ID || look_9_0 == T__56 )
      alt_9 = 1

    end
    case alt_9
    when 1
      # at line 88:3: attribute
      @state.following.push( TOKENS_FOLLOWING_attribute_IN_state_212 )
      attribute26 = attribute
      @state.following.pop
      @adaptor.add_child( root_0, attribute26.tree )


    else
      break # out of loop for decision 9
    end
  end # loop for decision 9

  char_literal27 = match( T__86, TOKENS_FOLLOWING_T__86_IN_state_217 )
  tree_for_char_literal27 = @adaptor.create_with_payload( char_literal27 )
  @adaptor.add_child( root_0, tree_for_char_literal27 )



  # --> 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__, 6 )


  end

  return return_value
end
state_dependency() click to toggle source

parser rule state_dependency

(in SfpLang.g) 278:1: state_dependency : ‘if’ dep_effect ( NL )* ‘then’ ( NL )* ‘{’ ( NL )* constraint_body ‘}’ ( ( NL )* ‘or’ ( NL )* ‘{’ ( NL )* constraint_body ‘}’ )* ( NL )+ ;

# File lib/sfp/SfpLangParser.rb, line 2590
def state_dependency
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 17 )


  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 279:4: 'if' dep_effect ( NL )* 'then' ( NL )* '{' ( NL )* constraint_body '}' ( ( NL )* 'or' ( NL )* '{' ( NL )* constraint_body '}' )* ( NL )+
  string_literal84 = match( T__63, TOKENS_FOLLOWING_T__63_IN_state_dependency_623 )
  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_627 )
  dep_effect85 = dep_effect
  @state.following.pop
  @adaptor.add_child( root_0, dep_effect85.tree )

  # at line 280: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 280:14: NL
      __NL86__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_629 )
      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__82, TOKENS_FOLLOWING_T__82_IN_state_dependency_632 )
  tree_for_string_literal87 = @adaptor.create_with_payload( string_literal87 )
  @adaptor.add_child( root_0, tree_for_string_literal87 )


  # at line 280: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 280:25: NL
      __NL88__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_634 )
      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__85, TOKENS_FOLLOWING_T__85_IN_state_dependency_637 )
  tree_for_char_literal89 = @adaptor.create_with_payload( char_literal89 )
  @adaptor.add_child( root_0, tree_for_char_literal89 )


  # at line 281: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 281:3: NL
      __NL90__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_641 )
      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_644 )
  constraint_body91 = constraint_body
  @state.following.pop
  @adaptor.add_child( root_0, constraint_body91.tree )

  char_literal92 = match( T__86, TOKENS_FOLLOWING_T__86_IN_state_dependency_649 )
  tree_for_char_literal92 = @adaptor.create_with_payload( char_literal92 )
  @adaptor.add_child( root_0, tree_for_char_literal92 )


  # at line 283: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 283:5: ( NL )* 'or' ( NL )* '{' ( NL )* constraint_body '}'
      # at line 283: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 283:5: NL
          __NL93__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_655 )
          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__74, TOKENS_FOLLOWING_T__74_IN_state_dependency_658 )
      tree_for_string_literal94 = @adaptor.create_with_payload( string_literal94 )
      @adaptor.add_child( root_0, tree_for_string_literal94 )


      # at line 283: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 283:14: NL
          __NL95__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_660 )
          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__85, TOKENS_FOLLOWING_T__85_IN_state_dependency_663 )
      tree_for_char_literal96 = @adaptor.create_with_payload( char_literal96 )
      @adaptor.add_child( root_0, tree_for_char_literal96 )


      # at line 284: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 284:3: NL
          __NL97__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_667 )
          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_670 )
      constraint_body98 = constraint_body
      @state.following.pop
      @adaptor.add_child( root_0, constraint_body98.tree )

      char_literal99 = match( T__86, TOKENS_FOLLOWING_T__86_IN_state_dependency_674 )
      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 286: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 286:3: NL
      __NL100__ = match( NL, TOKENS_FOLLOWING_NL_IN_state_dependency_680 )
      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__, 17 )


  end

  return return_value
end
total_constraint() click to toggle source

parser rule total_constraint

(in SfpLang.g) 726:1: total_constraint : ‘total(’ total_statement ‘)’ binary_comp NUMBER ;

# File lib/sfp/SfpLangParser.rb, line 7980
def total_constraint
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 41 )


  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 727:4: 'total(' total_statement ')' binary_comp NUMBER
  string_literal334 = match( T__83, TOKENS_FOLLOWING_T__83_IN_total_constraint_2049 )
  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_2051 )
  total_statement335 = total_statement
  @state.following.pop
  @adaptor.add_child( root_0, total_statement335.tree )

  char_literal336 = match( T__21, TOKENS_FOLLOWING_T__21_IN_total_constraint_2053 )
  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_2055 )
  binary_comp337 = binary_comp
  @state.following.pop
  @adaptor.add_child( root_0, binary_comp337.tree )

  __NUMBER338__ = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_total_constraint_2057 )
  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__, 41 )


  end

  return return_value
end
total_statement() click to toggle source

parser rule total_statement

(in SfpLang.g) 730:1: total_statement : reference equals_op value ;

# File lib/sfp/SfpLangParser.rb, line 8067
def total_statement
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 42 )


  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 731:4: reference equals_op value
  @state.following.push( TOKENS_FOLLOWING_reference_IN_total_statement_2068 )
  reference339 = reference
  @state.following.pop
  @adaptor.add_child( root_0, reference339.tree )

  @state.following.push( TOKENS_FOLLOWING_equals_op_IN_total_statement_2070 )
  equals_op340 = equals_op
  @state.following.pop
  @adaptor.add_child( root_0, equals_op340.tree )

  @state.following.push( TOKENS_FOLLOWING_value_IN_total_statement_2072 )
  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__, 42 )


  end

  return return_value
end
value() click to toggle source

parser rule value

(in SfpLang.g) 901:1: value returns [val, type] : ( primitive_value | reference | set_value | ‘any’ );

# File lib/sfp/SfpLangParser.rb, line 9672
def value
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 52 )


  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 902: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__20, T__35 then alt_142 = 3
  when T__41 then alt_142 = 4
  else
    raise NoViableAlternative( "", 142, 0 )

  end
  case alt_142
  when 1
    root_0 = @adaptor.create_flat_list


    # at line 902:4: primitive_value
    @state.following.push( TOKENS_FOLLOWING_primitive_value_IN_value_2510 )
    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 907:4: reference
    @state.following.push( TOKENS_FOLLOWING_reference_IN_value_2519 )
    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 912:4: set_value
    @state.following.push( TOKENS_FOLLOWING_set_value_IN_value_2528 )
    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 917:4: 'any'
    string_literal408 = match( T__41, TOKENS_FOLLOWING_T__41_IN_value_2537 )
    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__, 52 )


  end

  return return_value
end

Private Instance Methods

initialize_dfas() click to toggle source
Calls superclass method
# File lib/sfp/SfpLangParser.rb, line 11044
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