FortranParserActionTreeMaker.java
package fortran.ofp.parser.java;
import java.util.Stack;
import org.antlr.runtime.Token;
public class FortranParserActionTreeMaker implements IFortranParserAction {
private FortranNode root;
private Stack<FortranNode> stack = new Stack<FortranNode>();
public FortranParserActionTreeMaker(String[] args, IFortranParser parser,
String filename) {
super();
}
/**
* R102 [Begin] Generic Name List
*/
public void generic_name_list__begin() {
// Do nothing
}
/**
* R102 [List] Generic Name List
*/
public void generic_name_list(int count) {
int counter = count;
FortranNode temp = null;
FortranNode generic_name_list_Node = new FortranNode(102, "ArgsList["
+ counter + "]");
while (counter > 0) {
assert !stack.empty();
temp = stack.pop();
assert temp.rule() == 102;
generic_name_list_Node.addChild(0, temp);
counter--;
}
stack.push(generic_name_list_Node);
}
/**
* R102 [Element] Generic Name
*/
public void generic_name_list_part(Token ident) {
FortranNode generic_name_list_part_Node = new FortranNode(102,
"ArgName", ident);
stack.push(generic_name_list_part_Node);
}
/**
* R204 Specification Part
*/
public void specification_part(int numUseStmts, int numImportStmts,
int numImplStmts, int numDeclConstructs) {
int counter = 0;
FortranNode temp = null;
FortranNode specification_part_Node = new FortranNode(204, "SpecPart");
counter = numDeclConstructs;
while (counter > 0) {
assert !stack.empty();
temp = stack.pop();
assert temp.rule() == 207;
specification_part_Node.addChild(0, temp);
counter--;
}
counter = numImportStmts;
while (counter > 0) {
assert false;
assert !stack.empty();
temp = stack.pop();
assert temp.rule() == 1209;
specification_part_Node.addChild(0, temp);
counter--;
}
counter = numImplStmts;
assert counter == 0;
// According to the grammar(Ex_08), numImplStmts is 0
while (counter > 0) {
assert false;
assert !stack.empty();
temp = stack.pop();
assert temp.rule() == 549;
specification_part_Node.addChild(0, temp);
counter--;
}
counter = numUseStmts;
while (counter > 0) {
assert false;
assert !stack.empty();
temp = stack.pop();
assert temp.rule() == 1109;
specification_part_Node.addChild(0, temp);
counter--;
}
stack.push(specification_part_Node);
} // Test
/**
* R207 Declaration Construct
*/
public void declaration_construct() {
int rule = -1;
FortranNode temp = null;
FortranNode declaration_construct_Node = new FortranNode(207,
"DeclConstruct");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 429 /* DerivedTypeDef */
|| rule == 1235 /* EntryStmt */
|| rule == 460 /* EnumDef */
|| rule == 1001 /* FormatStmt */
|| rule == 1201 /* InterfBlock */
|| rule == 538 /* ParamStmt */
|| rule == 1211 /* ProcDeclStmt */
|| rule == 212 /* SpecStmt */
|| rule == 501 /* TypeDeclStmt */
|| rule == 1238 /* StmtFuncStmt */
;
declaration_construct_Node.addChild(temp);
stack.push(declaration_construct_Node);
} // Test
/**
* R208 Execution Part
*/
public void execution_part() {
int rule = -1;
FortranNode temp = null;
FortranNode execution_part_Node = new FortranNode(208, "ExecPart");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 213;
execution_part_Node.addChild(temp);
while (true) {
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
if (rule == 213 /* ExecConstruct */
|| rule == 1001 /* FormatStmt */
|| rule == 1235 /* EntryStmt */
|| rule == 524 /* DataStmt */
) {
execution_part_Node.addChild(0, temp);
} else {
stack.push(temp);
break;
}
}
stack.push(execution_part_Node);
} // Test
/**
* R209 Execution Part Construct
*/
public void execution_part_construct() {
// Omitted, with R 208
}
public void internal_subprogram_part(int count) {
} // TODO: Implement
/**
* R211
*/
public void internal_subprogram() {
} // TODO: Implement
/**
* R212 (Other) Specification Statement
*/
public void specification_stmt() {
int rule = -1;
FortranNode temp = null;
FortranNode specification_stmt_Node = new FortranNode(212, "SpecStmt");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 518 /* AccessStmt */
|| rule == 520 /* AllocatableStmt */
|| rule == 521 /* AsynchronousStmt */
|| rule == 522 /* BindStmt */
|| rule == 531 /* CodimensionStmt */
|| rule == 557 /* CommonStmt */
|| rule == 524 /* DataStmt */
|| rule == 535 /* DimensionStmt */
|| rule == 554 /* EquivalenceStmt */
|| rule == 1210 /* ExtStmt */
|| rule == 536 /* IntentStmt */
|| rule == 1216 /* IntrinsicStmt */
|| rule == 552 /* NamelistStmt */
|| rule == 537 /* OptionalStmt */
|| rule == 550 /* PtrStmt */
|| rule == 542 /* ProtectedStmt */
|| rule == 543 /* SaveStmt */
|| rule == 546 /* TargetStmt */
|| rule == 548 /* VolatileStmt */
|| rule == 547 /* ValueStmt */
;
specification_stmt_Node.addChild(temp);
stack.push(specification_stmt_Node);
} // Test
/**
* R213 Executable Construct
*/
public void executable_construct() {
int rule = -1;
FortranNode temp = null;
FortranNode executable_construct_Node = new FortranNode(213,
"ExecConstruct");
assert !stack.empty();
temp = stack.pop();
rule = temp.rule();
assert rule == 214 /* ActionStmt */
|| rule == 817 /* AssociateConstruct */
|| rule == 808 /* CaseConstruct */
|| rule == 825 /* DoConstruct */
|| rule == 752 /* ForallConstruct */
|| rule == 802 /* IfConstruct */
|| rule == 821 /* SelectTypeConstruct */
|| rule == 744 /* WhereConstruct */
;
executable_construct_Node.addChild(temp);
stack.push(executable_construct_Node);
} // Test
/**
* R214 Action Statement
*/
public void action_stmt() {
int rule = -1;
FortranNode temp = null;
FortranNode action_stmt_Node = new FortranNode(214, "ActionStmt");
assert !stack.empty();
temp = stack.pop();
rule = temp.rule();
assert rule == 623 /* AllocateStmt */
|| rule == 734 /* AssignmentStmt */
|| rule == 923 /* BackspaceStmt */
|| rule == 1218 /* CallStmt */
|| rule == 908 /* CloseStmt */
|| rule == 848 /* ContinueStmt */
|| rule == 843 /* CycleStmt */
|| rule == 635 /* DeallocateStmt */
|| rule == 924 /* EndfileStmt */
|| rule == 844 /* ExitStmt */
|| rule == 927 /* FlushStmt */
|| rule == 759 /* ForallStmt */
|| rule == 845 /* GotoStmt */
|| rule == 807 /* IfStmt */
|| rule == 929 /* InquireStmt */
|| rule == 633 /* NullifyStmt */
|| rule == 904 /* OpenStmt */
|| rule == 735 /* PtrAssignmentStmt */
|| rule == 912 /* PrintStmt */
|| rule == 910 /* ReadStmt */
|| rule == 1236 /* ReturnStmt */
|| rule == 925 /* RewindStmt */
|| rule == 849 /* StopStmt */
|| rule == 921 /* WaitStmt */
|| rule == 743 /* WhereStmt */
|| rule == 911 /* WriteStmt */
|| rule == 847 /* ArithmeticIfStmt */
|| rule == 846 /* ComputedGotoStmt */
|| rule == 0 /* AssignStmt <Deleted> */
|| rule == 0 /* AssignedGotoStmt <Deleted> */
|| rule == 0 /* PauseStmt <Deleted> */
;
action_stmt_Node.addChild(temp);
stack.push(action_stmt_Node);
} // Test
/**
* R215 Keyword
*/
public void keyword() {
assert false;
FortranNode temp = null;
FortranNode keyword_Node = new FortranNode(215, "F_Keyword");
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 304;
keyword_Node.addChild(temp);
stack.push(keyword_Node);
} // Test
/**
* R304 Name
*/
public void name(Token id) {
assert false;
FortranNode name_Node = new FortranNode(304, "F_Name");
FortranNode id_Node = new FortranNode("ID", id);
name_Node.addChild(id_Node);
stack.push(name_Node);
} // Test
/**
* R305 Constant
*/
public void constant(Token id) {
assert false;
FortranNode constant_Node = new FortranNode(305, "F_Const");
if (id != null) {
FortranNode id_Node = new FortranNode("ID", id);
constant_Node.addChild(id_Node);
} else {
FortranNode temp = null;
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 306;
constant_Node.addChild(temp);
}
stack.push(constant_Node);
} // Test
/**
* R
*/
public void scalar_constant() {
assert false;
} // TODO: Implement
/**
* R306 Literal Constant
*/
public void literal_constant() {
int rule = -1;
FortranNode temp = null;
FortranNode literal_constant_Node = new FortranNode(306, "LiteralConst");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 406 /* IntLitConst */
|| rule == 417 /* RealLitConst */
|| rule == 421 /* CompLitConst */
|| rule == 428 /* LogicLitConst */
|| rule == 427 /* CharLitConst */
|| rule == 411 /* BozLitConst */
|| rule == 0 /* HollerithLitConst <Deleted> */
;
literal_constant_Node.addChild(temp);
stack.push(literal_constant_Node);
} // Test
/**
* R308 Int Constant
*/
public void int_constant(Token id) {
assert false;
FortranNode int_constant_Node = new FortranNode(308, "IntConst");
if (id != null) {
FortranNode id_Node = new FortranNode("ID", id);
int_constant_Node.addChild(id_Node);
} else {
FortranNode temp = null;
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 406;
int_constant_Node.addChild(temp);
}
stack.push(int_constant_Node);
} // Test
/**
* R309 Char Constant
*/
public void char_constant(Token id) {
assert false;
FortranNode char_constant_Node = new FortranNode(309, "CharConst");
if (id != null) {
FortranNode id_Node = new FortranNode("ID", id);
char_constant_Node.addChild(id_Node);
} else {
FortranNode temp = null;
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 427;
char_constant_Node.addChild(temp);
}
stack.push(char_constant_Node);
} // Test
/**
* R310
*/
public void intrinsic_operator() {
} // TODO: Implement
/**
* R311
*/
public void defined_operator(Token definedOp, boolean isExtended) {
} // TODO: Implement
/**
* R312
*/
public void extended_intrinsic_op() {
} // TODO: Implement
/**
* R313 [Element]
*/
public void label(Token lbl) {
FortranNode label_Node = new FortranNode(313, "Lbl", lbl);
stack.push(label_Node);
} // TODO: Implement
/**
* R313 [Begin] Label List
*/
public void label_list__begin() {
// Do nothing
}
/**
* R313 [List] Label List
*/
public void label_list(int count) {
int counter = count;
FortranNode temp = null;
FortranNode label_list_Node = new FortranNode(313, "LblList[" + counter
+ "]");
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 313;
label_list_Node.addChild(0, temp);
counter--;
}
stack.push(label_list_Node);
} // TODO: Implement
/**
* R401
*/
public void type_spec() {
} // TODO: Implement
/**
* R402
*/
public void type_param_value(boolean hasExpr, boolean hasAsterisk,
boolean hasColon) {
} // TODO: Implement
/**
* R403 Intrinsic Type Specification
*/
public void intrinsic_type_spec(Token keyword1, Token keyword2, int type,
boolean hasKindSelector) {
int rule = -1;
FortranNode temp = null;
FortranNode intrinsic_type_spec_Node = new FortranNode(403,
"IntrinsicTypeSpec");
FortranNode keyword1_Node = new FortranNode("Keyword1", keyword1);
FortranNode keyword2_Node = new FortranNode("Keyword2", keyword2);
intrinsic_type_spec_Node.addChild(keyword1_Node);
intrinsic_type_spec_Node.addChild(keyword2_Node);
if (hasKindSelector) {
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 404 /* KindSelector */
|| rule == 424 /* CharSelector */
;
intrinsic_type_spec_Node.addChild(temp);
}
stack.push(intrinsic_type_spec_Node);
} // Test
/**
* R404 Kind Selector
*/
public void kind_selector(Token token1, Token token2, boolean hasExpression) {
FortranNode temp = null;
FortranNode kind_selector_Node = new FortranNode(404, "KindSelector");
FortranNode token1_Node = new FortranNode("Token1", token1);
FortranNode token2_Node = new FortranNode("Token2", token2);
kind_selector_Node.addChild(token1_Node);
kind_selector_Node.addChild(token2_Node);
if (hasExpression) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 701;
kind_selector_Node.addChild(temp);
}
stack.push(kind_selector_Node);
} // Test (May not only 701 Prim)
/**
* R405 Signed Int Literal Constant (Upgrade from R 406)
*/
public void signed_int_literal_constant(Token sign) {
FortranNode temp = null;
FortranNode sign_Node = new FortranNode("Sign", sign);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 406;
temp.addChild(0, sign_Node);
temp.setRule(405);
temp.setNodeName("SignedIntConst");
stack.push(temp);
} // Test
/**
* R406 Int Literal Constant
*/
public void int_literal_constant(Token digitString, Token kindParam) {
FortranNode int_literal_constant_Node = new FortranNode(406,
"IntLitConst");
FortranNode digitString_Node = new FortranNode("Digit", digitString);
FortranNode kindParam_Node = new FortranNode("Kind", kindParam);
int_literal_constant_Node.addChild(digitString_Node);
int_literal_constant_Node.addChild(kindParam_Node);
stack.push(int_literal_constant_Node);
} // Test
/**
* R407 Kind Parameter
*/
public void kind_param(Token kind) {
// Omitted, with R 406, 417, 428
}
/**
* R411 Boz Literal Constant
*/
public void boz_literal_constant(Token constant) {
FortranNode boz_literal_constant_Node = new FortranNode(411,
"BozLitConst");
FortranNode constant_Node = new FortranNode("Const", constant);
boz_literal_constant_Node.addChild(constant_Node);
stack.push(boz_literal_constant_Node);
} // Test
/**
* R416 Signed Real Literal Constant (Upgrade from R 417)
*/
public void signed_real_literal_constant(Token sign) {
FortranNode temp = null;
FortranNode sign_Node = new FortranNode("Sign", sign);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 417;
temp.addChild(0, sign_Node);
temp.setRule(416);
temp.setNodeName("SignedRealConst");
stack.push(temp);
} // Test
/**
* R417 Real Literal Constant
*/
public void real_literal_constant(Token realConstant, Token kindParam) {
FortranNode int_literal_constant_Node = new FortranNode(417,
"RealLitConst");
FortranNode realConstant_Node = new FortranNode("RealConst",
realConstant);
FortranNode kindParam_Node = new FortranNode("Kind", kindParam);
int_literal_constant_Node.addChild(realConstant_Node);
int_literal_constant_Node.addChild(kindParam_Node);
stack.push(int_literal_constant_Node);
} // Test
/**
* R421 Complex Literal Constant
*/
public void complex_literal_constant() {
FortranNode temp = null;
FortranNode complex_literal_constant_Node = new FortranNode(421,
"CompLitConst");
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 423;
complex_literal_constant_Node.addChild(temp);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 422;
complex_literal_constant_Node.addChild(0, temp);
stack.push(complex_literal_constant_Node);
} // Test
/**
* R422 Real Part (of R421)
*/
public void real_part(boolean hasIntConstant, boolean hasRealConstant,
Token id) {
FortranNode temp = null;
FortranNode real_part_Node = new FortranNode(422, "RealPart");
FortranNode id_Node = new FortranNode("ID");
if (hasIntConstant) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 405;
real_part_Node.addChild(temp);
} else if (hasRealConstant) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 416;
real_part_Node.addChild(temp);
} else {
real_part_Node.addChild(id_Node);
}
stack.push(real_part_Node);
} // Test
/**
* R423 Imagine Part (of R421)
*/
public void imag_part(boolean hasIntConstant, boolean hasRealConstant,
Token id) {
FortranNode temp = null;
FortranNode imag_part_Node = new FortranNode(423, "ImagPart");
FortranNode id_Node = new FortranNode("ID");
if (hasIntConstant) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 405;
imag_part_Node.addChild(temp);
} else if (hasRealConstant) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 416;
imag_part_Node.addChild(temp);
} else {
imag_part_Node.addChild(id_Node);
}
stack.push(imag_part_Node);
} // Test
/**
* R424
*/
public void char_selector(Token tk1, Token tk2, int kindOrLen1,
int kindOrLen2, boolean hasAsterisk) {
FortranNode temp = null;
FortranNode char_selector_Node = new FortranNode(424, "CharSelector");
FortranNode token1_Node = new FortranNode("Token1", tk1);
FortranNode token2_Node = new FortranNode("Token2", tk2);
char_selector_Node.addChild(token1_Node);
char_selector_Node.addChild(token2_Node);
if (hasAsterisk) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 426;
char_selector_Node.addChild(temp);
} else {
assert false; // TODO: Implement
if (kindOrLen1 == IActionEnums.KindLenParam_len) {
if (kindOrLen2 == IActionEnums.KindLenParam_kind) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 701;
char_selector_Node.addChild(temp);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 402;
char_selector_Node.addChild(temp);
} else { /* kindOfLen2 is KindLenParam_none */
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 402;
char_selector_Node.addChild(temp);
}
} else { /* kindOfLen1 is KindLenParam_kind */
if (kindOrLen2 == IActionEnums.KindLenParam_len) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 402;
char_selector_Node.addChild(temp);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 701;
char_selector_Node.addChild(temp);
} else { /* kindOfLen2 is KindLenParam_none */
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 701;
char_selector_Node.addChild(temp);
}
}
}
stack.push(char_selector_Node);
} // Test (Expr may not only 701Prim)
/**
* R425
*/
public void length_selector(Token len, int kindOrLen, boolean hasAsterisk) {
} // TODO: Implement
/**
* R426 Char Length
*/
public void char_length(boolean hasTypeParamValue) {
FortranNode temp = null;
FortranNode char_length_Node = new FortranNode(426, "CharLength");
assert !stack.isEmpty();
temp = stack.pop();
assert hasTypeParamValue ? temp.rule() == 402 : temp.rule() == -2;
char_length_Node.addChild(temp);
stack.push(char_length_Node);
} // Test
/**
* R-2 Scalar Int Literal Constant
*/
public void scalar_int_literal_constant() {
FortranNode temp = null;
FortranNode scalar_int_literal_constant_Node = new FortranNode(-2,
"ScalarIntConst");
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 406;
scalar_int_literal_constant_Node.addChild(temp);
stack.push(scalar_int_literal_constant_Node);
} // Test
/**
* R427 Char Literal Constant
*/
public void char_literal_constant(Token digitString, Token id, Token str) {
FortranNode char_literal_constant_Node = new FortranNode(427,
"CharLitConst");
FortranNode digitString_Node = new FortranNode("DigitStr", digitString);
FortranNode id_Node = new FortranNode("ID", id);
FortranNode str_Node = new FortranNode("String", str);
if (digitString != null) {
char_literal_constant_Node.addChild(digitString_Node);
} else if (id != null) {
char_literal_constant_Node.addChild(id_Node);
}
char_literal_constant_Node.addChild(str_Node);
stack.push(char_literal_constant_Node);
} // Test
/**
* R428 Logical Literal constant
*/
public void logical_literal_constant(Token logicalValue, boolean isTrue,
Token kindParam) {
FortranNode logical_literal_constant_Node = new FortranNode(428,
"LogicLitConst");
FortranNode logicalValue_Node = new FortranNode("LogicVal",
logicalValue);
FortranNode kindParam_Node = new FortranNode("Kind", kindParam);
if (isTrue) {
logical_literal_constant_Node.setNodeName("LogicLitConst: TRUE");
} else {
logical_literal_constant_Node.setNodeName("LogicLitConst: FALSE");
}
logical_literal_constant_Node.addChild(logicalValue_Node);
logical_literal_constant_Node.addChild(kindParam_Node);
stack.push(logical_literal_constant_Node);
} // Test
/**
* RX Hollerith Literal Constant
*/
public void hollerith_literal_constant(Token hollerithConstant) {
// Hollerith constants were deleted in F77
}
/**
* R429
*/
public void derived_type_def() {
} // TODO: Implement
/**
* RX
*/
public void type_param_or_comp_def_stmt(Token eos, int type) {
} // TODO: Implement
public void type_param_or_comp_def_stmt_list() {
} // TODO: Implement
/**
* R430
*/
public void derived_type_stmt(Token label, Token keyword, Token id,
Token eos, boolean hasTypeAttrSpecList, boolean hasGenericNameList) {
} // TODO: Implement
/**
* R431 [Element]
*/
public void type_attr_spec(Token keyword, Token id, int specType) {
} // TODO: Implement
/**
* R431 [Begin] Type Attribute Specification List
*/
public void type_attr_spec_list__begin() {
// Do nothing
}
/**
* R431 [List]
*/
public void type_attr_spec_list(int count) {
} // TODO: Implement
/**
* R432
*/
public void private_or_sequence() {
} // TODO: Implement
/**
* R433
*/
public void end_type_stmt(Token label, Token endKeyword, Token typeKeyword,
Token id, Token eos) {
} // TODO: Implement
/**
* R434
*/
public void sequence_stmt(Token label, Token sequenceKeyword, Token eos) {
} // TODO: Implement
/**
* R436 [Element]
*/
public void type_param_decl(Token id, boolean hasInit) {
} // TODO: Implement
/**
* R436 [Begin]
*/
public void type_param_decl_list__begin() {
// Do nothing
}
/**
* R436 [List]
*/
public void type_param_decl_list(int count) {
} // TODO: Implement
/**
* R437
*/
public void type_param_attr_spec(Token kindOrLen) {
} // TODO: Implement
/**
* R439
*/
public void component_def_stmt(int type) {
} // TODO: Implement
/**
* R440
*/
public void data_component_def_stmt(Token label, Token eos, boolean hasSpec) {
} // TODO: Implement
/**
* R437 [Element] (441_F03)
*/
public void component_attr_spec(Token attrKeyword, int specType) {
} // TODO: Implement
/**
* R437 [Begin]
*/
public void component_attr_spec_list__begin() {
// Do nothing
}
/**
* R437 [List]
*/
public void component_attr_spec_list(int count) {
} // TODO: Implement
/**
* R438 [Element] (442_F03)
*/
public void component_decl(Token id, boolean hasComponentArraySpec,
boolean hasCoarraySpec, boolean hasCharLength,
boolean hasComponentInitialization) {
} // TODO: Implement
/**
* R438 [Begin]
*/
public void component_decl_list__begin() {
// Do nothing
}
/**
* R438 [List]
*/
public void component_decl_list(int count) {
} // TODO: Implement
/**
* R443 [Element]
*/
public void component_array_spec(boolean isExplicit) {
} // TODO: Implement
/**
* R443 [Begin]
*/
public void deferred_shape_spec_list__begin() {
// Do nothing
}
/**
* RX
*/
public void deferred_shape_spec_list(int count) {
// Replaced by T_COLON
} // TODO: Implement
/**
* R444
*/
public void component_initialization() {
} // TODO: Implement
/**
* R445
*/
public void proc_component_def_stmt(Token label, Token procedureKeyword,
Token eos, boolean hasInterface) {
} // TODO: Implement
/**
* R446 [Element]
*/
public void proc_component_attr_spec(Token attrSpecKeyword, Token id,
int specType) {
} // TODO: Implement
/**
* R446 [Begin] Process Component Attribute Specification List
*/
public void proc_component_attr_spec_list__begin() {
// Do nothing
}
/**
* R446 [List]
*/
public void proc_component_attr_spec_list(int count) {
} // TODO: Implement
/**
* R447
*/
public void private_components_stmt(Token label, Token privateKeyword,
Token eos) {
} // TODO: Implement
/**
* R448
*/
public void type_bound_procedure_part(int count,
boolean hasBindingPrivateStmt) {
} // TODO: Implement
/**
* R449
*/
public void binding_private_stmt(Token label, Token privateKeyword,
Token eos) {
} // TODO: Implement
/**
* R450
*/
public void proc_binding_stmt(Token label, int type, Token eos) {
} // TODO: Implement
/**
* R451
*/
public void specific_binding(Token procedureKeyword, Token interfaceName,
Token bindingName, Token procedureName, boolean hasBindingAttrList) {
} // TODO: Implement
/**
* R452
*/
public void generic_binding(Token genericKeyword, boolean hasAccessSpec) {
} // TODO: Implement
/**
* R453 [Element]
*/
public void binding_attr(Token bindingAttr, int attr, Token id) {
} // TODO: Implement
/**
* R453 [Begin]
*/
public void binding_attr_list__begin() {
// Do nothing
}
/**
* R453 [List]
*/
public void binding_attr_list(int count) {
} // TODO: Implement
/**
* R454
*/
public void final_binding(Token finalKeyword) {
} // TODO: Implement
/**
* R455
*/
public void derived_type_spec(Token typeName, boolean hasTypeParamSpecList) {
} // TODO: Implement
/**
* R456 [Element]
*/
public void type_param_spec(Token keyword) {
} // TODO: Implement
/**
* R456 [Begin]
*/
public void type_param_spec_list__begin() {
// Do nothing
}
/**
* R456 [List]
*/
public void type_param_spec_list(int count) {
} // TODO: Implement
/**
* R457
*/
public void structure_constructor(Token id) {
} // TODO: Implement
/**
* R458 [Element]
*/
public void component_spec(Token id) {
} // TODO: Implement
/**
* R458 [Begin]
*/
public void component_spec_list__begin() {
// Do nothing
}
/**
* R458 [List]
*/
public void component_spec_list(int count) {
} // TODO: Implement
/**
* R459
*/
public void component_data_source() {
} // TODO: Implement
/**
* R460
*/
public void enum_def(int numEls) {
} // TODO: Implement
/**
* R461
*/
public void enum_def_stmt(Token label, Token enumKeyword,
Token bindKeyword, Token id, Token eos) {
} // TODO: Implement
/**
* R462
*/
public void enumerator_def_stmt(Token label, Token enumeratorKeyword,
Token eos) {
} // TODO: Implement
/**
* R463 [Element]
*/
public void enumerator(Token id, boolean hasExpr) {
} // TODO: Implement
/**
* R463 [Begin]
*/
public void enumerator_list__begin() {
// Do nothing
}
/**
* R463 [List]
*/
public void enumerator_list(int count) {
} // TODO: Implement
/**
* R464
*/
public void end_enum_stmt(Token label, Token endKeyword, Token enumKeyword,
Token eos) {
} // TODO: Implement
/**
* R465
*/
public void array_constructor() {
} // TODO: Implement
/**
* R466
*/
public void ac_spec() {
} // TODO: Implement
/**
* R469 [Element]
*/
public void ac_value() {
} // TODO: Implement
/**
* R469 [Begin]
*/
public void ac_value_list__begin() {
// Do nothing
}
/**
* R469 [List]
*/
public void ac_value_list(int count) {
} // TODO: Implement
/**
* R470
*/
public void ac_implied_do() {
} // TODO: Implement
/**
* R471
*/
public void ac_implied_do_control(boolean hasStride) {
} // TODO: Implement
/**
* R472
*/
public void scalar_int_variable() {
} // TODO: Implement
/**
* R501 Type Declaration Statement
*/
public void type_declaration_stmt(Token label, int numAttributes, Token eos) {
int counter = numAttributes;
FortranNode temp = null;
FortranNode type_declaration_stmt_Node = new FortranNode(501,
"TypeDeclStmt:(Attr:[" + counter + "])");
FortranNode label_Node = new FortranNode("LabelDef", label);
type_declaration_stmt_Node.addChild(label_Node);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 503;
type_declaration_stmt_Node.addChild(temp);
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 502; /* AttrSpec */
type_declaration_stmt_Node.addChild(1, temp);
counter--;
}
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 502; /* DeclTypeSpec */
type_declaration_stmt_Node.addChild(1, temp);
stack.push(type_declaration_stmt_Node);
} // Test
/**
* R502 Declaration Type Specification
*/
public void declaration_type_spec(Token udtKeyword, int type) {
FortranNode temp = null;
FortranNode declaration_type_spec_Node = null;
FortranNode udtKeyword_Node = new FortranNode("UDTKeyword", udtKeyword);
if (type == IActionEnums.DeclarationTypeSpec_INTRINSIC) {
declaration_type_spec_Node = new FortranNode(502,
"DeclTypeSpec(Intrinsic)");
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 403;
declaration_type_spec_Node.addChild(temp);
} else if (type == IActionEnums.DeclarationTypeSpec_TYPE) {
declaration_type_spec_Node = new FortranNode(502,
"DeclTypeSpec(DerivedType)");
declaration_type_spec_Node.addChild(udtKeyword_Node);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 455;
declaration_type_spec_Node.addChild(temp);
} else if (type == IActionEnums.DeclarationTypeSpec_CLASS) {
declaration_type_spec_Node = new FortranNode(502,
"DeclTypeSpec(DerivedClass)");
declaration_type_spec_Node.addChild(udtKeyword_Node);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 455;
declaration_type_spec_Node.addChild(temp);
} else if (type == IActionEnums.DeclarationTypeSpec_unlimited) {
declaration_type_spec_Node = new FortranNode(502,
"DeclTypeSpec(Unlimited)");
declaration_type_spec_Node.addChild(udtKeyword_Node);
} else {
assert false; // Syntax Error
}
new FortranNode(502, "DeclTypeSpec", udtKeyword);
stack.push(declaration_type_spec_Node);
} // Test
/**
* R502 (503_03)
*/
public void attr_spec(Token attrKeyword, int attr) {
} // TODO: Implement
/**
* R503 [Element] Entity Declaration
*/
public void entity_decl(Token id, boolean hasArraySpec,
boolean hasCoarraySpec, boolean hasCharLength,
boolean hasInitialization) {
FortranNode temp = null;
FortranNode entity_decl_Node = new FortranNode(503, "EntityDecl");
FortranNode id_Node = new FortranNode("ID", id);
entity_decl_Node.addChild(id_Node);
if (hasInitialization) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 506;
entity_decl_Node.addChild(temp);
}
if (hasCharLength) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 426;
entity_decl_Node.addChild(temp);
}
if (hasCoarraySpec) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 509;
entity_decl_Node.addChild(temp);
}
if (hasArraySpec) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 510;
entity_decl_Node.addChild(temp);
}
stack.push(entity_decl_Node);
} // Test
/**
* R503 [Begin] Entity Declaration List
*/
public void entity_decl_list__begin() {
// Do nothing.
}
/**
* R503 [List] Entity Declaration List
*/
public void entity_decl_list(int count) {
FortranNode temp = null;
int counter = count;
FortranNode entity_decl_list_Node = new FortranNode(503,
"EntityDeclList[" + counter + "]");
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 503;
entity_decl_list_Node.addChild(0, temp);
counter--;
}
stack.push(entity_decl_list_Node);
} // Test
/**
* R506 Initialization
*/
public void initialization(boolean hasExpr, boolean hasNullInit) {
FortranNode temp = null;
FortranNode init_Node = new FortranNode(506, "Init");
if (hasExpr) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 701;
init_Node.addChild(temp);
}
if (hasNullInit) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 507;
init_Node.addChild(temp);
}
stack.push(init_Node);
} // Test
/**
* R507 Null Initialization
*/
public void null_init(Token id) {
FortranNode null_init_Node = new FortranNode(507, "NullInit");
FortranNode id_Node = new FortranNode("ID", id);
null_init_Node.addChild(id_Node);
stack.push(null_init_Node);
} // TODO: Implement
/**
* R508
*/
public void access_spec(Token keyword, int type) {
} // TODO: Implement
/**
* R509
*/
public void language_binding_spec(Token keyword, Token id, boolean hasName) {
} // TODO: Implement
/**
* R509_F08
*/
public void coarray_spec(int count) {
} // TODO: Implement
/**
* R510 [List] Array Specification
*/
public void array_spec(int count) {
int counter = count;
FortranNode temp = null;
FortranNode array_spec_Node = new FortranNode(510, "ArraySpec["
+ counter + "]");
while (counter > 0) {
assert !stack.empty();
temp = stack.pop();
assert temp.rule() == 510;
array_spec_Node.addChild(0, temp);
counter--;
}
stack.push(array_spec_Node);
} // Test
/**
* R510 [Element] Array Specification Element
*/
public void array_spec_element(int type) {
int rule = -1;
FortranNode temp = null;
FortranNode array_spec_element_Node = null;
if (type == IActionEnums.ArraySpecElement_colon) {
array_spec_element_Node = new FortranNode(510,
"ArrayElement(:)");
} else if (type == IActionEnums.ArraySpecElement_asterisk) {
array_spec_element_Node = new FortranNode(510,
"ArrayElement(*)");
} else if (type == IActionEnums.ArraySpecElement_expr) {
array_spec_element_Node = new FortranNode(510,
"ArrayElement(Expr)");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimaryExpr */
|| rule == 702 /* Lv1Expr */
|| rule == 715 /* OrOperand */
|| rule == 717 /* Lv5Expr */
;
array_spec_element_Node.addChild(temp);
} else if (type == IActionEnums.ArraySpecElement_expr_colon) {
array_spec_element_Node = new FortranNode(510,
"ArrayElement(Expr:)");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* Primary */
|| rule == 717 /* Lv5Expr */;
array_spec_element_Node.addChild(temp);
} else if (type == IActionEnums.ArraySpecElement_expr_colon_asterisk) {
array_spec_element_Node = new FortranNode(510,
"ArrayElement(Expr:*)");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* Primary */
|| rule == 717 /* Lv5Expr */;
array_spec_element_Node.addChild(temp);
} else if (type == IActionEnums.ArraySpecElement_expr_colon_expr) {
array_spec_element_Node = new FortranNode(510,
"ArrayElement(Expr1:Expr2)");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* Primary */
|| rule == 717 /* Lv5Expr */;
array_spec_element_Node.addChild(temp);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* Primary */
|| rule == 717 /* Lv5Expr */;
array_spec_element_Node.addChild(0, temp);
} else {
assert false; // Syntax Error
}
stack.push(array_spec_element_Node);
} // Test
/**
* R511 [Element]
*/
public void explicit_shape_spec(boolean hasUpperBound) {
} // TODO: Implement
/**
* R511 [Begin]
*/
public void explicit_shape_spec_list__begin() {
// Do nothing
}
/**
* R511 [List]
*/
public void explicit_shape_spec_list(int count) {
} // TODO: Implement
/**
* R517
*/
public void intent_spec(Token intentKeyword1, Token intentKeyword2,
int intent) {
} // TODO: Implement
/**
* R518
*/
public void access_stmt(Token label, Token eos, boolean hasList) {
} // TODO: Implement
/**
* R519 [Element]
*/
public void access_id() {
} // TODO: Implement
/**
* R519 [Begin]
*/
public void access_id_list__begin() {
// Do nothing
}
/**
* R519 [List]
*/
public void access_id_list(int count) {
} // TODO: Implement
/**
* R520 (526_F03)
*/
public void allocatable_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
/**
* R527 [Element]
*/
public void allocatable_decl(Token id, boolean hasArraySpec,
boolean hasCoarraySpec) {
} // TODO: Implement
/**
* R527 [Begin] Allocatable Declaration List
*/
public void allocatable_decl_list__begin() {
// Do nothing
}
/**
* R527 [List]
*/
public void allocatable_decl_list(int count) {
} // TODO: Implement
/**
* R521
*/
public void asynchronous_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
/**
* R522
*/
public void bind_stmt(Token label, Token eos) {
} // TODO: Implement
/**
* R523 [Element]
*/
public void bind_entity(Token entity, boolean isCommonBlockName) {
} // TODO: Implement
/**
* R523 [Begin] Bind Entity List
*/
public void bind_entity_list__begin() {
// Do nothing
}
/**
* R523 [List]
*/
public void bind_entity_list(int count) {
} // TODO: Implement
/**
* R531
*/
public void codimension_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
/**
* R532 [Element]
*/
public void codimension_decl(Token coarrayName, Token lbracket,
Token rbracket) {
} // TODO: Implement
/**
* R532 [Begin] Codimension Declaration List
*/
public void codimension_decl_list__begin() {
// Do nothing
}
/**
* R532 [List]
*/
public void codimension_decl_list(int count) {
} // TODO: Implement
/**
* R524
*/
public void data_stmt(Token label, Token keyword, Token eos, int count) {
int counter = count;
FortranNode temp = null;
FortranNode data_stmt_Node = new FortranNode(524, "DataStmt[" + counter
+ "]");
FortranNode label_Node = new FortranNode("LabelDef", label);
// FortranNode keyword_Node = new FortranNode("Keyword", keyword);
data_stmt_Node.addChild(label_Node);
assert counter >= 1;
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 525;
data_stmt_Node.addChild(temp);
counter--;
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 525;
data_stmt_Node.addChild(1, temp);
stack.push(data_stmt_Node);
counter--;
}
stack.push(data_stmt_Node);
} // TODO: Implement
/**
* R525
*/
public void data_stmt_set() {
FortranNode temp = null;
FortranNode data_stmt_set_Node = new FortranNode(525, "DataSet");
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 530;
data_stmt_set_Node.addChild(temp);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 526;
data_stmt_set_Node.addChild(0, temp);
stack.push(data_stmt_set_Node);
} // TODO: Implement
/**
* R526 [Element]
*/
public void data_stmt_object() {
int rule = -1;
FortranNode temp = null;
FortranNode data_stmt_object_Node = new FortranNode(526, "DataObj");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 601 /* Variable */
;
data_stmt_object_Node.addChild(temp);
stack.push(data_stmt_object_Node);
} // TODO: Implement
/**
* R526 [Begin]
*/
public void data_stmt_object_list__begin() {
// Do nothing
}
/**
* R526 [List]
*/
public void data_stmt_object_list(int count) {
int counter = count;
FortranNode temp = null;
FortranNode data_stmt_object_list_Node = new FortranNode(526,
"DataObjList[" + counter + "]");
assert counter >= 1;
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 526; /* DataObj */
data_stmt_object_list_Node.addChild(temp);
counter--;
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 526; /* DataObj */
data_stmt_object_list_Node.addChild(0, temp);
counter--;
}
stack.push(data_stmt_object_list_Node);
} // TODO: Implement
/**
* R527
*/
public void data_implied_do(Token id, boolean hasThirdExpr) {
} // TODO: Implement
/**
* R528 [Element]
*/
public void data_i_do_object() {
} // TODO: Implement
/**
* R528 [Begin] Data i Do Object List
*/
public void data_i_do_object_list__begin() {
// Do nothing
}
/**
* R528 [List]
*/
public void data_i_do_object_list(int count) {
} // TODO: Implement
/**
* R530 [Element]
*/
public void data_stmt_value(Token asterisk) {
int rule = -1;
FortranNode temp = null;
FortranNode data_stmt_value_Node = new FortranNode(530, "DataVal");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 416 /* SignRealLitConst */
;
data_stmt_value_Node.addChild(temp);
stack.push(data_stmt_value_Node);
} // TODO: Implement
/**
* R530 [Begin] Data Statement Value List
*/
public void data_stmt_value_list__begin() {
// Do nothing
}
/**
* R530 [List]
*/
public void data_stmt_value_list(int count) {
int counter = count;
FortranNode temp = null;
FortranNode data_stmt_value_list_Node = new FortranNode(530,
"DataValList[" + counter + "]");
assert counter >= 1;
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 530; /* DataVal */
data_stmt_value_list_Node.addChild(temp);
counter--;
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 530; /* DataVal */
data_stmt_value_list_Node.addChild(0, temp);
counter--;
}
stack.push(data_stmt_value_list_Node);
} // TODO: Implement
/**
* R531
*/
public void scalar_int_constant() {
} // TODO: Implement
/**
* R532
*/
public void data_stmt_constant() {
} // TODO: Implement
/**
* R535
*/
public void dimension_stmt(Token label, Token keyword, Token eos, int count) {
} // TODO: Implement
/**
* R535 [SubRule]
*/
public void dimension_decl(Token id) {
} // TODO: Implement
/**
* R536
*/
public void intent_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
/**
* R537
*/
public void optional_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
/**
* R538 Parameter Statement
*/
public void parameter_stmt(Token label, Token keyword, Token eos) {
FortranNode temp = null;
FortranNode parameter_stmt_Node = new FortranNode(538, "ParamStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode keyword_Node = new FortranNode("Keyword", keyword);
parameter_stmt_Node.addChild(label_Node);
parameter_stmt_Node.addChild(keyword_Node);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 539;
parameter_stmt_Node.addChild(temp);
stack.push(parameter_stmt_Node);
} // Test
/**
* R539 [Begin] Named Constant Definition List
*/
public void named_constant_def_list__begin() {
// Do nothing
}
/**
* R539 [List] Named Constant Definition List
*/
public void named_constant_def_list(int count) {
int counter = count;
FortranNode temp = null;
FortranNode named_constant_def_list_Node = new FortranNode(539,
"NamedConstDef[" + counter + "]");
while (counter > 0) {
assert !stack.empty();
temp = stack.pop();
assert temp.rule() == 539;
named_constant_def_list_Node.addChild(0, temp);
counter--;
}
stack.push(named_constant_def_list_Node);
} // Test
/**
* R539 [Element] Named Constant Definition
*/
public void named_constant_def(Token id) {
int rule = -1;
FortranNode temp = null;
FortranNode named_constant_def_Node = new FortranNode(539,
"NamedConstDef");
FortranNode id_Node = new FortranNode("ID", id);
named_constant_def_Node.addChild(id_Node);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* Primary */
|| rule == 715;
named_constant_def_Node.addChild(temp);
stack.push(named_constant_def_Node);
} // Test (Expr)
/**
* R550
*/
public void pointer_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
public void pointer_decl_list__begin() {
// Do nothing
}
public void pointer_decl_list(int count) {
} // TODO: Implement
public void pointer_decl(Token id, boolean hasSpecList) {
} // TODO: Implement
public void cray_pointer_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
public void cray_pointer_assoc_list__begin() {
// Do nothing
} // TODO: Implement
public void cray_pointer_assoc_list(int count) {
} // TODO: Implement
public void cray_pointer_assoc(Token pointer, Token pointee) {
} // TODO: Implement
public void protected_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
public void save_stmt(Token label, Token keyword, Token eos,
boolean hasSavedEntityList) {
} // TODO: Implement
public void saved_entity_list__begin() {
// Do nothing
}
public void saved_entity_list(int count) {
} // TODO: Implement
public void saved_entity(Token id, boolean isCommonBlockName) {
} // TODO: Implement
public void target_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
public void target_decl(Token objName, boolean hasArraySpec,
boolean hasCoarraySpec) {
} // TODO: Implement
public void target_decl_list__begin() {
// Do nothing
}
public void target_decl_list(int count) {
} // TODO: Implement
public void value_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
public void volatile_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
public void implicit_stmt(Token label, Token implicitKeyword,
Token noneKeyword, Token eos, boolean hasImplicitSpecList) {
} // TODO: Implement
public void implicit_spec() {
} // TODO: Implement
public void implicit_spec_list__begin() {
// Do nothing
}
public void implicit_spec_list(int count) {
} // TODO: Implement
public void letter_spec(Token id1, Token id2) {
} // TODO: Implement
public void letter_spec_list__begin() {
// Do nothing
}
public void letter_spec_list(int count) {
} // TODO: Implement
public void namelist_stmt(Token label, Token keyword, Token eos, int count) {
} // TODO: Implement
public void namelist_group_name(Token id) {
} // TODO: Implement
public void namelist_group_object(Token id) {
} // TODO: Implement
public void namelist_group_object_list__begin() {
// Do nothing
}
public void namelist_group_object_list(int count) {
} // TODO: Implement
public void equivalence_stmt(Token label, Token equivalenceKeyword,
Token eos) {
} // TODO: Implement
public void equivalence_set() {
} // TODO: Implement
public void equivalence_set_list__begin() {
// Do nothing
}
public void equivalence_set_list(int count) {
} // TODO: Implement
public void equivalence_object() {
} // TODO: Implement
public void equivalence_object_list__begin() {
// Do nothing
}
public void equivalence_object_list(int count) {
} // TODO: Implement
public void common_stmt(Token label, Token commonKeyword, Token eos,
int numBlocks) {
} // TODO: Implement
public void common_block_name(Token id) {
} // TODO: Implement
public void common_block_object_list__begin() {
// Do nothing
}
public void common_block_object_list(int count) {
} // TODO: Implement
public void common_block_object(Token id, boolean hasShapeSpecList) {
} // TODO: Implement
/**
* R601
*/
public void variable() {
FortranNode temp = null;
FortranNode variable_Node = new FortranNode(601, "Variable");
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 603;// May not only 603
variable_Node.addChild(temp);
stack.push(variable_Node);
} // Test
/**
* R603
*/
public void designator(boolean hasSubstringRange) {
FortranNode temp = null;
FortranNode designator_Node = new FortranNode(603, "Designator");
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 612;// May not only 612
designator_Node.addChild(temp);
if (hasSubstringRange) {
assert false;
}
stack.push(designator_Node);
} // TODO: Implement
/**
* R-3
*/
public void designator_or_func_ref() {
FortranNode temp = null;
FortranNode designator_or_func_ref_Node = new FortranNode(-3,
"DesignatorOrFunctionRef");
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 612;// May not only 612
designator_or_func_ref_Node.addChild(temp);
stack.push(designator_or_func_ref_Node);
} // Test
public void substring_range_or_arg_list() {
} // TODO: Implement
public void substr_range_or_arg_list_suffix() {
} // TODO: Implement
public void logical_variable() {
} // TODO: Implement
public void default_logical_variable() {
} // TODO: Implement
public void scalar_default_logical_variable() {
} // TODO: Implement
public void char_variable() {
} // TODO: Implement
public void default_char_variable() {
} // TODO: Implement
public void scalar_default_char_variable() {
} // TODO: Implement
public void int_variable() {
} // TODO: Implement
public void substring(boolean hasSubstringRange) {
} // TODO: Implement
public void substring_range(boolean hasLowerBound, boolean hasUpperBound) {
} // TODO: Implement
/**
* R612 [List] Data Reference
*/
public void data_ref(int numPartRef) {
FortranNode temp = null;
int counter = numPartRef;
FortranNode data_ref_Node = new FortranNode(612, "DataRef[" + counter
+ "]");
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 613;
data_ref_Node.addChild(0, temp);
counter--;
}
stack.push(data_ref_Node);
} // Test
/**
* R613 Ex [Element]
*/
public void part_ref(Token id, boolean hasSelectionSubscriptList,
boolean hasImageSelector) {
FortranNode temp = null;
FortranNode part_ref = new FortranNode(613, "PartRef");
FortranNode id_Node = new FortranNode("ID", id);
part_ref.addChild(id_Node);
if (hasSelectionSubscriptList) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 619;
part_ref.addChild(temp);
}
if (hasImageSelector) {
assert false;
}
stack.push(part_ref);
} // TODO: Implement
/**
* R619 [Element] Section Subscript
*/
public void section_subscript(boolean hasLowerBound, boolean hasUpperBound,
boolean hasStride, boolean isAmbiguous) {
int rule = -1;
FortranNode temp = null;
FortranNode section_subscript_Node = new FortranNode(619,
"SecSubscript");
if (hasLowerBound) {
}
if (hasUpperBound) {
}
if (hasStride) {
}
if (isAmbiguous) {
}
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* Primary */
|| rule == 702 /* Lv1Expr */
|| rule == 704 /**/
|| rule == 705 /**/
|| rule == 715 /* OrOperand */;
section_subscript_Node.addChild(temp);
stack.push(section_subscript_Node);
} // TODO: Implement
/**
* R619 [Begin] Section Subscript List
*/
public void section_subscript_list__begin() {
// Do nothing
}
/**
* R619 [List] Section Subscript List
*/
public void section_subscript_list(int count) {
int counter = count;
FortranNode temp = null;
FortranNode section_subscript_list_Node = new FortranNode(619,
"SectionSubscriptList[" + counter + "]");
while (counter > 0) {
assert !stack.empty();
temp = stack.pop();
assert temp.rule() == 619;
section_subscript_list_Node.addChild(0, temp);
counter--;
}
stack.push(section_subscript_list_Node);
} // Test
public void vector_subscript() {
} // TODO: Implement
public void allocate_stmt(Token label, Token allocateKeyword, Token eos,
boolean hasTypeSpec, boolean hasAllocOptList) {
} // TODO: Implement
public void image_selector(Token leftBracket, Token rightBracket) {
} // TODO: Implement
public void alloc_opt(Token allocOpt) {
} // TODO: Implement
public void alloc_opt_list__begin() {
// Do nothing
}
public void alloc_opt_list(int count) {
} // TODO: Implement
public void cosubscript_list__begin() {
// Do nothing
}
public void cosubscript_list(int count, Token team) {
} // TODO: Implement
public void allocation(boolean hasAllocateShapeSpecList,
boolean hasAllocateCoarraySpec) {
} // TODO: Implement
public void allocation_list__begin() {
// Do nothing
}
public void allocation_list(int count) {
} // TODO: Implement
public void allocate_object() {
} // TODO: Implement
public void allocate_object_list__begin() {
// Do nothing
}
public void allocate_object_list(int count) {
} // TODO: Implement
public void allocate_shape_spec(boolean hasLowerBound, boolean hasUpperBound) {
} // TODO: Implement
public void allocate_shape_spec_list__begin() {
// Do nothing
}
public void allocate_shape_spec_list(int count) {
} // TODO: Implement
public void nullify_stmt(Token label, Token nullifyKeyword, Token eos) {
} // TODO: Implement
public void pointer_object() {
} // TODO: Implement
public void pointer_object_list__begin() {
// Do nothing
}
public void pointer_object_list(int count) {
} // TODO: Implement
public void deallocate_stmt(Token label, Token deallocateKeyword,
Token eos, boolean hasDeallocOptList) {
} // TODO: Implement
public void dealloc_opt(Token id) {
} // TODO: Implement
public void dealloc_opt_list__begin() {
// Do nothing
}
public void dealloc_opt_list(int count) {
} // TODO: Implement
public void allocate_coarray_spec() {
} // TODO: Implement
public void allocate_coshape_spec(boolean hasExpr) {
} // TODO: Implement
public void allocate_coshape_spec_list__begin() {
// Do nothing
}
public void allocate_coshape_spec_list(int count) {
} // TODO: Implement
/**
* R701
*/
public void primary() {
int rule = -1;
FortranNode temp = null;
FortranNode primary_Node = new FortranNode(701, "PrimaryExpr");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == -3 /* DesignatorOrFunctionRef */
|| rule == 306 /* LiteralConst */
|| rule == 705 /* AddOperand */
;
// May not only -3
primary_Node.addChild(temp);
stack.push(primary_Node);
} // Test
public void parenthesized_expr() {
} // TODO: Implement
/**
* R702
*/
public void level_1_expr(Token definedUnaryOp) {
if (definedUnaryOp != null) {
FortranNode temp = null;
FortranNode level_1_expr_Node = new FortranNode(702, "Lv1Expr");
FortranNode definedUnaryOp_Node = new FortranNode(703,
"DefUnaryOp", definedUnaryOp);
level_1_expr_Node.addChild(definedUnaryOp_Node);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 701; /* PrimExpr */
level_1_expr_Node.addChild(temp);
stack.push(level_1_expr_Node);
}
} // TODO: Implement
/**
* R703
*/
public void defined_unary_op(Token definedOp) {
// Omitted, with R 702
} // TODO: Implement
/**
* R704
*/
public void power_operand(boolean hasPowerOperand) {
if (hasPowerOperand) {
FortranNode temp = null;
FortranNode power_operand_Node = new FortranNode(704,
"PowerOperand");
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 701;
power_operand_Node.addChild(temp);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 701;
power_operand_Node.addChild(0, temp);
stack.push(power_operand_Node);
}
} // TODO: Implement
/**
* R704
*/
public void power_operand__power_op(Token powerOp) {
assert false;
} // TODO: Implement
/**
* R704 [List] Multiply Operand List
*/
public void mult_operand(int numMultOps) {
if (numMultOps > 0) {
int counter = numMultOps;
FortranNode temp = null;
FortranNode mult_operand_Node = new FortranNode(704,
"MultOperands[" + counter + "]");
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 704;
mult_operand_Node.addChild(0, temp);
counter--;
}
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 701 || temp.rule() == 702
|| temp.rule() == 705;
mult_operand_Node.addChild(0, temp);
stack.push(mult_operand_Node);
}
} // Test
/**
* R704 [Element] Multiply Operand
*/
public void mult_operand__mult_op(Token multOp) {
int rule = -1;
FortranNode temp = null;
FortranNode mult_operand__mult_op_Node = new FortranNode(704,
"MultOperand");
FortranNode multOp_Node = new FortranNode(708, "MultOp", multOp);
mult_operand__mult_op_Node.addChild(multOp_Node);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimaryExpr */
|| rule == 702 /* Lv1Expr */
|| rule == 704;
mult_operand__mult_op_Node.addChild(temp);
stack.push(mult_operand__mult_op_Node);
} // Test
/**
* R705 [Element]2
*/
public void signed_operand(Token addOp) {
if (addOp != null) {
int rule = -1;
FortranNode temp = null;
FortranNode signed_operand_Node = new FortranNode(705,
"SignedOperand");
FortranNode sign_Node = new FortranNode(709, "Sign", addOp);
signed_operand_Node.addChild(sign_Node);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimaryExpr */
|| rule == 702 /**/
|| rule == 704;
signed_operand_Node.addChild(temp);
stack.push(signed_operand_Node);
}
} // Test
/**
* R705 [List] Add Operand List
*/
public void add_operand(int numAddOps) {
if (numAddOps > 0) {
int rule = -1;
int counter = numAddOps;
FortranNode temp = null;
FortranNode add_operand_Node = new FortranNode(705, "AddOperands["
+ counter + "]");
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
if (rule == 601) {
stack.push(temp);
break;
}
assert rule == 701 /* Primary */
|| rule == 702 /* Lv1Expr */
|| rule == 704 /* MultOperand */
|| rule == 705 /* AddOperandAddOp */;
add_operand_Node.addChild(0, temp);
counter--;
}
stack.push(add_operand_Node);
}
} // Test
/**
* R705 [Element]1
*/
public void add_operand__add_op(Token addOp) {
if (addOp != null) {
int rule = -1;
FortranNode temp = null;
FortranNode add_operand__add_op_Node = new FortranNode(705,
"AddOperand");
FortranNode addOp_Node = new FortranNode(709, "AddOp", addOp);
add_operand__add_op_Node.addChild(addOp_Node);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimaryExpr */
|| rule == 702 /* Lv1Expr */
|| rule == 704 /* MultOperand */
;// TODO:
add_operand__add_op_Node.addChild(temp);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
if (rule == 601) {
stack.push(temp);
stack.push(add_operand__add_op_Node);
return;
}
assert rule == 701 /* PrimaryExpr */
|| rule == 702 /**/
|| rule == 704 /**/
|| rule == 705 /**/
;
add_operand__add_op_Node.addChild(1, temp);
stack.push(add_operand__add_op_Node);
}
} // Test
public void level_2_expr(int numConcatOps) {
} // TODO: Implement
/**
* R707 Power Operator
*/
public void power_op(Token powerKeyword) {
}
/**
* R708 Multiply Operator
*/
public void mult_op(Token multKeyword) {
// Omitted, with R 704
}
/**
* R709 Add Operator
*/
public void add_op(Token addKeyword) {
// Omitted, with R 705
}
/**
* R710
*/
public void level_3_expr(Token relOp) {
if (relOp != null) {
int rule = -1;
FortranNode temp = null;
FortranNode level_3_expr_Node = new FortranNode(710, "Lv3Expr");
FortranNode relOp_Node = new FortranNode(713, "RelOp", relOp);
level_3_expr_Node.addChild(relOp_Node);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701;
level_3_expr_Node.addChild(temp);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* Primary */
|| rule == 705 /* AddOperand */
;
level_3_expr_Node.addChild(0, temp);
stack.push(level_3_expr_Node);
}
} // Test
/**
* R712 Concatenate Operator
*/
public void concat_op(Token concatKeyword) {
}
/**
* R713 Relationship Operator
*/
public void rel_op(Token relOp) {
// Omitted, with R 710
}
/**
* R714 [List] And Operand List
*/
public void and_operand(boolean hasNotOp, int numAndOps) {
if (hasNotOp || numAndOps > 0) {
int rule = -1;
int counter = numAndOps;
FortranNode temp = null;
FortranNode and_operand_Node = new FortranNode(714, "AndOperands["
+ (counter + 1) + "]");
FortranNode and_operand__not_op_Node = new FortranNode(714,
"AndOperandNotOp");
and_operand_Node.addChild(and_operand__not_op_Node);
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 714;
if (and_operand_Node.numChildren() == 0) {
}
and_operand_Node.addChild(0, temp);
counter--;
}
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimaryExpr */
|| rule == 714 /* Lv3Expr */
|| rule == 710;
and_operand__not_op_Node.addChild(temp);
if (hasNotOp) {
FortranNode notOp_Node = new FortranNode(719, "NotOp");
and_operand__not_op_Node.addChild(0, notOp_Node);
}
stack.push(and_operand_Node);
}
} // Test
/**
* R714 [Element]
*/
public void and_operand__not_op(boolean hasNotOp) {
int rule = -1;
FortranNode temp = null;
FortranNode and_operand__not_op_Node = new FortranNode(714,
"AndOperandNotOp");
if (hasNotOp) {
FortranNode notOp_Node = new FortranNode(719, "NotOp");
and_operand__not_op_Node.addChild(notOp_Node);
}
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimaryExpr */
|| rule == 714 /* Lv3Expr */
|| rule == 710;
and_operand__not_op_Node.addChild(temp);
stack.push(and_operand__not_op_Node);
} // Test
/**
* R715
*/
public void or_operand(int numOrOps) {
if (numOrOps > 0) {
int rule = -1;
int counter = numOrOps;
FortranNode temp = null;
FortranNode or_operand_Node = new FortranNode(715, "OrOperands["
+ (counter + 1) + "]");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimaryExpr */
|| rule == 714 /* Lv3Expr */
|| rule == 710;
or_operand_Node.addChild(temp);
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimaryExpr */
|| rule == 714 /* Lv3Expr */
|| rule == 710;
or_operand_Node.addChild(0, temp);
counter--;
}
stack.push(or_operand_Node);
}
} // TODO: Implement
public void equiv_operand(int numEquivOps) {
} // TODO: Implement
public void equiv_operand__equiv_op(Token equivOp) {
} // TODO: Implement
public void level_5_expr(int numDefinedBinaryOps) {
} // TODO: Implement
public void level_5_expr__defined_binary_op(Token definedBinaryOp) {
} // TODO: Implement
/**
* R718 Not Operator
*/
public void not_op(Token notOp) {
// Omitted, with R 719
}
/**
* R719 And Operator
*/
public void and_op(Token andOp) {
// Omitted, with R 714
}
/**
* R720 Or Operator
*/
public void or_op(Token orOp) {
}
/**
* R721 Equivalence Operator
*/
public void equiv_op(Token equivOp) {
}
/**
* R722 Expression
*/
public void expr() {
// Omitted, with R 717
}
public void defined_binary_op(Token binaryOp) {
} // TODO: Implement
/**
* R734
*/
public void assignment_stmt(Token label, Token eos) {
int rule = -1;
FortranNode temp = null;
FortranNode assignment_stmt_Node = new FortranNode(734, "AssigmentStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
assignment_stmt_Node.addChild(label_Node);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimaryExpr */
|| rule == 702 /* Lv1Expr */
|| rule == 704 /* MultiOperand */
|| rule == 705 /* AddOperand */
|| rule == 715 /* OrOperand */
;
assignment_stmt_Node.addChild(temp);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 601; // May not only 601
assignment_stmt_Node.addChild(1, temp);
stack.push(assignment_stmt_Node);
} // Test
public void pointer_assignment_stmt(Token label, Token eos,
boolean hasBoundsSpecList, boolean hasBRList) {
} // TODO: Implement
public void data_pointer_object() {
} // TODO: Implement
public void bounds_spec() {
} // TODO: Implement
public void bounds_spec_list__begin() {
// Do nothing
}
public void bounds_spec_list(int count) {
} // TODO: Implement
public void bounds_remapping() {
} // TODO: Implement
public void bounds_remapping_list__begin() {
// Do nothing
}
public void bounds_remapping_list(int count) {
} // TODO: Implement
public void proc_pointer_object() {
} // TODO: Implement
public void where_stmt__begin() {
// Do nothing
}
public void where_stmt(Token label, Token whereKeyword) {
} // TODO: Implement
public void where_construct(int numConstructs, boolean hasMaskedElsewhere,
boolean hasElsewhere) {
} // TODO: Implement
public void where_construct_stmt(Token id, Token whereKeyword, Token eos) {
} // TODO: Implement
public void where_body_construct() {
} // TODO: Implement
public void masked_elsewhere_stmt(Token label, Token elseKeyword,
Token whereKeyword, Token id, Token eos) {
} // TODO: Implement
public void masked_elsewhere_stmt__end(int numBodyConstructs) {
} // TODO: Implement
public void elsewhere_stmt(Token label, Token elseKeyword,
Token whereKeyword, Token id, Token eos) {
} // TODO: Implement
public void elsewhere_stmt__end(int numBodyConstructs) {
} // TODO: Implement
public void end_where_stmt(Token label, Token endKeyword,
Token whereKeyword, Token id, Token eos) {
} // TODO: Implement
public void forall_construct() {
} // TODO: Implement
public void forall_construct_stmt(Token label, Token id,
Token forallKeyword, Token eos) {
} // TODO: Implement
public void forall_header() {
} // TODO: Implement
public void forall_triplet_spec(Token id, boolean hasStride) {
} // TODO: Implement
public void forall_triplet_spec_list__begin() {
// Do nothing
}
public void forall_triplet_spec_list(int count) {
} // TODO: Implement
public void forall_body_construct() {
} // TODO: Implement
public void forall_assignment_stmt(boolean isPointerAssignment) {
} // TODO: Implement
public void end_forall_stmt(Token label, Token endKeyword,
Token forallKeyword, Token id, Token eos) {
} // TODO: Implement
public void forall_stmt__begin() {
// Do nothing
}
public void forall_stmt(Token label, Token forallKeyword) {
} // Test
/**
* R801
*/
public void block() {
FortranNode temp = null;
FortranNode block_Node = new FortranNode(801, "Block");
while (!stack.isEmpty() && stack.peek().rule() == 213) {
temp = stack.pop();
if (block_Node.numChildren() < 1)
block_Node.addChild(temp);
else
block_Node.addChild(0, temp);
}
stack.push(block_Node);
} // Test
public void if_construct() {
} // TODO: Implement
/**
* R803
*/
public void if_then_stmt(Token label, Token id, Token ifKeyword,
Token thenKeyword, Token eos) {
int rule = -1;
FortranNode temp = null;
FortranNode if_then_stmt_Node = new FortranNode(803, "IfThenStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode id_Node = new FortranNode("ID", id);
if_then_stmt_Node.addChild(label_Node);
if_then_stmt_Node.addChild(id_Node);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 710 /* Lv3Expr */
|| rule == 714 /* AndOperand */
|| rule == 715 /* OrOperand */
; // TODO: boolean variable
if_then_stmt_Node.addChild(temp);
stack.push(if_then_stmt_Node);
} // Test
/**
* R804
*/
public void else_if_stmt(Token label, Token elseKeyword, Token ifKeyword,
Token thenKeyword, Token id, Token eos) {
int rule = -1;
FortranNode temp = null;
FortranNode else_if_stmt_Node = new FortranNode(804, "ElseIfStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode id_Node = new FortranNode("ID", id);
else_if_stmt_Node.addChild(label_Node);
else_if_stmt_Node.addChild(id_Node);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 710 /* Lv3Expr */
|| rule == 714 /* AndOperand */
|| rule == 715 /* OrOperand */
; // boolean variable
else_if_stmt_Node.addChild(temp);
stack.push(else_if_stmt_Node);
} // Test
/**
* R805 Else Statement
*/
public void else_stmt(Token label, Token elseKeyword, Token id, Token eos) {
FortranNode else_stmt_Node = new FortranNode(805, "ElseStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode id_Node = new FortranNode("ID", id);
else_stmt_Node.addChild(label_Node);
else_stmt_Node.addChild(id_Node);
stack.push(else_stmt_Node);
} // Test
public void end_if_stmt(Token label, Token endKeyword, Token ifKeyword,
Token id, Token eos) {
} // TODO: Implement
/**
* R807 Begin
*/
public void if_stmt__begin() {
// Do nothing
}
/**
* R807
*/
public void if_stmt(Token label, Token ifKeyword) {
int rule = -1;
FortranNode temp = null;
FortranNode if_stmt_Node = new FortranNode(807, "IfStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode ifKeyword_Node = new FortranNode("Keyword", ifKeyword);
if_stmt_Node.addChild(label_Node);
if_stmt_Node.addChild(ifKeyword_Node);
assert !stack.isEmpty();
rule = stack.peek().rule();
if (rule == 214) {
temp = stack.pop();
if_stmt_Node.addChild(temp);
assert !stack.isEmpty();
}
temp = stack.pop();
rule = temp.rule();
assert rule == 710 /* Lv3Expr */
|| rule == 714 /* AndOperand */
|| rule == 715 /* OrOperand */
; // boolean variable
if_stmt_Node.addChild(2, temp);
stack.push(if_stmt_Node);
} // Test
public void block_construct() {
} // TODO: Implement
public void specification_part_and_block(int numUseStmts,
int numImportStmts, int numDeclConstructs) {
} // TODO: Implement
public void block_stmt(Token label, Token id, Token keyword, Token eos) {
} // TODO: Implement
public void end_block_stmt(Token label, Token id, Token endKeyword,
Token blockKeyword, Token eos) {
} // TODO: Implement
public void critical_construct() {
} // TODO: Implement
public void critical_stmt(Token label, Token id, Token keyword, Token eos) {
} // TODO: Implement
public void end_critical_stmt(Token label, Token id, Token endKeyword,
Token criticalKeyword, Token eos) {
} // TODO: Implement
public void case_construct() {
} // TODO: Implement
public void select_case_stmt(Token label, Token id, Token selectKeyword,
Token caseKeyword, Token eos) {
} // TODO: Implement
public void case_stmt(Token label, Token caseKeyword, Token id, Token eos) {
} // TODO: Implement
public void end_select_stmt(Token label, Token endKeyword,
Token selectKeyword, Token id, Token eos) {
} // TODO: Implement
public void case_selector(Token defaultToken) {
} // TODO: Implement
public void case_value_range() {
} // TODO: Implement
public void case_value_range_list__begin() {
// Do nothing
}
public void case_value_range_list(int count) {
} // TODO: Implement
public void case_value_range_suffix() {
} // TODO: Implement
public void case_value() {
} // TODO: Implement
public void associate_construct() {
} // TODO: Implement
public void associate_stmt(Token label, Token id, Token associateKeyword,
Token eos) {
} // TODO: Implement
public void association_list__begin() {
// Do nothing
}
public void association_list(int count) {
} // TODO: Implement
public void association(Token id) {
} // TODO: Implement
public void selector() {
} // TODO: Implement
public void end_associate_stmt(Token label, Token endKeyword,
Token associateKeyword, Token id, Token eos) {
} // TODO: Implement
public void select_type_construct() {
} // TODO: Implement
public void select_type_stmt(Token label, Token selectConstructName,
Token associateName, Token eos) {
} // TODO: Implement
public void select_type(Token selectKeyword, Token typeKeyword) {
} // TODO: Implement
public void type_guard_stmt(Token label, Token typeKeyword,
Token isOrDefaultKeyword, Token selectConstructName, Token eos) {
} // TODO: Implement
public void end_select_type_stmt(Token label, Token endKeyword,
Token selectKeyword, Token id, Token eos) {
} // TODO: Implement
/**
* R825 Do Construct
*/
public void do_construct() {
int rule = -1;
FortranNode temp = null;
FortranNode do_construct_Node = new FortranNode(825, "DoConstruct");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 833;
do_construct_Node.addChild(temp);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 801;
do_construct_Node.addChild(0, temp);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 827;
do_construct_Node.addChild(0, temp);
stack.push(do_construct_Node);
} // Test
/**
* R826 Block Do Construct
*/
public void block_do_construct() {
// Omitted, with R 825
}
/**
* R827 Do Statement
*/
public void do_stmt(Token label, Token id, Token doKeyword,
Token digitString, Token eos, boolean hasLoopControl) {
FortranNode temp = null;
FortranNode do_stmt_Node = new FortranNode(827, "DoStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode id_Node = new FortranNode("ID", id);
FortranNode doKeyword_Node = new FortranNode("Keyword", doKeyword);
FortranNode digitString_Node = new FortranNode("DigitString",
digitString);
do_stmt_Node.addChild(label_Node);
do_stmt_Node.addChild(id_Node);
do_stmt_Node.addChild(doKeyword_Node);
do_stmt_Node.addChild(digitString_Node);
if (hasLoopControl) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 818;
do_stmt_Node.addChild(temp);
}
stack.push(do_stmt_Node);
} // Test
public void label_do_stmt(Token label, Token id, Token doKeyword,
Token digitString, Token eos, boolean hasLoopControl) {
} // TODO: Implement
/**
* R818
*/
public void loop_control(Token keyword, int doConstructType,
boolean hasOptExpr) {
int rule = -1;
FortranNode temp = null;
FortranNode loop_control_Node = new FortranNode(818, "LoopCtrl("
+ doConstructType + ")");
FortranNode keyword_Node = new FortranNode("Keyword", keyword);
loop_control_Node.addChild(keyword_Node);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimExpr */
|| rule == 702 /* Lv1Expr */; // TODO:
loop_control_Node.addChild(temp);
if (hasOptExpr) {
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimExpr */
|| rule == 702 /* Lv1Expr */; // TODO:
loop_control_Node.addChild(1, temp);
}
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimExpr */
|| rule == 702 /* Lv1Expr */; // TODO:
loop_control_Node.addChild(1, temp);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 831; // TODO:
loop_control_Node.addChild(1, temp);
stack.push(loop_control_Node);
} // Test
/**
* R831 Do Variable
*/
public void do_variable(Token id) {
FortranNode do_variable_Node = new FortranNode(831, "DoVariable");
FortranNode id_Node = new FortranNode("ID", id);
do_variable_Node.addChild(id_Node);
stack.push(do_variable_Node);
} // Test
/**
* R833 End Do Construct
*/
public void end_do() {
int rule = -1;
FortranNode temp = null;
FortranNode end_do_Node = new FortranNode(833, "EndDoCons");
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 834 /* EndDoStmt */
|| rule == 838 /* DoTermActionStmt */
;
end_do_Node.addChild(temp);
stack.push(end_do_Node);
} // Test
/**
* R834 End Do Statement
*/
public void end_do_stmt(Token label, Token endKeyword, Token doKeyword,
Token id, Token eos) {
FortranNode end_do_stmt_Node = new FortranNode(834, "EndDoStmt");
FortranNode label_Node = new FortranNode("Label", label);
FortranNode endKeyword_Node = new FortranNode("KeywordEnd", endKeyword);
FortranNode doKeyword_Node = new FortranNode("KeywordDo", doKeyword);
FortranNode id_Node = new FortranNode("ID", id);
end_do_stmt_Node.addChild(label_Node);
end_do_stmt_Node.addChild(endKeyword_Node);
end_do_stmt_Node.addChild(doKeyword_Node);
end_do_stmt_Node.addChild(id_Node);
stack.push(end_do_stmt_Node);
} // Test
/**
* R838 1 Do Termination Action Statement (with "inserted")
*/
@Deprecated
public void do_term_action_stmt(Token label, Token endKeyword,
Token doKeyword, Token id, Token eos, boolean inserted) {
/* Currently, no one calls this function */
FortranNode temp = null;
FortranNode do_term_action_stmt_Node = new FortranNode(838,
"DoTermActStmt");
FortranNode label_Node = new FortranNode("Label", label);
FortranNode endKeyword_Node = new FortranNode("KeywordEnd", endKeyword);
FortranNode doKeyword_Node = new FortranNode("KeywordDo", doKeyword);
FortranNode id_Node = new FortranNode("ID", id);
do_term_action_stmt_Node.addChild(label_Node);
do_term_action_stmt_Node.addChild(endKeyword_Node);
do_term_action_stmt_Node.addChild(doKeyword_Node);
do_term_action_stmt_Node.addChild(id_Node);
if (inserted) {
assert false;
}
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 214;
do_term_action_stmt_Node.addChild(temp);
stack.push(do_term_action_stmt_Node);
} // Test
public void cycle_stmt(Token label, Token cycleKeyword, Token id, Token eos) {
} // TODO: Implement
public void exit_stmt(Token label, Token exitKeyword, Token id, Token eos) {
} // TODO: Implement
/**
* R845 Goto Statement
*/
public void goto_stmt(Token label, Token goKeyword, Token toKeyword,
Token target_label, Token eos) {
FortranNode goto_stmt_Node = new FortranNode(845, "GotoStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode goKeyword_Node = new FortranNode("KeywordGo", goKeyword);
FortranNode toKeyword_Node = new FortranNode("KeywordTo", toKeyword);
FortranNode target_label_Node = new FortranNode("LabelRef",
target_label);
goto_stmt_Node.addChild(label_Node);
goto_stmt_Node.addChild(goKeyword_Node);
goto_stmt_Node.addChild(toKeyword_Node);
goto_stmt_Node.addChild(target_label_Node);
stack.push(goto_stmt_Node);
} // Test
/**
* R846
*/
public void computed_goto_stmt(Token label, Token goKeyword,
Token toKeyword, Token eos) {
int rule = -1;
FortranNode temp = null;
FortranNode computed_goto_stmt_Node = new FortranNode(846,
"ComputedGotoStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
// FortranNode keyword1_Node = new FortranNode("Keyword_Go", goKeyword);
// FortranNode keyword2_Node = new FortranNode("Keyword_To", toKeyword);
computed_goto_stmt_Node.addChild(label_Node);
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 701 /* PrimExpr */
|| rule == 702 /* Lv1Expr */
;
computed_goto_stmt_Node.addChild(temp);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 313 /* LblList */
;
computed_goto_stmt_Node.addChild(1, temp);
stack.push(computed_goto_stmt_Node);
} // TODO: Implement
public void assign_stmt(Token label1, Token assignKeyword, Token label2,
Token toKeyword, Token name, Token eos) {
} // TODO: Implement
public void assigned_goto_stmt(Token label, Token goKeyword,
Token toKeyword, Token name, Token eos) {
} // TODO: Implement
public void stmt_label_list() {
} // TODO: Implement
public void pause_stmt(Token label, Token pauseKeyword, Token constant,
Token eos) {
} // TODO: Implement
public void arithmetic_if_stmt(Token label, Token ifKeyword, Token label1,
Token label2, Token label3, Token eos) {
} // TODO: Implement
/**
* R848 Continue Statement
*/
public void continue_stmt(Token label, Token continueKeyword, Token eos) {
FortranNode continue_stmt_Node = new FortranNode(848, "ContinueStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode continueKeyword_Node = new FortranNode("Keyword",
continueKeyword);
if (stack.peek().rule() == 313) {
label_Node = stack.pop();
}
continue_stmt_Node.addChild(label_Node);
continue_stmt_Node.addChild(continueKeyword_Node);
stack.push(continue_stmt_Node);
} // Test
public void stop_stmt(Token label, Token stopKeyword, Token eos,
boolean hasStopCode) {
} // TODO: Implement
public void stop_code(Token digitString) {
} // TODO: Implement
public void errorstop_stmt(Token label, Token errorKeyword,
Token stopKeyword, Token eos, boolean hasStopCode) {
} // TODO: Implement
public void sync_all_stmt(Token label, Token syncKeyword, Token allKeyword,
Token eos, boolean hasSyncStatList) {
} // TODO: Implement
public void sync_stat(Token syncStat) {
} // TODO: Implement
public void sync_stat_list__begin() {
// Do nothing
}
public void sync_stat_list(int count) {
} // TODO: Implement
public void sync_images_stmt(Token label, Token syncKeyword,
Token imagesKeyword, Token eos, boolean hasSyncStatList) {
} // TODO: Implement
public void image_set(Token asterisk, boolean hasIntExpr) {
} // TODO: Implement
public void sync_memory_stmt(Token label, Token syncKeyword,
Token memoryKeyword, Token eos, boolean hasSyncStatList) {
} // TODO: Implement
public void lock_stmt(Token label, Token lockKeyword, Token eos,
boolean hasLockStatList) {
} // TODO: Implement
public void lock_stat(Token acquiredKeyword) {
} // TODO: Implement
public void lock_stat_list__begin() {
// Do nothing
}
public void lock_stat_list(int count) {
} // TODO: Implement
public void unlock_stmt(Token label, Token unlockKeyword, Token eos,
boolean hasSyncStatList) {
} // TODO: Implement
public void lock_variable() {
} // TODO: Implement
public void scalar_char_constant() {
} // TODO: Implement
public void io_unit() {
} // TODO: Implement
public void file_unit_number() {
} // TODO: Implement
public void open_stmt(Token label, Token openKeyword, Token eos) {
} // TODO: Implement
public void connect_spec(Token id) {
} // TODO: Implement
public void connect_spec_list__begin() {
// Do nothing
}
public void connect_spec_list(int count) {
} // TODO: Implement
public void close_stmt(Token label, Token closeKeyword, Token eos) {
} // TODO: Implement
public void close_spec(Token closeSpec) {
} // TODO: Implement
public void close_spec_list__begin() {
// Do nothing
}
public void close_spec_list(int count) {
} // TODO: Implement
public void read_stmt(Token label, Token readKeyword, Token eos,
boolean hasInputItemList) {
} // TODO: Implement
public void write_stmt(Token label, Token writeKeyword, Token eos,
boolean hasOutputItemList) {
} // TODO: Implement
public void print_stmt(Token label, Token printKeyword, Token eos,
boolean hasOutputItemList) {
} // TODO: Implement
public void io_control_spec(boolean hasExpression, Token keyword,
boolean hasAsterisk) {
} // TODO: Implement
public void io_control_spec_list__begin() {
// Do nothing
}
public void io_control_spec_list(int count) {
} // TODO: Implement
public void format() {
} // TODO: Implement
public void input_item() {
} // TODO: Implement
public void input_item_list__begin() {
// Do nothing
}
public void input_item_list(int count) {
} // TODO: Implement
public void output_item() {
} // TODO: Implement
public void output_item_list__begin() {
// Do nothing
}
public void output_item_list(int count) {
} // TODO: Implement
public void io_implied_do() {
} // TODO: Implement
public void io_implied_do_object() {
} // TODO: Implement
public void io_implied_do_control(boolean hasStride) {
} // TODO: Implement
public void dtv_type_spec(Token typeKeyword) {
} // TODO: Implement
public void wait_stmt(Token label, Token waitKeyword, Token eos) {
} // TODO: Implement
public void wait_spec(Token id) {
} // TODO: Implement
public void wait_spec_list__begin() {
// Do nothing
}
public void wait_spec_list(int count) {
} // TODO: Implement
public void backspace_stmt(Token label, Token backspaceKeyword, Token eos,
boolean hasPositionSpecList) {
} // TODO: Implement
public void endfile_stmt(Token label, Token endKeyword, Token fileKeyword,
Token eos, boolean hasPositionSpecList) {
} // TODO: Implement
public void rewind_stmt(Token label, Token rewindKeyword, Token eos,
boolean hasPositionSpecList) {
} // TODO: Implement
public void position_spec(Token id) {
} // TODO: Implement
public void position_spec_list__begin() {
// Do nothing
}
public void position_spec_list(int count) {
} // TODO: Implement
public void flush_stmt(Token label, Token flushKeyword, Token eos,
boolean hasFlushSpecList) {
} // TODO: Implement
public void flush_spec(Token id) {
} // TODO: Implement
public void flush_spec_list__begin() {
// Do nothing
}
public void flush_spec_list(int count) {
} // TODO: Implement
public void inquire_stmt(Token label, Token inquireKeyword, Token id,
Token eos, boolean isType2) {
} // TODO: Implement
public void inquire_spec(Token id) {
} // TODO: Implement
public void inquire_spec_list__begin() {
// Do nothing
}
public void inquire_spec_list(int count) {
} // TODO: Implement
public void format_stmt(Token label, Token formatKeyword, Token eos) {
} // TODO: Implement
public void format_specification(boolean hasFormatItemList) {
} // TODO: Implement
public void format_item(Token descOrDigit, boolean hasFormatItemList) {
} // TODO: Implement
public void format_item_list__begin() {
// Do nothing
}
public void format_item_list(int count) {
} // TODO: Implement
public void v_list_part(Token plus_minus, Token digitString) {
} // TODO: Implement
public void v_list__begin() {
// Do nothing
}
public void v_list(int count) {
} // TODO: Implement
/**
* R1101 [Begin] Main Program
*/
public void main_program__begin() {
// Do nothing
}
/**
* R1101 Main Program
*/
public void main_program(boolean hasProgramStmt, boolean hasExecutionPart,
boolean hasInternalSubprogramPart) {
int rule = -1;
FortranNode temp = null;
FortranNode main_Node = new FortranNode(1101, "Main");
// EndProgramStmt
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 1103;
main_Node.addChild(temp);
// (InternalSubprogram)
if (hasInternalSubprogramPart) {
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 210;
main_Node.addChild(0, temp);
}
// (ExecutionPart)
if (hasExecutionPart) {
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 208;
main_Node.addChild(0, temp);
}
// SpecificationPart
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 204;
main_Node.addChild(0, temp);
// (ProgramStmt)
if (hasProgramStmt) {
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 1102;
main_Node.addChild(0, temp);
}
// ROOT: Program_Main
root.addChild(main_Node);
} // Test
/**
* R1101 Ext Function Subprogram
*/
public void ext_function_subprogram(boolean hasPrefix) {
FortranNode prefix_Node = null;
FortranNode function_subprogram_Node = null;
assert !stack.isEmpty();
function_subprogram_Node = stack.pop();
assert function_subprogram_Node.rule() == 1223;
if (hasPrefix) {
assert !stack.isEmpty();
prefix_Node = stack.pop();
assert prefix_Node.rule() == 1227;
function_subprogram_Node.getChildByIndex(0)
.addChild(1, prefix_Node);
}
// ROOT: Subprogram_Function
root.addChild(function_subprogram_Node);
} // Test
/**
* R1102 Program Statement
*/
public void program_stmt(Token label, Token programKeyword, Token id,
Token eos) {
FortranNode prog_stmt_Node = new FortranNode(1102, "ProgramStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode keyword_Node = new FortranNode("Keyword", programKeyword);
FortranNode id_Node = new FortranNode("ID", id);
prog_stmt_Node.addChild(label_Node);
prog_stmt_Node.addChild(keyword_Node);
prog_stmt_Node.addChild(id_Node);
stack.push(prog_stmt_Node);
} // Test
/**
* R1103 End Program Statement
*/
public void end_program_stmt(Token label, Token endKeyword,
Token programKeyword, Token id, Token eos) {
FortranNode prog_stmt_end_Node = new FortranNode(1103, "EndProgramStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode endKeyword_Node = new FortranNode("KeywordEnd",
programKeyword);
FortranNode programKeyword_Node = new FortranNode("KeywordProgram",
programKeyword);
FortranNode id_Node = new FortranNode("ID", id);
prog_stmt_end_Node.addChild(label_Node);
prog_stmt_end_Node.addChild(endKeyword_Node);
prog_stmt_end_Node.addChild(programKeyword_Node);
prog_stmt_end_Node.addChild(id_Node);
stack.push(prog_stmt_end_Node);
} // Test
public void module() {
} // TODO: Implement
public void module_stmt__begin() {
// Do nothing
}
public void module_stmt(Token label, Token moduleKeyword, Token id,
Token eos) {
} // TODO: Implement
public void end_module_stmt(Token label, Token endKeyword,
Token moduleKeyword, Token id, Token eos) {
} // TODO: Implement
public void module_subprogram_part(int count) {
} // TODO: Implement
public void module_subprogram(boolean hasPrefix) {
} // TODO: Implement
public void use_stmt(Token label, Token useKeyword, Token id,
Token onlyKeyword, Token eos, boolean hasModuleNature,
boolean hasRenameList, boolean hasOnly) {
} // TODO: Implement
public void module_nature(Token nature) {
} // TODO: Implement
public void rename(Token id1, Token id2, Token op1, Token defOp1,
Token op2, Token defOp2) {
} // TODO: Implement
public void rename_list__begin() {
// Do nothing
}
public void rename_list(int count) {
} // TODO: Implement
public void only(boolean hasGenericSpec, boolean hasRename,
boolean hasOnlyUseName) {
} // TODO: Implement
public void only_list__begin() {
// Do nothing
}
public void only_list(int count) {
} // TODO: Implement
public void submodule(boolean hasModuleSubprogramPart) {
} // TODO: Implement
public void submodule_stmt__begin() {
// Do nothing
}
public void submodule_stmt(Token label, Token submoduleKeyword, Token name,
Token eos) {
} // TODO: Implement
public void parent_identifier(Token ancestor, Token parent) {
} // TODO: Implement
public void end_submodule_stmt(Token label, Token endKeyword,
Token submoduleKeyword, Token name, Token eos) {
} // TODO: Implement
public void block_data() {
} // TODO: Implement
public void block_data_stmt__begin() {
// Do nothing
}
public void block_data_stmt(Token label, Token blockKeyword,
Token dataKeyword, Token id, Token eos) {
} // TODO: Implement
public void end_block_data_stmt(Token label, Token endKeyword,
Token blockKeyword, Token dataKeyword, Token id, Token eos) {
} // TODO: Implement
public void interface_block() {
} // TODO: Implement
public void interface_specification() {
} // TODO: Implement
public void interface_stmt__begin() {
// Do nothing
}
public void interface_stmt(Token label, Token abstractToken, Token keyword,
Token eos, boolean hasGenericSpec) {
} // TODO: Implement
public void end_interface_stmt(Token label, Token kw1, Token kw2,
Token eos, boolean hasGenericSpec) {
} // TODO: Implement
public void interface_body(boolean hasPrefix) {
} // TODO: Implement
public void procedure_stmt(Token label, Token module,
Token procedureKeyword, Token eos) {
} // TODO: Implement
public void generic_spec(Token keyword, Token name, int type) {
} // TODO: Implement
public void dtio_generic_spec(Token rw, Token format, int type) {
} // TODO: Implement
public void import_stmt(Token label, Token importKeyword, Token eos,
boolean hasGenericNameList) {
} // TODO: Implement
/**
* R1210 External Statement
*/
public void external_stmt(Token label, Token externalKeyword, Token eos) {
FortranNode temp = null;
FortranNode external_stmt_Node = new FortranNode(1210, "ExternalStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode externalKeyword_Node = new FortranNode("Keyword_Ext",
externalKeyword);
external_stmt_Node.addChild(label_Node);
external_stmt_Node.addChild(externalKeyword_Node);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 102;
external_stmt_Node.addChild(temp);
stack.push(external_stmt_Node);
} // Test
public void procedure_declaration_stmt(Token label, Token procedureKeyword,
Token eos, boolean hasProcInterface, int count) {
} // TODO: Implement
public void proc_interface(Token id) {
} // TODO: Implement
public void proc_attr_spec(Token attrKeyword, Token id, int spec) {
} // TODO: Implement
public void proc_decl(Token id, boolean hasNullInit) {
} // TODO: Implement
public void proc_decl_list__begin() {
// Do nothing
}
public void proc_decl_list(int count) {
} // TODO: Implement
/**
* R1216 Intrinsic Statement
*/
public void intrinsic_stmt(Token label, Token intrinsicToken, Token eos) {
FortranNode temp = null;
FortranNode intrinsic_stmt_Node = new FortranNode(1216, "IntrinsicStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode intrinsicToken_Node = new FortranNode("Keyword_Intr",
intrinsicToken);
intrinsic_stmt_Node.addChild(label_Node);
intrinsic_stmt_Node.addChild(intrinsicToken_Node);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 102;
intrinsic_stmt_Node.addChild(temp);
stack.push(intrinsic_stmt_Node);
} // Test
public void function_reference(boolean hasActualArgSpecList) {
} // TODO: Implement
/**
* R1218
*/
public void call_stmt(Token label, Token callKeyword, Token eos,
boolean hasActualArgSpecList) {
FortranNode temp = null;
FortranNode call_stmt_Node = new FortranNode(1218, "CallStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
call_stmt_Node.addChild(label_Node);
if (hasActualArgSpecList) {
assert false; // TODO:
}
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 1219;
call_stmt_Node.addChild(temp);
stack.push(call_stmt_Node);
} // Test
/**
* R1219 Procdure Designator
*/
public void procedure_designator() {
FortranNode temp = null;
FortranNode procedure_designator_Node = new FortranNode(1219,
"ProcDesignator");
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 612;
procedure_designator_Node.addChild(temp);
stack.push(procedure_designator_Node);
} // Test
public void actual_arg_spec(Token keyword) {
} // TODO: Implement
public void actual_arg_spec_list__begin() {
// Do nothing
}
public void actual_arg_spec_list(int count) {
} // TODO: Implement
public void actual_arg(boolean hasExpr, Token label) {
} // TODO: Implement
/**
* R1223 Function Subprogram (Part)
*/
public void function_subprogram(boolean hasExePart, boolean hasIntSubProg) {
int rule = -1;
FortranNode temp = null;
FortranNode function_subprogram_Node = new FortranNode(1223,
"FunctionSubprogram");
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 1230;
function_subprogram_Node.addChild(temp);
if (hasExePart) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 208;
function_subprogram_Node.addChild(0, temp);
}
if (hasIntSubProg) {
assert false;
}
assert !stack.isEmpty();
rule = stack.peek().rule();
if (rule == 204) {
temp = stack.pop();
function_subprogram_Node.addChild(0, temp);
}
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 1224;
function_subprogram_Node.addChild(0, temp);
stack.push(function_subprogram_Node);
} // Test
/**
* R1224 [Begin] Function Statement
*/
public void function_stmt__begin() {
// Do nothing
}
/**
* R1224
*/
public void function_stmt(Token label, Token keyword, Token name,
Token eos, boolean hasGenericNameList, boolean hasSuffix) {
FortranNode temp = null;
FortranNode function_stmt_Node = new FortranNode(1224, "FunctionStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode keyword_Node = new FortranNode("Keyword", keyword);
FortranNode name_Node = new FortranNode("ID", name);
function_stmt_Node.addChild(label_Node);
function_stmt_Node.addChild(keyword_Node);
function_stmt_Node.addChild(name_Node);
if (hasGenericNameList) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 102;
function_stmt_Node.addChild(temp);
}
if (hasSuffix) {
assert false;
}
stack.push(function_stmt_Node);
} // TODO: Implement
public void proc_language_binding_spec() {
} // TODO: Implement
/**
* R1227 [List] Prefix List
*/
public void prefix(int specCount) {
int counter = specCount;
FortranNode temp = null;
FortranNode prefix_Node = new FortranNode(1227, "Prefix[" + counter
+ "]");
while (counter > 0) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 1228;
prefix_Node.addChild(0, temp);
counter--;
}
stack.push(prefix_Node);
} // Test
public void t_prefix(int specCount) {
} // TODO: Implement
/**
* R1228 [Element]
*/
public void prefix_spec(boolean isDecTypeSpec) {
FortranNode temp = null;
FortranNode prefix_spec_Node = new FortranNode(1228, "PrefixSpec");
if (isDecTypeSpec) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 502;
prefix_spec_Node.addChild(temp);
} else {
assert false;// TODO:
}
stack.push(prefix_spec_Node);
} // Test
public void t_prefix_spec(Token spec) {
} // TODO: Implement
public void suffix(Token resultKeyword, boolean hasProcLangBindSpec) {
} // TODO: Implement
public void result_name() {
} // TODO: Implement
/**
* R1230 End Function Statement
*/
public void end_function_stmt(Token label, Token keyword1, Token keyword2,
Token name, Token eos) {
FortranNode end_function_stmt_Node = new FortranNode(1230,
"EndFunctionStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode keyword1_Node = new FortranNode("Keyword1", keyword2);
FortranNode keyword2_Node = new FortranNode("Keyword2", keyword2);
FortranNode name_Node = new FortranNode("Name", name);
end_function_stmt_Node.addChild(label_Node);
end_function_stmt_Node.addChild(keyword1_Node);
end_function_stmt_Node.addChild(keyword2_Node);
end_function_stmt_Node.addChild(name_Node);
stack.push(end_function_stmt_Node);
} // Test
/**
* R1232 [Begin] Subroutine Statement
*/
public void subroutine_stmt__begin() {
// Do nothing
}
/**
* R1232
*/
public void subroutine_stmt(Token label, Token keyword, Token name,
Token eos, boolean hasPrefix, boolean hasDummyArgList,
boolean hasBindingSpec, boolean hasArgSpecifier) {
FortranNode temp = null;
FortranNode subroutine_stmt_Node = new FortranNode(1232,
"SubRoutineStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode keyword_Node = new FortranNode("Keyword", keyword);
FortranNode name_Node = new FortranNode("ID", name);
subroutine_stmt_Node.addChild(label_Node);
subroutine_stmt_Node.addChild(keyword_Node);
subroutine_stmt_Node.addChild(name_Node);
if (hasPrefix) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 1227;
subroutine_stmt_Node.addChild(1, temp);
}
if (hasArgSpecifier) {
if (hasDummyArgList) {
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 1233;
subroutine_stmt_Node.addChild(temp);
}
if (hasBindingSpec) {
assert false; // TODO:
}
}
stack.push(subroutine_stmt_Node);
} // Test
/**
* R1233 [Element] Dummy Argument (for Subroutine)
*/
public void dummy_arg(Token dummy) {
FortranNode dummy_arg_Node = new FortranNode(1233, "DummyArg", dummy);
stack.push(dummy_arg_Node);
} // Test
/**
* R1233 [Begin] Dummy Argument List
*/
public void dummy_arg_list__begin() {
// Do nothing
}
/**
* R1233 [List] Dummy Argument List
*/
public void dummy_arg_list(int count) {
int counter = count;
FortranNode temp = null;
FortranNode dummy_arg_list_Node = new FortranNode(1233, "ArgsList["
+ counter + "]");
while (counter > 0) {
assert !stack.empty();
temp = stack.pop();
assert temp.rule() == 1233;
dummy_arg_list_Node.addChild(0, temp);
counter--;
}
stack.push(dummy_arg_list_Node);
} // Test
/**
* R1234 & R1231 End Subroutine Statement & Subroutine Subprogram
*/
public void end_subroutine_stmt(Token label, Token keyword1,
Token keyword2, Token name, Token eos) {
int rule = -1;
FortranNode temp = null;
FortranNode end_subroutine_stmt_Node = new FortranNode(1234,
"EndSubroutineStmt");
FortranNode subroutine_subprogram_Node = new FortranNode(1231,
"Subroutine");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode keyword1_Node = new FortranNode("Keyword1", keyword1);
FortranNode keyword2_Node = new FortranNode("Keyword2", keyword2);
FortranNode name_Node = new FortranNode("ID", name);
end_subroutine_stmt_Node.addChild(label_Node);
end_subroutine_stmt_Node.addChild(keyword1_Node);
end_subroutine_stmt_Node.addChild(keyword2_Node);
end_subroutine_stmt_Node.addChild(name_Node);
stack.push(end_subroutine_stmt_Node);
// R1231
// EndSubroutineStmt
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 1234;
subroutine_subprogram_Node.addChild(temp);
// (InternalSubprogram)
assert !stack.isEmpty();
rule = stack.peek().rule();
while (rule == 210) {
temp = stack.pop();
subroutine_subprogram_Node.addChild(0, temp);
assert !stack.isEmpty();
rule = stack.peek().rule();
}
// (ExecutionPart)
assert !stack.isEmpty();
rule = stack.peek().rule();
while (rule == 208) {
temp = stack.pop();
subroutine_subprogram_Node.addChild(0, temp);
assert !stack.isEmpty();
rule = stack.peek().rule();
}
// SpecificationPart
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 204;
subroutine_subprogram_Node.addChild(0, temp);
// SubroutineStmt
assert !stack.isEmpty();
temp = stack.pop();
rule = temp.rule();
assert rule == 1232;
subroutine_subprogram_Node.addChild(0, temp);
// ROOT: Subprogram_Subroutine
root.addChild(subroutine_subprogram_Node);
} // Test
public void entry_stmt(Token label, Token keyword, Token id, Token eos,
boolean hasDummyArgList, boolean hasSuffix) {
} // TODO: Implement
/**
* R1236
*/
public void return_stmt(Token label, Token keyword, Token eos,
boolean hasScalarIntExpr) {
// FortranNode temp = null;
FortranNode return_stmt_Node = new FortranNode(1236, "ReturnStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
return_stmt_Node.addChild(label_Node);
if (hasScalarIntExpr) {
assert false; // TODO:
}
stack.push(return_stmt_Node);
} // Test
public void contains_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
public void separate_module_subprogram(boolean hasExecutionPart,
boolean hasInternalSubprogramPart) {
} // TODO: Implement
public void separate_module_subprogram__begin() {
// Do nothing
} // TODO: Implement
public void mp_subprogram_stmt(Token label, Token moduleKeyword,
Token procedureKeyword, Token name, Token eos) {
} // TODO: Implement
public void end_mp_subprogram_stmt(Token label, Token keyword1,
Token keyword2, Token name, Token eos) {
} // TODO: Implement
public void stmt_function_stmt(Token label, Token functionName, Token eos,
boolean hasGenericNameList) {
} // TODO: Implement
public void end_of_stmt(Token eos) {
// Omitted
}
/**
* R0 Start Of File
*/
public void start_of_file(String filename, String path) {
FortranNode programe_file_Node = new FortranNode(0, filename);
root = programe_file_Node;
}
/**
* R0 End Of File
*/
public void end_of_file(String filename, String path) {
System.out.print(root.toString());
}
public void cleanUp() {
} // TODO: Implement
public void rice_image_selector(Token idTeam) {
} // TODO: Implement
public void rice_co_dereference_op(Token lbracket, Token rbracket) {
} // TODO: Implement
public void rice_allocate_coarray_spec(int selection, Token id) {
} // TODO: Implement
public void rice_co_with_team_stmt(Token label, Token id) {
} // TODO: Implement
public void rice_end_with_team_stmt(Token label, Token id, Token eos) {
} // TODO: Implement
public void rice_finish_stmt(Token label, Token idTeam, Token eos) {
} // TODO: Implement
public void rice_end_finish_stmt(Token label, Token eos) {
} // TODO: Implement
public void rice_spawn_stmt(Token label, Token spawn, Token eos,
boolean hasEvent) {
} // TODO: Implement
public void lope_halo_stmt(Token label, Token keyword,
boolean hasHaloBoundarySpec, boolean hasHaloCopyFn, Token eos,
int count) {
} // TODO: Implement
public void lope_halo_decl(Token id, boolean hasHaloSpec) {
} // TODO: Implement
public void lope_halo_copy_fn(Token id) {
} // TODO: Implement
public void lope_halo_spec(int count) {
} // TODO: Implement
public void lope_halo_spec_element(int type) {
} // TODO: Implement
public void lope_halo_boundary_spec(int count) {
} // TODO: Implement
public void lope_halo_boundary_spec_element(int type) {
} // TODO: Implement
public void lope_exchange_halo_stmt(Token label, Token keyword, Token eos) {
} // TODO: Implement
public void next_token(Token tk) {
} // TODO: Implement
/**
* R838 2 Do Termination Action Statement
*/
@Override
public void do_term_action_stmt(Token label, Token endKeyword,
Token doKeyword, Token id, Token eos) {
FortranNode temp = null;
FortranNode do_term_action_stmt_Node = new FortranNode(838,
"DoTermActStmt");
FortranNode label_Node = new FortranNode("LabelDef", label);
FortranNode endKeyword_Node = new FortranNode("Keyword", endKeyword);
FortranNode doKeyword_Node = new FortranNode("Keyword", doKeyword);
FortranNode id_Node = new FortranNode("ID", id);
do_term_action_stmt_Node.addChild(label_Node);
do_term_action_stmt_Node.addChild(endKeyword_Node);
do_term_action_stmt_Node.addChild(doKeyword_Node);
do_term_action_stmt_Node.addChild(id_Node);
assert !stack.isEmpty();
temp = stack.pop();
assert temp.rule() == 214;
do_term_action_stmt_Node.addChild(temp);
stack.push(do_term_action_stmt_Node);
} // Test
}