grammar  hello;


/*
 : EOS;
commentOrNewLine : COMMENTORNEWLINE ;*/
@header{
	import ast.*;
}

start returns [ASTNode node]
    : p = executableProgram EOF { $node = new Start($p.node); }
    ;

executableProgram returns [ProgramNode node]
    : pul = programUnitList { $node = new ExecutableProgram($pul.node); }
    ;

programUnitList returns [ProgramUnitListNode node]
    : pu = programUnit { $node = new ProgramUnitListSingle($pu.node); }
    | pu = programUnit pul = programUnitList { $node = new ProgramUnitListMultiple($pu.node, $pul.node); }
    ;

programUnit returns [ProgramUnitNode node]
    : mp = mainProgram { $node = new ProgramUnitMain($mp.node); }
    | fs = functionSubprogram { $node = new ProgramUnitFunction($fs.node); }
    | ss = subroutineSubprogram { $node = new ProgramUnitSubroutine($ss.node); }
    | bd = blockDataSubprogram { $node = new ProgramUnitBlockData($bd.node); }
    | m = module { $node = new ProgramUnitModule($m.node); }
    ;

mainProgram returns [MainProgramNode node]
    : ps = programStmt mr = mainRange { $node = new MainProgram($ps.node, $mr.node); }
    | mr = mainRange { $node = new MainProgram(null, $mr.node); }
    ;

programStmt returns [ProgramStmtNode node]
    : PROGRAM id = identifier { $node = new ProgramStmt($id.node); }
    ;
identifier returns [IdentifierNode node]
   : IDENT{ $node = new Identifier($IDENT.text); }
   ;

mainRange returns [MainRangeNode node]
    : b = body e = endProgramStmt { $node = new MainRange($b.node, $e.node); }
    // Other alternatives for mainRange
	| endProgramStmt
    | (bodyPlusInternals endProgramStmt) ;

bodyPlusInternals returns [BodyPlusInternalsNode node]
    : b = body cs = containsStmt isp = internalSubprogram { $node = new BodyPlusInternalsType1($b.node, $cs.node, $isp.node); }
    | cs = containsStmt isp = internalSubprogram { $node = new BodyPlusInternalsType2($cs.node, $isp.node); }
    | bpi = bodyPlusInternals isp = internalSubprogram { $node = new BodyPlusInternalsType3($bpi.node, $isp.node); }
    ;

internalSubprogram returns [InternalSubprogramNode node]
    : fs = functionSubprogram { $node = new InternalSubprogramFunction($fs.node); }
    | ss = subroutineSubprogram { $node = new InternalSubprogramSubroutine($ss.node); }
    ;

specificationPartConstruct returns [SpecificationPartConstructNode node]
    : is = implicitStmt { $node = new SpecificationPartConstructImplicit($is.node); }
    | ps = parameterStmt { $node = new SpecificationPartConstructParameter($ps.node); }
    | fs = formatStmt { $node = new SpecificationPartConstructFormat($fs.node); }
    | es = entryStmt { $node = new SpecificationPartConstructEntry($es.node); }
    | dc = declarationConstruct { $node = new SpecificationPartConstructDeclaration($dc.node); }
    | is = includeStmt { $node = new SpecificationPartConstructInclude($is.node); }
    | us = useStmt { $node = new SpecificationPartConstructUse($us.node); }
    ;

useStmt returns [UseStmtNode node]
    : USE n = NAME { $node = new UseStmtSimple($n.node); }
    | USE n = NAME COMMA ONLY COLON { $node = new UseStmtOnlyColon($n.node); }
    | USE n = NAME COMMA rl = renameList { $node = new UseStmtRenameList($n.node, $rl.node); }
    | USE n = NAME COMMA ONLY COLON ol = onlyList { $node = new UseStmtOnlyList($n.node, $ol.node); }
    ;

onlyList returns [OnlyListNode node]
    : os = onlyStmt { $node = new OnlyListSingle($os.node); }
    | os = onlyStmt osl = onlyStmtList { $node = new OnlyListMultiple($os.node, $osl.node); }
    ;

onlyStmtList returns [OnlyStmtListNode node]
    : COMMA os = onlyStmt { $node = new OnlyStmtListSingle($os.node); }
    | COMMA os = onlyStmt osl = onlyStmtList { $node = new OnlyStmtListMultiple($os.node, $osl.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

onlyStmt returns [OnlyStmtNode node]
    : gs = genericSpec { $node = new OnlyStmtGenericSpec($gs.node); }
    | id = ident IMPLIEDT un = useName { $node = new OnlyStmtIdentUseName($id.node, $un.node); }
    | un = useName { $node = new OnlyStmtUseName($un.node); }
    ;

renameList returns [RenameListNode node]
    : r = rename rt = renameListTail { $node = new RenameList($r.node, $rt.node); }
    ;

renameListTail returns [RenameListTailNode node]
    : COMMA r = rename rt = renameListTail { $node = new RenameListTail($r.node, $rt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

rename returns [RenameNode node]
    : id = ident IMPLIEDT un = useName { $node = new Rename($id.node, $un.node); }
    ;

useName returns [UseNameNode node]
    : id = ident { $node = new UseName($id.node); }
    ;

parameterStmt returns [ParameterStmtNode node]
    : PARAMETER LPAREN ncdl = namedConstantDefList RPAREN { $node = new ParameterStmt($ncdl.node); }
    ;

namedConstantDefList returns [NamedConstantDefListNode node]
    : ncd = namedConstantDef { $node = new NamedConstantDefListSingle($ncd.node); }
    | ncd = namedConstantDef ncdlt = namedConstantDefListTail { $node = new NamedConstantDefListMultiple($ncd.node, $ncdlt.node); }
    ;

namedConstantDefListTail returns [NamedConstantDefListTailNode node]
    : ncd = namedConstantDef { $node = new NamedConstantDefListTailSingle($ncd.node); }
    | ncd = namedConstantDef ncdlt = namedConstantDefListTail { $node = new NamedConstantDefListTailMultiple($ncd.node, $ncdlt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

namedConstantDef returns [NamedConstantDefNode node]
    : NAME ASSIGN expr = expression { $node = new NamedConstantDef($NAME.text, $expr.node); }
    ;

endProgramStmt returns [EndProgramStmtNode node]
    : END { $node = new EndProgramStmt(); }
    | END PROGRAM { $node = new EndProgramStmt(); }
    | END PROGRAM NAME { $node = new EndProgramStmt($NAME.text); }
    ;


blockDataSubprogram returns [BlockDataSubprogramNode node]
    : bds = blockDataStmt bdb = blockDataBody ebd = endBlockDataStmt { $node = new BlockDataSubprogram($bds.node, $bdb.node, $ebd.node); }
    | bds = blockDataStmt ebd = endBlockDataStmt { $node = new BlockDataSubprogram($bds.node, null, $ebd.node); }
    ;

blockDataStmt returns [BlockDataStmtNode node]
    : BLOCKDATA { $node = new BlockDataStmt(null); }
    | BLOCKDATA NAME { $node = new BlockDataStmt($NAME.text); }
    ;

blockDataBody returns [BlockDataBodyNode node]
    : bdbc = blockDataBodyConstruct { $node = new BlockDataBodySingle($bdbc.node); }
    | bdb = blockDataBody bdbc = blockDataBodyConstruct { $node = new BlockDataBodyMultiple($bdb.node, $bdbc.node); }
    ;

blockDataBodyConstruct returns [BlockDataBodyConstructNode node]
    : spc = specificationPartConstruct { $node = new BlockDataBodyConstruct($spc.node); }
    ;

endBlockDataStmt returns [EndBlockDataStmtNode node]
    : ENDBLOCKDATA { $node = new EndBlockDataStmt(); }
    | ENDBLOCKDATA NAME { $node = new EndBlockDataStmt($NAME.text); }
    ;

formatStmt returns [FormatStmtNode node]
    : ICON FORMAT LPAREN RPAREN { $node = new FormatStmtEmpty(); }
    | ICON FORMAT LPAREN fs = fmtSpec RPAREN { $node = new FormatStmt($fs.node); }
    ;

fmtSpec returns [FmtSpecNode node]
    : fe = formatedit { $node = new FmtSpecSingle($fe.node); }
    | fs = fmtSpec fe = formatedit { $node = new FmtSpecMultiple($fs.node, $fe.node); }
    ;

formatedit returns [FormatEditNode node]
    : ee = editElement { $node = new FormatEdit($ee.node); }
    ;

editElement returns [EditElementNode node]
    : FCON { $node = new EditElementFcon($FCON.text); }
    | SCON { $node = new EditElementScon($SCON.text); }
    ;

mislexedFcon returns [MislexedFconNode node]
    : RDCON SPOFF RDCON SPON { $node = new MislexedFconType1(); }
    | NAME SPOFF RDCON SPON { $node = new MislexedFconType2($NAME.text); }
    ;

module returns [ModuleNode node]
    : ms = moduleStmt mb = moduleBody ems = endModuleStmt { $node = new Module($ms.node, $mb.node, $ems.node); }
    | ms = moduleStmt ems = endModuleStmt { $node = new Module($ms.node, null, $ems.node); }
    ;

endModuleStmt returns [EndModuleStmtNode node]
    : END MODULE { $node = new EndModuleStmt(); }
    | END MODULE NAME { $node = new EndModuleStmt($NAME.text); }
    | ENDMODULE { $node = new EndModuleStmt(); }
    | ENDMODULE NAME { $node = new EndModuleStmt($NAME.text); }
    | END { $node = new EndModuleStmt(); }
    ;

entryStmt returns [EntryStmtNode node]
    : ENTRY NAME spl = subroutineParList RESULT LPAREN NAME RPAREN { $node = new EntryStmt($NAME.text, $spl.node, $NAME.text); }
    ;

subroutineParList returns [SubroutineParListNode node]
    : LPAREN sp = subroutinePars RPAREN { $node = new SubroutineParList($sp.node); }
    | LPAREN RPAREN { $node = new SubroutineParListEmpty(); }
    | { $node = new NullNode(); } // For the empty case
    ;

subroutinePars returns [SubroutineParsNode node]
    : sp = subroutinePar { $node = new SubroutineParsSingle($sp.node); }
    | sp = subroutinePar splt = subroutineParListTail { $node = new SubroutineParsMultiple($sp.node, $splt.node); }
    ;

subroutineParListTail returns [SubroutineParListTailNode node]
    : COMMA sp = subroutinePar { $node = new SubroutineParListTailSingle($sp.node); }
    | COMMA sp = subroutinePar splt = subroutineParListTail { $node = new SubroutineParListTailMultiple($sp.node, $splt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

subroutinePar returns [SubroutineParNode node]
    : dan = dummyArgName { $node = new SubroutineParDummyArg($dan.node); }
    | STAR { $node = new SubroutineParStar(); }
    ;

declarationConstruct returns [DeclarationConstructNode node]
    : dtd = derivedTypeDef { $node = new DeclarationConstructDerivedType($dtd.node); }
    | ib = interfaceBlock { $node = new DeclarationConstructInterface($ib.node); }
    | tds = typeDeclarationStmt { $node = new DeclarationConstructTypeDeclaration($tds.node); }
    | ss = specificationStmt { $node = new DeclarationConstructSpecification($ss.node); }
    ;

specificationStmt returns [SpecificationStmtNode node]
    : cs = commonStmt { $node = new SpecificationStmtCommon($cs.node); }
    | ds = dataStmt { $node = new SpecificationStmtData($ds.node); }
    // Add other variations of specification statements
    ;

targetStmt returns [TargetStmtNode node]
    : TARGET DOUBLECOLON tol = targetObjectList { $node = new TargetStmt($tol.node); }
    | TARGET tol = targetObjectList { $node = new TargetStmt($tol.node); }
    ;

targetObjectList returns [TargetObjectListNode node]
    : to = targetObject { $node = new TargetObjectListSingle($to.node); }
    | to = targetObject tot = targetObjectListTail { $node = new TargetObjectListMultiple($to.node, $tot.node); }
    ;

targetObjectListTail returns [TargetObjectListTailNode node]
    : COMMA to = targetObject { $node = new TargetObjectListTailSingle($to.node); }
    | COMMA to = targetObject tot = targetObjectListTail { $node = new TargetObjectListTailMultiple($to.node, $tot.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

targetObject returns [TargetObjectNode node]
    : on = objectName { $node = new TargetObject($on.node); }
    | on = objectName LPAREN as = arraySpec RPAREN { $node = new TargetObjectArray($on.node, $as.node); }
    ;

pointerStmt returns [PointerStmtNode node]
    : POINTER DOUBLECOLON posl = pointerStmtObjectList { $node = new PointerStmt($posl.node); }
    | POINTER posl = pointerStmtObjectList { $node = new PointerStmt($posl.node); }
    ;

pointerStmtObject returns [PointerStmtObjectNode node]
    : on = objectName { $node = new PointerStmtObject($on.node); }
    | on = objectName LPAREN dssl = deferredShapeSpecList RPAREN { $node = new PointerStmtObjectArray($on.node, $dssl.node); }
    ;

pointerStmtObjectList returns [PointerStmtObjectListNode node]
    : pso = pointerStmtObject psot = pointerStmtObjectListTail { $node = new PointerStmtObjectList($pso.node, $psot.node); }
    ;

pointerStmtObjectListTail returns [PointerStmtObjectListTailNode node]
    : COMMA pso = pointerStmtObject { $node = new PointerStmtObjectListTailSingle($pso.node); }
    | COMMA pso = pointerStmtObject psot = pointerStmtObjectListTail { $node = new PointerStmtObjectListTailMultiple($pso.node, $psot.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

optionalStmt returns [OptionalStmtNode node]
    : OPTIONAL DOUBLECOLON opl = optionalParList { $node = new OptionalStmt($opl.node); }
    | OPTIONAL opl = optionalParList { $node = new OptionalStmt($opl.node); }
    ;

optionalParList returns [OptionalParListNode node]
    : op = optionalPar { $node = new OptionalParListSingle($op.node); }
    | op = optionalPar oplt = optionalParListTail { $node = new OptionalParListMultiple($op.node, $oplt.node); }
    ;

optionalParListTail returns [OptionalParListTailNode node]
    : COMMA op = optionalPar { $node = new OptionalParListTailSingle($op.node); }
    | COMMA op = optionalPar oplt = optionalParListTail { $node = new OptionalParListTailMultiple($op.node, $oplt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

optionalPar returns [OptionalParNode node]
    : dan = dummyArgName { $node = new OptionalPar($dan.node); }
    ;

namelistStmt returns [NamelistStmtNode node]
    : NAMELIST ngs = namelistGroups { $node = new NamelistStmt($ngs.node); }
    ;

namelistGroups returns [NamelistGroupsNode node]
    : DIV ngn = namelistGroupName DIV ngo = namelistGroupObject { $node = new NamelistGroups($ngn.node, $ngo.node); }
    // Add other variations of namelistGroups
    ;

namelistGroupName returns [NamelistGroupNameNode node]
    : NAME { $node = new NamelistGroupName($NAME.text); }
    ;

namelistGroupObject returns [NamelistGroupObjectNode node]
    : vn = variableName { $node = new NamelistGroupObject($vn.node); }
    ;

intentStmt returns [IntentStmtNode node]
    : INTENT LPAREN is = intentSpec RPAREN iplc = intentParListWithColon { $node = new IntentStmt($is.node, $iplc.node); }
    | INTENT LPAREN is = intentSpec RPAREN ipl = intentParList { $node = new IntentStmt($is.node, $ipl.node); }
    ;

intentParListWithColon returns [IntentParListWithColonNode node]
    : DOUBLECOLON ipl = intentParList { $node = new IntentParListWithColon($ipl.node); }
    ;

intentParList returns [IntentParListNode node]
    : ip = intentPar { $node = new IntentParListSingle($ip.node); }
    | ip = intentPar COMMA ipl = intentParList { $node = new IntentParListMultiple($ip.node, $ipl.node); }
    ;

intentPar returns [IntentParNode node]
    : dan = dummyArgName { $node = new IntentPar($dan.node); }
    ;

dummyArgName returns [DummyArgNameNode node]
    : NAME { $node = new DummyArgName($NAME.text); }
    ;

intentSpec returns [IntentSpecNode node]
    : IN { $node = new IntentSpecIn(); }
    | OUT { $node = new IntentSpecOut(); }
    | INOUT { $node = new IntentSpecInOut(); }
    ;

allocatableStmt returns [AllocatableStmtNode node]
    : ALLOCATABLE DOUBLECOLON aal = arrayAllocationList { $node = new AllocatableStmt($aal.node); }
    | ALLOCATABLE aal = arrayAllocationList { $node = new AllocatableStmt($aal.node); }
    ;

arrayAllocationList returns [ArrayAllocationListNode node]
    : aa = arrayAllocation { $node = new ArrayAllocationListSingle($aa.node); }
    | aa = arrayAllocation aalt = arrayAllocationListTail { $node = new ArrayAllocationListMultiple($aa.node, $aalt.node); }
    ;

arrayAllocationListTail returns [ArrayAllocationListTailNode node]
    : COMMA aa = arrayAllocation { $node = new ArrayAllocationListTailSingle($aa.node); }
    | COMMA aa = arrayAllocation aalt = arrayAllocationListTail { $node = new ArrayAllocationListTailMultiple($aa.node, $aalt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

arrayAllocation returns [ArrayAllocationNode node]
    : an = arrayName { $node = new ArrayAllocation($an.node); }
    | an = arrayName LPAREN dssl = deferredShapeSpecList RPAREN { $node = new ArrayAllocationArray($an.node, $dssl.node); }
    ;

arrayName returns [ArrayNameNode node]
    : id = ident { $node = new ArrayName($id.node); }
    ;

accessStmt returns [AccessStmtNode node]
    : ACCESSSPEC DOUBLECOLON aidl = accessIdList { $node = new AccessStmt($aidl.node); }
    | ACCESSSPEC aidl = accessIdList { $node = new AccessStmt($aidl.node); }
    | ACCESSSPEC { $node = new AccessStmtEmpty(); }
    ;

accessIdList returns [AccessIdListNode node]
    : aid = accessId { $node = new AccessIdListSingle($aid.node); }
    | aid = accessId ailt = accessIdListTail { $node = new AccessIdListMultiple($aid.node, $ailt.node); }
    ;

accessIdListTail returns [AccessIdListTailNode node]
    : COMMA aid = accessId { $node = new AccessIdListTailSingle($aid.node); }
    | COMMA aid = accessId ailt = accessIdListTail { $node = new AccessIdListTailMultiple($aid.node, $ailt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

accessId returns [AccessIdNode node]
    : gn = genericName { $node = new AccessIdGenericName($gn.node); }
    | gs = genericSpec { $node = new AccessIdGenericSpec($gs.node); }
    ;

genericName returns [GenericNameNode node]
    : id = ident { $node = new GenericName($id.node); }
    ;

saveStmt returns [SaveStmtNode node]
    : SAVE { $node = new SaveStmt(); }
    | SAVE sel = savedEntityList { $node = new SaveStmtEntityList($sel.node); }
    | SAVE DOUBLECOLON sel = savedEntityList { $node = new SaveStmtEntityList($sel.node); }
    ;

savedEntityList returns [SavedEntityListNode node]
    : se = savedEntity { $node = new SavedEntityListSingle($se.node); }
    | se = savedEntity selt = savedEntityListTail { $node = new SavedEntityListMultiple($se.node, $selt.node); }
    ;

savedEntityListTail returns [SavedEntityListTailNode node]
    : se = savedEntity { $node = new SavedEntityListTailSingle($se.node); }
    | se = savedEntity selt = savedEntityListTail { $node = new SavedEntityListTailMultiple($se.node, $selt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

savedEntity returns [SavedEntityNode node]
    : vn = variableName { $node = new SavedEntityVariableName($vn.node); }
    | scb = savedCommonBlock { $node = new SavedEntityCommonBlock($scb.node); }
    ;

savedCommonBlock returns [SavedCommonBlockNode node]
    : DIV cbn = commonBlockName DIV { $node = new SavedCommonBlock($cbn.node); }
    ;

intrinsicStmt returns [IntrinsicStmtNode node]
    : INTRINSIC il = intrinsicList { $node = new IntrinsicStmt($il.node); }
    ;

intrinsicList returns [IntrinsicListNode node]
    : ipn = intrinsicProcedureName { $node = new IntrinsicListSingle($ipn.node); }
    | ipn = intrinsicProcedureName ilt = intrinsicListTail { $node = new IntrinsicListMultiple($ipn.node, $ilt.node); }
    ;

intrinsicListTail returns [IntrinsicListTailNode node]
    : ipn = intrinsicProcedureName { $node = new IntrinsicListTailSingle($ipn.node); }
    | ipn = intrinsicProcedureName ilt = intrinsicListTail { $node = new IntrinsicListTailMultiple($ipn.node, $ilt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

intrinsicProcedureName returns [IntrinsicProcedureNameNode node]
    : NAME { $node = new IntrinsicProcedureName($NAME.text); }
    ;

externalStmt returns [ExternalStmtNode node]
    : EXTERNAL enl = externalNameList { $node = new ExternalStmt($enl.node); }
    ;

externalNameList returns [ExternalNameListNode node]
    : en = externalName { $node = new ExternalNameListSingle($en.node); }
    | en = externalName enlt = externalNameListTail { $node = new ExternalNameListMultiple($en.node, $enlt.node); }
    ;

externalNameListTail returns [ExternalNameListTailNode node]
    : en = externalName { $node = new ExternalNameListTailSingle($en.node); }
    | en = externalName enlt = externalNameListTail { $node = new ExternalNameListTailMultiple($en.node, $enlt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

externalName returns [ExternalNameNode node]
    : NAME { $node = new ExternalName($NAME.text); }
    ;

equivalenceStmt returns [EquivalenceStmtNode node]
    : EQUIVALENCE esl = equivalenceSetList { $node = new EquivalenceStmt($esl.node); }
    ;

equivalenceSetList returns [EquivalenceSetListNode node]
    : es = equivalenceSet { $node = new EquivalenceSetListSingle($es.node); }
    | es = equivalenceSet eslt = equivalenceSetListTail { $node = new EquivalenceSetListMultiple($es.node, $eslt.node); }
    ;

equivalenceSetListTail returns [EquivalenceSetListTailNode node]
    : es = equivalenceSet { $node = new EquivalenceSetListTailSingle($es.node); }
    | es = equivalenceSet eslt = equivalenceSetListTail { $node = new EquivalenceSetListTailMultiple($es.node, $eslt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

equivalenceSet returns [EquivalenceSetNode node]
    : LPAREN eo = equivalenceObject COMMA eol = equivalenceObjectList RPAREN { $node = new EquivalenceSet($eo.node, $eol.node); }
    ;

equivalenceObject returns [EquivalenceObjectNode node]
    : v = variable { $node = new EquivalenceObject($v.node); }
    ;

equivalenceObjectList returns [EquivalenceObjectListNode node]
    : eo = equivalenceObject { $node = new EquivalenceObjectListSingle($eo.node); }
    | eo = equivalenceObject eolt = equivalenceObjectListTail { $node = new EquivalenceObjectListMultiple($eo.node, $eolt.node); }
    ;

equivalenceObjectListTail returns [EquivalenceObjectListTailNode node]
    : eo = equivalenceObject { $node = new EquivalenceObjectListTailSingle($eo.node); }
    | eo = equivalenceObject eolt = equivalenceObjectListTail { $node = new EquivalenceObjectListTailMultiple($eo.node, $eolt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

dimensionStmt returns [DimensionStmtNode node]
    : DIMENSION adl = arrayDeclaratorList { $node = new DimensionStmt($adl.node); }
    | DIMENSION DOUBLECOLON adl = arrayDeclaratorList { $node = new DimensionStmt($adl.node); }
    ;

arrayDeclaratorList returns [ArrayDeclaratorListNode node]
    : ad = arrayDeclarator adlt = arrayDeclaratorListTail { $node = new ArrayDeclaratorList($ad.node, $adlt.node); }
    ;

arrayDeclaratorListTail returns [ArrayDeclaratorListTailNode node]
    : ad = arrayDeclarator { $node = new ArrayDeclaratorListTailSingle($ad.node); }
    | ad = arrayDeclarator adlt = arrayDeclaratorListTail { $node = new ArrayDeclaratorListTailMultiple($ad.node, $adlt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

commonStmt returns [CommonStmtNode node]
    : COMMON cl = comlist { $node = new CommonStmt($cl.node); }
    ;

comlist returns [ComlistNode node]
    : cb = comblock cbo = commonBlockObject { $node = new ComlistBlockObject($cb.node, $cbo.node); }
    | cbo = commonBlockObject { $node = new ComlistObject($cbo.node); }
    // Add other variations of comlist
    ;

commonBlockObject returns [CommonBlockObjectNode node]
    : vn = variableName { $node = new CommonBlockObjectVariable($vn.node); }
    | ad = arrayDeclarator { $node = new CommonBlockObjectArray($ad.node); }
    ;

arrayDeclarator returns [ArrayDeclaratorNode node]
    : vn = variableName LPAREN as = arraySpec RPAREN { $node = new ArrayDeclarator($vn.node, $as.node); }
    ;

comblock returns [ComblockNode node]
    : DIV SPOFF DIV SPON { $node = new ComblockEmpty(); }
    | DIV cbn = commonBlockName DIV { $node = new ComblockName($cbn.node); }
    ;

commonBlockName returns [CommonBlockNameNode node]
    : NAME { $node = new CommonBlockName($NAME.text); }
    ;

typeDeclarationStmt returns [TypeDeclarationStmtNode node]
    : ts = typeSpec edl = entityDeclList { $node = new TypeDeclarationStmt($ts.node, $edl.node); }
    // Add other variations of typeDeclarationStmt
    ;

attrSpecSeq returns [AttrSpecSeqNode node]
    : COMMA as = attrSpec { $node = new AttrSpecSeqSingle($as.node); }
    | ass = attrSpecSeq COMMA as = attrSpec { $node = new AttrSpecSeqMultiple($ass.node, $as.node); }
    ;

attrSpec returns [AttrSpecNode node]
    : PARAMETER { $node = new AttrSpecParameter(); }
    | ACCESSSPEC { $node = new AttrSpecAccessSpec(); }
    // Add other variations of attrSpec
    ;

entityDeclList returns [EntityDeclListNode node]
    : ed = entityDecl { $node = new EntityDeclListSingle($ed.node); }
    | ed = entityDecl edlt = entityDeclListTail { $node = new EntityDeclListMultiple($ed.node, $edlt.node); }
    ;

entityDeclListTail returns [EntityDeclListTailNode node]
    : COMMA ed = entityDecl { $node = new EntityDeclListTailSingle($ed.node); }
    | COMMA ed = entityDecl edlt = entityDeclListTail { $node = new EntityDeclListTailMultiple($ed.node, $edlt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

entityDecl returns [EntityDeclNode node]
    : on = objectName { $node = new EntityDeclName($on.node); }
    // Add other variations of entityDecl
    ;

objectName returns [ObjectNameNode node]
    : NAME { $node = new ObjectName($NAME.text); }
    ;

arraySpec returns [ArraySpecNode node]
    : essl = explicitShapeSpecList { $node = new ArraySpecExplicit($essl.node); }
    // Add other variations of arraySpec
    ;

assumedShapeSpecList returns [AssumedShapeSpecListNode node]
    : lb = lowerBound COLON { $node = new AssumedShapeSpecListSingle($lb.node); }
    | dssl = deferredShapeSpecList COMMA lb = lowerBound COLON { $node = new AssumedShapeSpecListMultiple($dssl.node, $lb.node); }
    | assl = assumedShapeSpecList COMMA ass = assumedShapeSpec { $node = new AssumedShapeSpecListMultiple($assl.node, $ass.node); }
    ;

assumedShapeSpec returns [AssumedShapeSpecNode node]
    : lb = lowerBound COLON { $node = new AssumedShapeSpec($lb.node); }
    | COLON { $node = new AssumedShapeSpecEmpty(); }
    ;

assumedSizeSpec returns [AssumedSizeSpecNode node]
    : STAR { $node = new AssumedSizeSpecStar(); }
    | lb = lowerBound COLON STAR { $node = new AssumedSizeSpecLowerBoundStar($lb.node); }
    | essl = explicitShapeSpecList COMMA STAR { $node = new AssumedSizeSpecListStar($essl.node); }
    | essl = explicitShapeSpecList COMMA lb = lowerBound COLON STAR { $node = new AssumedSizeSpecListLowerBoundStar($essl.node, $lb.node); }
    ;

interfaceBlock returns [InterfaceBlockNode node]
    : is = interfaceStmt ibb = interfaceBlockBody eis = endInterfaceStmt { $node = new InterfaceBlock($is.node, $ibb.node, $eis.node); }
    ;

endInterfaceStmt returns [EndInterfaceStmtNode node]
    : ENDINTERFACE { $node = new EndInterfaceStmt(); }
    | END INTERFACE { $node = new EndInterfaceStmt(); }
    | ENDINTERFACE NAME { $node = new EndInterfaceStmt($NAME.text); }
    | END INTERFACE NAME { $node = new EndInterfaceStmt($NAME.text); }
    ;

interfaceStmt returns [InterfaceStmtNode node]
    : INTERFACE NAME { $node = new InterfaceStmtName($NAME.text); }
    | INTERFACE gs = genericSpec { $node = new InterfaceStmtGeneric($gs.node); }
    | INTERFACE { $node = new InterfaceStmt(); }
    ;

genericSpec returns [GenericSpecNode node]
    : OPERATOR LPAREN dop = definedOperator RPAREN { $node = new GenericSpecOperator($dop.node); }
    | ASSIGNMENT LPAREN ASSIGN RPAREN { $node = new GenericSpecAssignment(); }
    ;

definedOperator returns [DefinedOperatorNode node]
    : DOP { $node = new DefinedOperatorDop($DOP.text); }
    | POWER { $node = new DefinedOperatorPower(); }
    | STAR { $node = new DefinedOperatorStar(); }
    // Add other variations of definedOperator
    ;

interfaceBlockBody returns [InterfaceBlockBodyNode node]
    : ibpc = interfaceBodyPartConstruct { $node = new InterfaceBlockBodySingle($ibpc.node); }
    | ibb = interfaceBlockBody ibpc = interfaceBodyPartConstruct { $node = new InterfaceBlockBodyMultiple($ibb.node, $ibpc.node); }
    ;

interfaceBodyPartConstruct returns [InterfaceBodyPartConstructNode node]
    : ib = interfaceBody { $node = new InterfaceBodyPartConstructInterfaceBody($ib.node); }
    | mps = moduleProcedureStmt { $node = new InterfaceBodyPartConstructModuleProcedure($mps.node); }
    ;

moduleProcedureStmt returns [ModuleProcedureStmtNode node]
    : MODULE PROCEDURE pnl = procedureNameList { $node = new ModuleProcedureStmt($pnl.node); }
    ;

procedureNameList returns [ProcedureNameListNode node]
    : pn = procedureName { $node = new ProcedureNameListSingle($pn.node); }
    | pn = procedureName pntl = procedureNameListTail { $node = new ProcedureNameListMultiple($pn.node, $pntl.node); }
    ;

procedureNameListTail returns [ProcedureNameListTailNode node]
    : COMMA pn = procedureName { $node = new ProcedureNameListTailSingle($pn.node); }
    | COMMA pn = procedureName pntl = procedureNameListTail { $node = new ProcedureNameListTailMultiple($pn.node, $pntl.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

procedureName returns [ProcedureNameNode node]
    : id = ident { $node = new ProcedureName($id.node); }
    ;

interfaceBody returns [InterfaceBodyNode node]
    : fp = functionPrefix NAME fir = functionInterfaceRange { $node = new InterfaceBodyFunction($fp.node, $NAME.text, $fir.node); }
    | SUBROUTINE NAME sir = subroutineInterfaceRange { $node = new InterfaceBodySubroutine($NAME.text, $sir.node); }
    ;

subroutineInterfaceRange returns [SubroutineInterfaceRangeNode node]
    : spl = subroutineParList sib = subprogramInterfaceBody es = endSubroutineStmt { $node = new SubroutineInterfaceRange($spl.node, $sib.node, $es.node); }
    | spl = subroutineParList es = endSubroutineStmt { $node = new SubroutineInterfaceRange($spl.node, null, $es.node); }
    ;


endSubroutineStmt returns [EndSubroutineStmtNode node]
    : END { $node = new EndSubroutineStmt(); }
    | END SUBROUTINE { $node = new EndSubroutineStmt(); }
    | END SUBROUTINE NAME { $node = new EndSubroutineStmt($NAME.text); }
    ;

recursive returns [RecursiveNode node]
    : RECURSIVE { $node = new Recursive(); }
    ;

functionPrefix returns [FunctionPrefixNode node]
    : rec = recursive ts = typeSpec FUNCTION { $node = new FunctionPrefixRecursiveTypeSpec($rec.node, $ts.node); }
    | ts = typeSpec rec = RECURSIVE FUNCTION { $node = new FunctionPrefixTypeSpecRecursive($ts.node); }
    | rec = recursive FUNCTION { $node = new FunctionPrefixRecursive($rec.node); }
    | ts = typeSpec FUNCTION { $node = new FunctionPrefixTypeSpec($ts.node); }
    ;

functionInterfaceRange returns [FunctionInterfaceRangeNode node]
    : fpl = functionParList sib = subprogramInterfaceBody efs = endFunctionStmt { $node = new FunctionInterfaceRange($fpl.node, $sib.node, $efs.node); }
    | fpl = functionParList efs = endFunctionStmt { $node = new FunctionInterfaceRange($fpl.node, null, $efs.node); }
    ;

functionParList returns [FunctionParListNode node]
    : LPAREN fps = functionPars RPAREN { $node = new FunctionParList($fps.node); }
    | LPAREN RPAREN { $node = new FunctionParListEmpty(); }
    ;

functionPars returns [FunctionParsNode node]
    : fp = functionPar { $node = new FunctionParsSingle($fp.node); }
    | fp = functionPar fpt = functionParsTail { $node = new FunctionParsMultiple($fp.node, $fpt.node); }
    ;

functionParsTail returns [FunctionParsTailNode node]
    : COMMA fp = functionPar { $node = new FunctionParsTailSingle($fp.node); }
    | COMMA fp = functionPar fpt = functionParsTail { $node = new FunctionParsTailMultiple($fp.node, $fpt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

functionPar returns [FunctionParNode node]
    : dan = dummyArgName { $node = new FunctionPar($dan.node); }
    ;

subprogramInterfaceBody returns [SubprogramInterfaceBodyNode node]
    : spc = specificationPartConstruct { $node = new SubprogramInterfaceBodySingle($spc.node); }
    | sib = subprogramInterfaceBody spc = specificationPartConstruct { $node = new SubprogramInterfaceBodyMultiple($sib.node, $spc.node); }
    ;

endFunctionStmt returns [EndFunctionStmtNode node]
    : END { $node = new EndFunctionStmt(); }
    | END FUNCTION { $node = new EndFunctionStmt(); }
    | END FUNCTION NAME { $node = new EndFunctionStmt($NAME.text); }
    ;

derivedTypeDef returns [DerivedTypeDefNode node]
    : dts = derivedTypeStmt dtb = derivedTypeBody ets = endTypeStmt { $node = new DerivedTypeDef($dts.node, $dtb.node, $ets.node); }
    ;

endTypeStmt returns [EndTypeStmtNode node]
    : ENDTYPE NAME { $node = new EndTypeStmt($NAME.text); }
    | ENDTYPE { $node = new EndTypeStmt(); }
    | END TYPE NAME { $node = new EndTypeStmt($NAME.text); }
    | END TYPE { $node = new EndTypeStmt(); }
    ;

derivedTypeStmt returns [DerivedTypeStmtNode node]
    : TYPE NAME { $node = new DerivedTypeStmtName($NAME.text); }
    | TYPE DOUBLECOLON NAME { $node = new DerivedTypeStmtDoubleColon($NAME.text); }
    | TYPE COMMA ACCESSSPEC DOUBLECOLON NAME { $node = new DerivedTypeStmtAccessSpec($NAME.text); }
    ;

derivedTypeBody returns [DerivedTypeBodyNode node]
    : dtbc = derivedTypeBodyConstruct { $node = new DerivedTypeBodySingle($dtbc.node); }
    | dtb = derivedTypeBody dtbc = derivedTypeBodyConstruct { $node = new DerivedTypeBodyMultiple($dtb.node, $dtbc.node); }
    ;

derivedTypeBodyConstruct returns [DerivedTypeBodyConstructNode node]
    : pss = privateSequenceStmt { $node = new DerivedTypeBodyConstructPrivateSequence($pss.node); }
    | cds = componentDefStmt { $node = new DerivedTypeBodyConstructComponentDef($cds.node); }
    ;

privateSequenceStmt returns [PrivateSequenceStmtNode node]
    : PRIVATE { $node = new PrivateSequenceStmtPrivate(); }
    | SEQUENCE { $node = new PrivateSequenceStmtSequence(); }
    ;

componentDefStmt returns [ComponentDefStmtNode node]
    : ts = typeSpec COMMA casl = componentAttrSpecList DOUBLECOLON cdl = componentDeclList { $node = new ComponentDefStmtAttrSpecList($ts.node, $casl.node, $cdl.node); }
    | ts = typeSpec DOUBLECOLON cdl = componentDeclList { $node = new ComponentDefStmtDoubleColon($ts.node, $cdl.node); }
    | ts = typeSpec cdl = componentDeclList { $node = new ComponentDefStmt($ts.node, $cdl.node); }
    ;

componentDeclList returns [ComponentDeclListNode node]
    : cd = componentDecl { $node = new ComponentDeclListSingle($cd.node); }
    | cd = componentDecl cdt = componentDeclListTail { $node = new ComponentDeclListMultiple($cd.node, $cdt.node); }
    ;

componentDeclListTail returns [ComponentDeclListTailNode node]
    : COMMA cd = componentDecl { $node = new ComponentDeclListTailSingle($cd.node); }
    | COMMA cd = componentDecl cdt = componentDeclListTail { $node = new ComponentDeclListTailMultiple($cd.node, $cdt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

componentDecl returns [ComponentDeclNode node]
    : cn = componentName LPAREN cas = componentArraySpec RPAREN STAR cl = charLength { $node = new ComponentDeclArrayCharLength($cn.node, $cas.node, $cl.node); }
    // Add other variations of componentDecl
    ;

componentName returns [ComponentNameNode node]
    : NAME { $node = new ComponentName($NAME.text); }
    ;

componentAttrSpecList returns [ComponentAttrSpecListNode node]
    : cas = componentAttrSpec { $node = new ComponentAttrSpecListSingle($cas.node); }
    | casl = componentAttrSpecListTail COMMA cas = componentAttrSpec { $node = new ComponentAttrSpecListMultiple($casl.node, $cas.node); }
    ;

componentAttrSpecListTail returns [ComponentAttrSpecListTailNode node]
    : COMMA cas = componentAttrSpec { $node = new ComponentAttrSpecListTailSingle($cas.node); }
    | casl = componentAttrSpecListTail COMMA cas = componentAttrSpec { $node = new ComponentAttrSpecListTailMultiple($casl.node, $cas.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

componentAttrSpec returns [ComponentAttrSpecNode node]
    : POINTER { $node = new ComponentAttrSpecPointer(); }
    | DIMENSION LPAREN cas = componentArraySpec RPAREN { $node = new ComponentAttrSpecDimension($cas.node); }
    ;

componentArraySpec returns [ComponentArraySpecNode node]
    : essl = explicitShapeSpecList { $node = new ComponentArraySpecExplicit($essl.node); }
    | dssl = deferredShapeSpecList { $node = new ComponentArraySpecDeferred($dssl.node); }
    ;

explicitShapeSpecList returns [ExplicitShapeSpecListNode node]
    : ess = explicitShapeSpec { $node = new ExplicitShapeSpecListSingle($ess.node); }
    | ess = explicitShapeSpec esslt = explicitShapeSpecListTail { $node = new ExplicitShapeSpecListMultiple($ess.node, $esslt.node); }
    ;

explicitShapeSpecListTail returns [ExplicitShapeSpecListTailNode node]
    : COMMA ess = explicitShapeSpec { $node = new ExplicitShapeSpecListTailSingle($ess.node); }
    | COMMA ess = explicitShapeSpec esslt = explicitShapeSpecListTail { $node = new ExplicitShapeSpecListTailMultiple($ess.node, $esslt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

explicitShapeSpec returns [ExplicitShapeSpecNode node]
    : lb = lowerBound COLON ub = upperBound { $node = new ExplicitShapeSpecRange($lb.node, $ub.node); }
    | ub = upperBound { $node = new ExplicitShapeSpecUpper($ub.node); }
    ;

lowerBound returns [LowerBoundNode node]
    : expr = expression { $node = new LowerBound($expr.node); }
    ;

upperBound returns [UpperBoundNode node]
    : expr = expression { $node = new UpperBound($expr.node); }
    ;

deferredShapeSpecList returns [DeferredShapeSpecListNode node]
    : dss = deferredShapeSpec { $node = new DeferredShapeSpecListSingle($dss.node); }
    | dss = deferredShapeSpec dsslt = deferredShapeSpecListTail { $node = new DeferredShapeSpecListMultiple($dss.node, $dsslt.node); }
    ;

deferredShapeSpecListTail returns [DeferredShapeSpecListTailNode node]
    : COMMA dss = deferredShapeSpec { $node = new DeferredShapeSpecListTailSingle($dss.node); }
    | COMMA dss = deferredShapeSpec dsslt = deferredShapeSpecListTail { $node = new DeferredShapeSpecListTailMultiple($dss.node, $dsslt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

deferredShapeSpec returns [DeferredShapeSpecNode node]
    : COLON { $node = new DeferredShapeSpec(); }
    ;

typeSpec returns [TypeSpecNode node]
    : INTEGER { $node = new TypeSpecInteger(); }
    | REAL { $node = new TypeSpecReal(); }
    | DOUBLEPRECISION { $node = new TypeSpecDoublePrecision(); }
    // Add other variations of typeSpec
    ;

kindSelector returns [KindSelectorNode node]
    : LPAREN KIND ASSIGN expr = expression RPAREN { $node = new KindSelectorKind($expr.node); }
    | LPAREN expr = expression RPAREN { $node = new KindSelectorExpression($expr.node); }
    ;

typeName returns [TypeNameNode node]
    : id = ident { $node = new TypeName($id.node); }
    ;

charSelector returns [CharSelectorNode node]
    : LPAREN LEN ASSIGN tpv = typeParamValue COMMA KIND ASSIGN expr = expression RPAREN { $node = new CharSelectorLenKind($tpv.node, $expr.node); }
    // Add other variations of charSelector
    ;

lengthSelector returns [LengthSelectorNode node]
    : STAR cl = charLength { $node = new LengthSelectorCharLength($cl.node); }
    | LPAREN tpv = typeParamValue RPAREN { $node = new LengthSelectorTypeParam($tpv.node); }
    ;

charLength returns [CharLengthNode node]
    : LPAREN tpv = typeParamValue RPAREN { $node = new CharLengthTypeParam($tpv.node); }
    | const = constant { $node = new CharLengthConstant($const.node); }
    ;

constant returns [ConstantNode node]
    : namedConstantUse { $node = new ConstantNamedConstantUse(); }
    | uacws = unsignedArithmeticConstantWithSign { $node = new ConstantUnsignedArithmeticWithSign($uacws.node); }
    | SCON { $node = new ConstantString($SCON.text); }
    | HOLLERITH { $node = new ConstantHollerith($HOLLERITH.text); }
    | logicalConstant { $node = new ConstantLogical(); }
    | ICON UNDERSCORE SCON { $node = new ConstantIconUnderscoreScon(); }
    | namedConstantUse UNDERSCORE SCON { $node = new ConstantNamedConstantUseUnderscoreScon(); }
    | structureConstructor { $node = new ConstantStructureConstructor(); }
    | bozLiteralConstant { $node = new ConstantBozLiteral(); }
    ;

unsignedArithmeticConstantWithSign returns [UnsignedArithmeticConstantWithSignNode node]
    : (PLUS | MINUS) uac = unsignedArithmeticConstant { $node = new UnsignedArithmeticConstantWithSign($uac.node); }
    | uac = unsignedArithmeticConstant { $node = new UnsignedArithmeticConstant($uac.node); }
    ;

bozLiteralConstant returns [BozLiteralConstantNode node]
    : BCON | OCON | ZCON;

structureConstructor returns [StructureConstructorNode node]
    : tn = typeName LPAREN el = exprList RPAREN { $node = new StructureConstructor($tn.node, $el.node); }
    ;

exprList returns [ExprListNode node]
    : expr = expression { $node = new ExprListSingle($expr.node); }
    | expr = expression COMMA el = exprList { $node = new ExprListMultiple($expr.node, $el.node); }
    ;

namedConstantUse returns [NamedConstantUseNode node]
    : NAME { $node = new NamedConstantUse($NAME.text); }
    ;

typeParamValue returns [TypeParamValueNode node]
    : expr = expression { $node = new TypeParamValueExpression($expr.node); }
    | STAR { $node = new TypeParamValueStar(); }
    ;

moduleStmt returns [ModuleStmtNode node]
    : MODULE mn = moduleName { $node = new ModuleStmt($mn.node); }
    ;

moduleName returns [ModuleNameNode node]
    : id = ident { $node = new ModuleName($id.node); }
    ;

ident returns [IdentNode node]
    : NAME { $node = new Ident($NAME.text); }
    ;

moduleBody returns [ModuleBodyNode node]
    : spc = specificationPartConstruct { $node = new ModuleBodySpecPartStmt($spc.node); }
    | mspc = moduleSubprogramPartConstruct { $node = new ModuleBodySubmoduleStmt($mspc.node); }
    | mb = moduleBody spc = specificationPartConstruct { $node = new ModuleBodyComplexSpecPart($mb.node, $spc.node); }
    | mb = moduleBody mspc = moduleSubprogramPartConstruct { $node = new ModuleBodyComplexSubmodule($mb.node, $mspc.node); }
    ;

moduleSubprogramPartConstruct returns [ModuleSubprogramPartConstructNode node]
    : cs = containsStmt { $node = new ModuleSubprogramPartConstructContains($cs.node); }
    | ms = moduleSubprogram { $node = new ModuleSubprogramPartConstructModuleSubprogram($ms.node); }
    ;

containsStmt returns [ContainsStmtNode node]
    : CONTAINS { $node = new ContainsStmt(); }
    ;

moduleSubprogram returns [ModuleSubprogramNode node]
    : fs = functionSubprogram { $node = new ModuleSubprogramFunction($fs.node); }
    | ss = subroutineSubprogram { $node = new ModuleSubprogramSubroutine($ss.node); }
    ;

functionSubprogram returns [FunctionSubprogramNode node]
    : fp = functionPrefix fn = functionName fr = functionRange { $node = new FunctionSubprogram($fp.node, $fn.node, $fr.node); }
    ;

functionName returns [FunctionNameNode node]
    : NAME { $node = new FunctionName($NAME.text); }
    ;

functionRange returns [FunctionRangeNode node]
    : fpl = functionParList bo = bodyOptional efs = endFunctionStmt { $node = new FunctionRange($fpl.node, $bo.node, $efs.node); }
    // Add other variations of functionRange
    ;

bodyOptional returns [BodyOptionalNode node]
    : body { $node = new BodyOptionalBody(); }
    | { $node = new NullNode(); } // For the empty case
    ;

body returns [BodyNode node]
    : bc = bodyConstruct { $node = new BodySingle($bc.node); }
    | bc = bodyConstruct bt = bodyTail { $node = new BodyMultiple($bc.node, $bt.node); }
    ;

bodyTail returns [BodyTailNode node]
    : bc = bodyConstruct { $node = new BodyTailSingle($bc.node); }
    | bc = bodyConstruct bt = bodyTail { $node = new BodyTailMultiple($bc.node, $bt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

bodyConstruct returns [BodyConstructNode node]
    : spc = specificationPartConstruct { $node = new BodyConstructSpecification($spc.node); }
    | ec = executableConstruct { $node = new BodyConstructExecutable($ec.node); }
    ;

executableConstruct returns [ExecutableConstructNode node]
    : as = actionStmt { $node = new ExecutableConstructAction($as.node); }
    | dc = doConstruct { $node = new ExecutableConstructDo($dc.node); }
    | ic = ifConstruct { $node = new ExecutableConstructIf($ic.node); }
    // Add other variations of executableConstruct
    ;

whereConstruct returns [WhereConstructNode node]
    : where { $node = new WhereConstructWhere($where.node); }
    | ew = elseWhere { $node = new WhereConstructElseWhere($ew.node); }
    ;

elseWhere returns [ElseWhereNode node]
    : where { $node = new ElseWhereWhere($where.node); }
    | ew = elsewhereStmt { $node = new ElseWhereElsewhereStmt($ew.node); }
    | ew = elseWhere as = assignmentStmt { $node = new ElseWhereAssignment($ew.node, $as.node); }
    ;

elsewhereStmt returns [ElsewhereStmtNode node]
    : ELSEWHERE { $node = new ElsewhereStmt(); }
    ;

endWhereStmt returns [EndWhereStmtNode node]
    : ENDWHERE { $node = new EndWhereStmt(); }
    | END WHERE { $node = new EndWhereStmt(); }
    ;
assignmentStmt returns [AssignmentStmtNode node]
    : lo = labelOptional NAME sfelro = sFExprListRefOptional ssro = substringRangeOptional ASSIGN expr = expression { $node = new AssignmentStmtLabelOptional($lo.node, $NAME.text, $sfelro.node, $ssro.node, $expr.node); }
    | NAME sfelro = sFExprListRefOptional PCT ndr = nameDataRef ASSIGN expr = expression { $node = new AssignmentStmtNameDataRef($NAME.text, $sfelro.node, $ndr.node, $expr.node); }
    | NAME LPAREN sfadnl = sFDummyArgNameList RPAREN PCT ndr = nameDataRef ASSIGN expr = expression { $node = new AssignmentStmtNameDataRefList($NAME.text, $sfadnl.node, $ndr.node, $expr.node); }
    ;
    sFDummyArgNameList returns [SFDummyArgNameListNode node]
    : | where as = assignmentStmt { $node = new WhereAssignmentStmt($where.node, $as.node); }

    ;
where returns [WhereNode node]
    : wcs = whereConstructStmt { $node = new WhereWhereConstructStmt($wcs.node); }
    | where as = assignmentStmt { $node = new WhereAssignmentStmt($where.node, $as.node); }
    ;

whereConstructStmt returns [WhereConstructStmtNode node]
    : WHERE LPAREN me = maskExpr RPAREN { $node = new WhereConstructStmt($me.node); }
    ;

maskExpr returns [MaskExprNode node]
    : expr = expression { $node = new MaskExpr($expr.node); }
    ;

caseConstruct returns [CaseConstructNode node]
    : NAME COLON SELECTCASE LPAREN expr = expression RPAREN scr = selectCaseRange { $node = new CaseConstructNameSelectCase($NAME.text, $expr.node, $scr.node); }
    // Add other variations of caseConstruct
    ;

selectCaseRange returns [SelectCaseRangeNode node]
    : scb = selectCaseBody ess = endSelectStmt { $node = new SelectCaseRange($scb.node, $ess.node); }
    | ess = endSelectStmt { $node = new SelectCaseRangeEmpty($ess.node); }
    ;

endSelectStmt returns [EndSelectStmtNode node]
    : ENDSELECT on = optionalName { $node = new EndSelectStmt($on.node); }
    | END SELECT on = optionalName { $node = new EndSelectStmt($on.node); }
    ;

optionalName returns [OptionalNameNode node]
    : NAME { $node = new OptionalName($NAME.text); }
    | { $node = new NullNode(); } // For the empty case
    ;

selectCaseBody returns [SelectCaseBodyNode node]
    : cs = caseStmt { $node = new SelectCaseBodyCaseStmt($cs.node); }
    | scb = selectCaseBody cbc = caseBodyConstruct { $node = new SelectCaseBodyMultiple($scb.node, $cbc.node); }
    ;

caseBodyConstruct returns [CaseBodyConstructNode node]
    : cs = caseStmt { $node = new CaseBodyConstructCaseStmt($cs.node); }
    | ep = executionPartConstruct { $node = new CaseBodyConstructExecutionPart($ep.node); }
    ;

caseStmt returns [CaseStmtNode node]
    : CASE cs = caseSelector { $node = new CaseStmt($cs.node); }
    | CASE cs = caseSelector NAME { $node = new CaseStmtName($cs.node, $NAME.text); }
    ;

caseSelector returns [CaseSelectorNode node]
    : LPAREN cvrl = caseValueRangeList RPAREN { $node = new CaseSelector($cvrl.node); }
    | DEFAULT { $node = new CaseSelectorDefault(); }
    ;

caseValueRangeList returns [CaseValueRangeListNode node]
    : cvr = caseValueRange { $node = new CaseValueRangeListSingle($cvr.node); }
    | cvr = caseValueRange cvrlt = caseValueRangeListTail { $node = new CaseValueRangeListMultiple($cvr.node, $cvrlt.node); }
    ;

caseValueRangeListTail returns [CaseValueRangeListTailNode node]
    : cvr = caseValueRange { $node = new CaseValueRangeListTailSingle($cvr.node); }
    | cvr = caseValueRange cvrlt = caseValueRangeListTail { $node = new CaseValueRangeListTailMultiple($cvr.node, $cvrlt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

caseValueRange returns [CaseValueRangeNode node]
    : expr = expression { $node = new CaseValueRangeLiteral($expr.node); }
    // Add other variations of caseValueRange
    ;

ifThenStmt returns [IfThenStmtNode node]
    : IF LPAREN expr = expression RPAREN THEN { $node = new IfThenStmt($expr.node); }
    ;

conditionalBody returns [ConditionalBodyNode node]
    : epc = executionPartConstruct { $node = new ConditionalBodySingle($epc.node); }
    | epc = executionPartConstruct cbt = conditionalBodyTail { $node = new ConditionalBodyMultiple($epc.node, $cbt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

conditionalBodyTail returns [ConditionalBodyTailNode node]
    : epc = executionPartConstruct { $node = new ConditionalBodyTailSingle($epc.node); }
    | epc = executionPartConstruct cbt = conditionalBodyTail { $node = new ConditionalBodyTailMultiple($epc.node, $cbt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;
ifConstruct returns [IfConstructNode node]
    : its = ifThenStmt cb = conditionalBody eicl = elseIfConstructList eco = elseConstructOptional eis = endIfStmt { $node = new IfConstruct($its.node, $cb.node, $eicl.node, $eco.node, $eis.node); }
    ;
elseIfConstructList returns [ElseIfConstructListNode node]
    : eic = elseIfConstruct { $node = new ElseIfConstructListSingle($eic.node); }
    | eic = elseIfConstruct eicl = elseIfConstructList { $node = new ElseIfConstructListMultiple($eic.node, $eicl.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

elseConstructOptional returns [ElseConstructOptionalNode node]
    : ec = elseConstruct { $node = new ElseConstructOptional($ec.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

elseIfConstruct returns [ElseIfConstructNode node]
    : eis = elseIfStmt cb = conditionalBody { $node = new ElseIfConstruct($eis.node, $cb.node); }
    ;

elseIfStmt returns [ElseIfStmtNode node]
    : ELSEIF LPAREN expr = expression RPAREN THEN { $node = new ElseIfStmt($expr.node); }
    | ELSE IF LPAREN expr = expression RPAREN THEN { $node = new ElseIfStmt($expr.node); }
    ;

elseConstruct returns [ElseConstructNode node]
    : es = elseStmt { $node = new ElseConstruct($es.node); }
    ;

elseStmt returns [ElseStmtNode node]
    : ELSE { $node = new ElseStmt(); }
    ;

endIfStmt returns [EndIfStmtNode node]
    : ENDIF { $node = new EndIfStmt(); }
    | END IF { $node = new EndIfStmt(); }
    ;

doConstruct returns [DoConstructNode node]
    : lds = labelDoStmt { $node = new DoConstructLabelDo($lds.node); }
    | bdc = blockDoConstruct { $node = new DoConstructBlockDo($bdc.node); }
    ;

blockDoConstruct returns [BlockDoConstructNode node]
    : nco = nameColonOptional DO cloc = commaLoopControlOptional epc = executionPartConstructList eds = endDoStmt { $node = new BlockDoConstruct($nco.node, $cloc.node, $epc.node, $eds.node); }
    ;

nameColonOptional returns [NameColonOptionalNode node]
    : nc = nameColon { $node = new NameColonOptional($nc.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

commaLoopControlOptional returns [CommaLoopControlOptionalNode node]
    : clc = commaLoopControl { $node = new CommaLoopControlOptional($clc.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

executionPartConstructList returns [ExecutionPartConstructListNode node]
    : epc = executionPartConstruct { $node = new ExecutionPartConstructListSingle($epc.node); }
    | epc = executionPartConstruct epc = executionPartConstructList { $node = new ExecutionPartConstructListMultiple($epc.node, $epc.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

endDoStmt returns [EndDoStmtNode node]
    : ENDDO eno = endNameOptional { $node = new EndDoStmt($eno.node); }
    | END DO eno = endNameOptional { $node = new EndDoStmt($eno.node); }
    ;

endNameOptional returns [EndNameOptionalNode node]
    : en = endName { $node = new EndNameOptional($en.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

endName returns [EndNameNode node]
    : ident { $node = new EndName($ident.node); }
    ;

nameColon returns [NameColonNode node]
    : NAME COLON { $node = new NameColon($NAME.text); }
    ;

labelDoStmt returns [LabelDoStmtNode node]
    : DO dlr = doLblRef clc = commaLoopControl epc = executionPartConstructList dld = doLblDef dl = doLabelStmt { $node = new LabelDoStmt($dlr.node, $clc.node, $epc.node, $dld.node, $dl.node); }
    ;


doLblRef returns [DoLblRefNode node]
    : ICON { $node = new DoLblRef($ICON.text); }
    ;

doLblDef returns [DoLblDefNode node]
    : ICON { $node = new DoLblDef($ICON.text); }
    ;

doLabelStmt returns [DoLabelStmtNode node]
    : as = actionStmt { $node = new DoLabelStmt($as.node); }
    ;

executionPartConstruct returns [ExecutionPartConstructNode node]
    : ec = executableConstruct { $node = new ExecutionPartConstructExecutable($ec.node); }
    | fs = formatStmt { $node = new ExecutionPartConstructFormat($fs.node); }
    | ds = dataStmt { $node = new ExecutionPartConstructData($ds.node); }
    | es = entryStmt { $node = new ExecutionPartConstructEntry($es.node); }
    | dds = doubleDoStmt { $node = new ExecutionPartConstructDoubleDo($dds.node); }
    ;

doubleDoStmt returns [DoubleDoStmtNode node]
    : DO lr = lblRef clc = commaLoopControl { $node = new DoubleDoStmt($lr.node, $clc.node); }
    ;

dataStmt returns [DataStmtNode node]
    : DATA dss = dataStmtSet dsst = dataStmtSetList { $node = new DataStmt($dss.node, $dsst.node); }
    ;

dataStmtSetList returns [DataStmtSetListNode node]
    : dsss = dataStmtSetSeparator dss = dataStmtSet dsst = dataStmtSetList { $node = new DataStmtSetList($dsss.node, $dss.node, $dsst.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

dataStmtSetSeparator returns [DataStmtSetSeparatorNode node]
    : COMMA { $node = new DataStmtSetSeparator(); }
    | { $node = new NullNode(); } // For the empty case
    ;

dataStmtSet returns [DataStmtSetNode node]
    : dse1 = dataStmtObject dse2 = dataStmtValue { $node = new DataStmtSet($dse1.node, $dse2.node); }
    ;

dataStmtObjectListTail returns [DataStmtObjectListTailNode node]
    : COMMA dso = dataStmtObject dsot = dataStmtObjectListTail { $node = new DataStmtObjectListTail($dso.node, $dsot.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

dataStmtValueListTail returns [DataStmtValueListTailNode node]
    : COMMA dsv = dataStmtValue dsvt = dataStmtValueListTail { $node = new DataStmtValueListTail($dsv.node, $dsvt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

dataStmtValue returns [DataStmtValueNode node]
    : const = constant { $node = new DataStmtValueConstant($const.node); }
    | const = constant STAR const2 = constant { $node = new DataStmtValueConstantStar($const.node, $const2.node); }
    | ncu = namedConstantUse STAR const = constant { $node = new DataStmtValueNamedConstantUseStar($ncu.node, $const.node); }
    ;

dataStmtObject returns [DataStmtObjectNode node]
    : variable { $node = new DataStmtObjectVariable($variable.node); }
    | dataImpliedDo { $node = new DataStmtObjectDataImpliedDo($dataImpliedDo.node); }
    ;

variable returns [VariableNode node]
    : vn = variableName slro = subscriptListRefOptional sro = substringRangeOptional { $node = new Variable($vn.node, $slro.node, $sro.node); }
    ;

subscriptListRefOptional returns [SubscriptListRefOptionalNode node]
    : slr = subscriptListRef { $node = new SubscriptListRefOptional($slr.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

substringRangeOptional returns [SubstringRangeOptionalNode node]
    : sr = substringRange { $node = new SubstringRangeOptional($sr.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

subscriptListRef returns [SubscriptListRefNode node]
    : LPAREN sl = subscriptList RPAREN { $node = new SubscriptListRef($sl.node); }
    ;

subscriptList returns [SubscriptListNode node]
    : s = subscript { $node = new SubscriptListSingle($s.node); }
    | s = subscript slt = subscriptListTail { $node = new SubscriptListMultiple($s.node, $slt.node); }
    ;

subscriptListTail returns [SubscriptListTailNode node]
    : s = subscript { $node = new SubscriptListTailSingle($s.node); }
    | s = subscript slt = subscriptListTail { $node = new SubscriptListTailMultiple($s.node, $slt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

subscript returns [SubscriptNode node]
    : expr = expression { $node = new Subscript($expr.node); }
    ;
sectionSubscriptList returns [SectionSubscriptListNode node]
    : ss = sectionSubscript { $node = new SectionSubscriptListSingle($ss.node); }
    | ssl = sectionSubscriptList COMMA ss = sectionSubscript { $node = new SectionSubscriptListMultiple($ssl.node, $ss.node); }
    ;

sectionSubscript returns [SectionSubscriptNode node]
    : expr = expression stt = subscriptTripletTail { $node = new SectionSubscriptExprTripletTail($expr.node, $stt.node); }
    | stt = subscriptTripletTail { $node = new SectionSubscriptTripletTail($stt.node); }
    | expr = expression { $node = new SectionSubscriptExpr($expr.node); }
    ;

subscriptTripletTail returns [SubscriptTripletTailNode node]
    : COLON eo = expressionOptional { $node = new SubscriptTripletTailColonOptional($eo.node); }
    | COLON expr1 = expression COLON expr2 = expression { $node = new SubscriptTripletTailColonExprExpr($expr1.node, $expr2.node); }
    | DOUBLECOLON expr = expression { $node = new SubscriptTripletTailDoubleColonExpr($expr.node); }
    | COLON { $node = new SubscriptTripletTailColon(); }
    ;

expressionOptional returns [ExpressionOptionalNode node]
    : expr = expression { $node = new ExpressionOptional($expr.node); }
    | { $node = new NullNode(); } // For the empty case
    ;
substringRange returns [SubstringRangeNode node]
    : LPAREN eo = expressionOptional stt = subscriptTripletTail RPAREN { $node = new SubstringRange($eo.node, $stt.node); }
    ;


dataImpliedDo returns [DataImpliedDoNode node]
    : LPAREN dool = dataIDoObjectList COMMA iv = impliedDoVariable ASSIGN e1 = expression COMMA e2 = expression RPAREN { $node = new DataImpliedDo($dool.node, $iv.node, $e1.node, $e2.node); }
    | LPAREN dool = dataIDoObjectList COMMA iv = impliedDoVariable ASSIGN e1 = expression COMMA e2 = expression COMMA e3 = expression RPAREN { $node = new DataImpliedDoExtended($dool.node, $iv.node, $e1.node, $e2.node, $e3.node); }
    ;

dataIDoObjectList returns [DataIDoObjectListNode node]
    : dio = dataIDoObject { $node = new DataIDoObjectListSingle($dio.node); }
    | dio = dataIDoObject diolt = dataIDoObjectListTail { $node = new DataIDoObjectListMultiple($dio.node, $diolt.node); }
    ;

dataIDoObjectListTail returns [DataIDoObjectListTailNode node]
    : dio = dataIDoObject { $node = new DataIDoObjectListTailSingle($dio.node); }
    | dio = dataIDoObject diolt = dataIDoObjectListTail { $node = new DataIDoObjectListTailMultiple($dio.node, $diolt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

dataIDoObject returns [DataIDoObjectNode node]
    : ae = arrayElement { $node = new DataIDoObjectArrayElement($ae.node); }
    | dimpDo = dataImpliedDo { $node = new DataIDoObjectDataImpliedDo($dimpDo.node); }
    | sc = structureComponent { $node = new DataIDoObjectStructureComponent($sc.node); }
    ;

structureComponent returns [StructureComponentNode node]
    : vn = variableName fs = fieldSelector { $node = new StructureComponentVariableName($vn.node, $fs.node); }
    | sc = structureComponent fs = fieldSelector { $node = new StructureComponentStructureComponent($sc.node, $fs.node); }
    ;

fieldSelector returns [FieldSelectorNode node]
    : LPAREN ssl = sectionSubscriptList RPAREN PCT NAME { $node = new FieldSelectorSubscriptList($ssl.node, $NAME.text); }
    | PCT NAME { $node = new FieldSelectorName($NAME.text); }
    ;

arrayElement returns [ArrayElementNode node]
    : vn = variableName LPAREN ssl = sectionSubscriptList RPAREN { $node = new ArrayElementVariableName($vn.node, $ssl.node); }
    | sc = structureComponent LPAREN ssl = sectionSubscriptList RPAREN { $node = new ArrayElementStructureComponent($sc.node, $ssl.node); }
    ;

impliedDoVariable returns [ImpliedDoVariableNode node]
    : NAME { $node = new ImpliedDoVariable($NAME.text); }
    ;

commaLoopControl returns [CommaLoopControlNode node]
    : co = commaOptional lc = loopControl { $node = new CommaLoopControl($co.node, $lc.node); }
    ;

commaOptional returns [CommaOptionalNode node]
    : COMMA { $node = new CommaOptional(); }
    | { $node = new NullNode(); } // For the empty case
    ;

loopControl returns [LoopControlNode node]
    : vn = variableName ASSIGN e1 = expression COMMA e2 = expression co = commaExprOptional { $node = new LoopControlVariableAssign($vn.node, $e1.node, $e2.node, $co.node); }
    | WHILE LPAREN expr = expression RPAREN { $node = new LoopControlWhile($expr.node); }
    ;

commaExprOptional returns [CommaExprOptionalNode node]
    : ce = commaExpr { $node = new CommaExprOptional($ce.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

variableName returns [VariableNameNode node]
    : NAME { $node = new VariableName($NAME.text); }
    ;

commaExpr returns [CommaExprNode node]
    : COMMA expr = expression { $node = new CommaExpr($expr.node); }
    ;

semicolonStmt returns [SemicolonStmtNode node]
    : SEMICOLON as = actionStmt { $node = new SemicolonStmt($as.node); }
    ;

actionStmt returns [ActionStmtNode node]
    : aif = arithmeticIfStmt { $node = new ActionStmtArithmeticIf($aif.node); }
    | as = assignmentStmt { $node = new ActionStmtAssignment($as.node); }
    | as = assignStmt { $node = new ActionStmtAssign($as.node); }
    | bs = backspaceStmt { $node = new ActionStmtBackspace($bs.node); }
    | cs = callStmt { $node = new ActionStmtCall($cs.node); }
    | cls = closeStmt { $node = new ActionStmtClose($cls.node); }
    | cs = continueStmt { $node = new ActionStmtContinue($cs.node); }
    | efs = endfileStmt { $node = new ActionStmtEndfile($efs.node); }
    | gts = gotoStmt { $node = new ActionStmtGoto($gts.node); }
    | cgs = computedGotoStmt { $node = new ActionStmtComputedGoto($cgs.node); }
    | ags = assignedGotoStmt { $node = new ActionStmtAssignedGoto($ags.node); }
    | ifs = ifStmt { $node = new ActionStmtIf($ifs.node); }
    | ins = inquireStmt { $node = new ActionStmtInquire($ins.node); }
    | os = openStmt { $node = new ActionStmtOpen($os.node); }
    | ps = pauseStmt { $node = new ActionStmtPause($ps.node); }
    | ps = printStmt { $node = new ActionStmtPrint($ps.node); }
    | ss = stopStmt { $node = new ActionStmtStop($ss.node); }
    | ws = writeStmt { $node = new ActionStmtWrite($ws.node); }
    | als = allocateStmt { $node = new ActionStmtAllocate($als.node); }
    | cys = cycleStmt { $node = new ActionStmtCycle($cys.node); }
    | dls = deallocateStmt { $node = new ActionStmtDeallocate($dls.node); }
    | exs = exitStmt { $node = new ActionStmtExit($exs.node); }
    | nus = nullifyStmt { $node = new ActionStmtNullify($nus.node); }
    | pas = pointerAssignmentStmt { $node = new ActionStmtPointerAssignment($pas.node); }
    | ws = whereStmt { $node = new ActionStmtWhere($ws.node); }
    | ss = semicolonStmt { $node = new ActionStmtSemicolon($ss.node); }
    ;

whereStmt returns [WhereStmtNode node]
    : WHERE LPAREN me = maskExpr RPAREN as = assignmentStmt { $node = new WhereStmt($me.node, $as.node); }
    ;

pointerAssignmentStmt returns [PointerAssignmentStmtNode node]
    : NAME IMPLIEDT t = target { $node = new PointerAssignmentStmtSingle($NAME.text, $t.node); }
    | NAME sfelro = sFExprListRefOptional PCT ndr = nameDataRef IMPLIEDT t = target { $node = new PointerAssignmentStmtComplex($NAME.text, $sfelro.node, $ndr.node, $t.node); }
    ;
sFExprListRef returns [SFExprListRefNode node]
    : LPAREN sfel = sFExprList cssl = expression RPAREN { $node = new SFExprListRef($sfel.node, $cssl.node); }
    ;

 sFExprList returns [SFExprListNode node]
    : expr1 = expression COLON expr2 = expression { $node = new SFExprListExprColonExpr($expr1.node, $expr2.node); }
    | expr = expression COLON { $node = new SFExprListExprColon($expr.node); }
    | expr = expression { $node = new SFExprListExpr($expr.node); }
    | COLON expr = expression { $node = new SFExprListColonExpr($expr.node); }
    | COLON { $node = new SFExprListColon(); }
    | expr1 = expression COLON expr2 = expression COLON expr3 = expression { $node = new SFExprListExprColonExprColonExpr($expr1.node, $expr2.node, $expr3.node); }
    | COLON expr1 = expression COLON expr2 = expression { $node = new SFExprListColonExprColonExpr($expr1.node, $expr2.node); }
    | DOUBLECOLON expr = expression { $node = new SFExprListDoubleColonExpr($expr.node); }
    | expr1 = expression DOUBLECOLON expr2 = expression { $node = new SFExprListExprDoubleColonExpr($expr1.node, $expr2.node); }
    ;
sFExprListRefOptional returns [SFExprListRefOptionalNode node]
    : sfelr = sFExprListRef { $node = new SFExprListRefOptional($sfelr.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

target returns [TargetNode node]
    : expr = expression { $node = new Target($expr.node); }
    ;

nullifyStmt returns [NullifyStmtNode node]
    : NULLIFY LPAREN pol = pointerObjectList RPAREN { $node = new NullifyStmt($pol.node); }
    ;

pointerObjectList returns [PointerObjectListNode node]
    : po = pointerObject { $node = new PointerObjectListSingle($po.node); }
    | po = pointerObject polt = pointerObjectListTail { $node = new PointerObjectListMultiple($po.node, $polt.node); }
    ;

pointerObjectListTail returns [PointerObjectListTailNode node]
    : COMMA po = pointerObject { $node = new PointerObjectListTailSingle($po.node); }
    | COMMA po = pointerObject polt = pointerObjectListTail { $node = new PointerObjectListTailMultiple($po.node, $polt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

pointerObject returns [PointerObjectNode node]
    : NAME { $node = new PointerObjectName($NAME.text); }
    | pf = pointerField { $node = new PointerObjectField($pf.node); }
    ;

pointerField returns [PointerFieldNode node]
    : NAME sfelro = sFExprListRefOptional PCT NAME { $node = new PointerFieldName($NAME.text, $sfelro.node, $NAME.text); }
    | pf = pointerField fs = fieldSelector { $node = new PointerFieldComplex($pf.node, $fs.node); }
    ;

exitStmt returns [ExitStmtNode node]
    : EXIT eno = endNameOptional { $node = new ExitStmt($eno.node); }
    ;
deallocateStmt returns [DeallocateStmtNode node]
    : DEALLOCATE LPAREN aol = allocateObjectList COMMA STAT ASSIGN v = variable RPAREN { $node = new DeallocateStmtWithStat($aol.node, $v.node); }
    | DEALLOCATE LPAREN aol = allocateObjectList RPAREN { $node = new DeallocateStmt($aol.node); }
    ;

allocateObjectList returns [AllocateObjectListNode node]
    : ao = allocateObject { $node = new AllocateObjectListSingle($ao.node); }
    | ao = allocateObject aolt = allocateObjectListTail { $node = new AllocateObjectListMultiple($ao.node, $aolt.node); }
    ;

allocateObjectListTail returns [AllocateObjectListTailNode node]
    : COMMA ao = allocateObject { $node = new AllocateObjectListTailSingle($ao.node); }
    | COMMA ao = allocateObject aolt = allocateObjectListTail { $node = new AllocateObjectListTailMultiple($ao.node, $aolt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

cycleStmt returns [CycleStmtNode node]
    : CYCLE eno = endNameOptional { $node = new CycleStmt($eno.node); }
    ;

allocateStmt returns [AllocateStmtNode node]
    : ALLOCATE LPAREN al = allocationList COMMA STAT ASSIGN v = variable RPAREN { $node = new AllocateStmtWithStat($al.node, $v.node); }
    | ALLOCATE LPAREN al = allocationList RPAREN { $node = new AllocateStmt($al.node); }
    ;

allocationList returns [AllocationListNode node]
    : a = allocation { $node = new AllocationListSingle($a.node); }
    | a = allocation alt = allocationListTail { $node = new AllocationListMultiple($a.node, $alt.node); }
    ;

allocationListTail returns [AllocationListTailNode node]
    : COMMA a = allocation { $node = new AllocationListTailSingle($a.node); }
    | COMMA a = allocation alt = allocationListTail { $node = new AllocationListTailMultiple($a.node, $alt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

allocation returns [AllocationNode node]
    : ao = allocateObject { $node = new AllocationAllocateObject($ao.node); }
    | ao = allocateObject as = allocatedShape { $node = new AllocationAllocateObjectWithShape($ao.node, $as.node); }
    ;

allocateObject returns [AllocateObjectNode node]
    : vn = variableName { $node = new AllocateObjectVariableName($vn.node); }
    | ao = allocateObject fs = fieldSelector { $node = new AllocateObjectFieldSelector($ao.node, $fs.node); }
    ;

allocatedShape returns [AllocatedShapeNode node]
    : LPAREN ssl = sectionSubscriptList RPAREN { $node = new AllocatedShape($ssl.node); }
    ;

stopStmt returns [StopStmtNode node]
    : STOP svo = stopValueOptional { $node = new StopStmt($svo.node); }
    ;

stopValueOptional returns [StopValueOptionalNode node]
    : ICON { $node = new StopValueOptionalIcon($ICON.text); }
    | SCON { $node = new StopValueOptionalString($SCON.text); }
    | { $node = new NullNode(); } // For the empty case
    ;

writeStmt returns [WriteStmtNode node]
    : WRITE LPAREN iocl = ioControlSpecList RPAREN oilo = outputItemListOptional { $node = new WriteStmt($iocl.node, $oilo.node); }
    ;

outputItemListOptional returns [OutputItemListOptionalNode node]
    : oil = outputItemList { $node = new OutputItemListOptional($oil.node); }
    | { $node = new NullNode(); } // For the empty case
    ;
ioControlSpec returns [IOControlSpecNode node]
    : FMT ASSIGN fi = formatIdentifier { $node = new IOControlSpecFmt($fi.node); }
    | UNIT ASSIGN ui = unitIdentifier { $node = new IOControlSpecUnit($ui.node); }
    | REC ASSIGN expr = expression { $node = new IOControlSpecRec($expr.node); }
    | END ASSIGN lr = lblRef { $node = new IOControlSpecEnd($lr.node); }
    | ERR ASSIGN lr = lblRef { $node = new IOControlSpecErr($lr.node); }
    | IOSTAT ASSIGN sv = scalarVariable { $node = new IOControlSpecIOStat($sv.node); }
    | NML ASSIGN ngn = namelistGroupName { $node = new IOControlSpecNml($ngn.node); }
    | ADVANCE ASSIGN cExpr = cExpression { $node = new IOControlSpecAdvance($cExpr.node); }
    | SIZE ASSIGN var = variable { $node = new IOControlSpecSize($var.node); }
    | EOR ASSIGN lr = lblRef { $node = new IOControlSpecEor($lr.node); }
    ;
ioControlSpecList returns [IOControlSpecListNode node]
    : ui = unitIdentifier DOLLAR COMMA { $node = new IOControlSpecListUnitIdentifier($ui.node); }
    | ui = unitIdentifier COMMA fi = formatIdentifier { $node = new IOControlSpecListFormatIdentifier($ui.node, $fi.node); }
    | ui = unitIdentifier COMMA iocs = ioControlSpec { $node = new IOControlSpecListUnitIdentifierIOControlSpec($ui.node, $iocs.node); }
    | iocs = ioControlSpec { $node = new IOControlSpecListIOControlSpec($iocs.node); }
    | iocsl = ioControlSpecList COMMA iocs = ioControlSpec { $node = new IOControlSpecListMultiple($iocsl.node, $iocs.node); }
    ;

printStmt returns [PrintStmtNode node]
    : PRINT fi = formatIdentifier COMMA oil = outputItemList { $node = new PrintStmtWithItemList($fi.node, $oil.node); }
    | PRINT fi = formatIdentifier { $node = new PrintStmtNoItemList($fi.node); }
    ;

outputItemList returns [OutputItemListNode node]
    : expr = expression { $node = new OutputItemListSingleExpression($expr.node); }
    | oil1 = outputItemList1 { $node = new OutputItemListComplex($oil1.node); }
    ;

outputItemList1 returns [OutputItemList1Node node]
    : expr1 = expression COMMA expr2 = expression { $node = new OutputItemList1TwoExpressions($expr1.node, $expr2.node); }
    | expr = expression COMMA oid = outputImpliedDo { $node = new OutputItemList1ExpressionImpliedDo($expr.node, $oid.node); }
    | oid = outputImpliedDo { $node = new OutputItemList1ImpliedDo($oid.node); }
    | oil1 = outputItemList1 COMMA expr = expression { $node = new OutputItemList1MultipleExpressions($oil1.node, $expr.node); }
    | oil1 = outputItemList1 COMMA oid = outputImpliedDo { $node = new OutputItemList1MultipleImpliedDo($oil1.node, $oid.node); }
    ;

outputImpliedDo returns [OutputImpliedDoNode node]
    : LPAREN expr = expression COMMA iv = impliedDoVariable ASSIGN e1 = expression COMMA e2 = expression ceo = commaExprOptional RPAREN { $node = new OutputImpliedDoSimple($expr.node, $iv.node, $e1.node, $e2.node, $ceo.node); }
    | LPAREN oil1 = outputItemList1 COMMA iv = impliedDoVariable ASSIGN e1 = expression COMMA e2 = expression ceo = commaExprOptional RPAREN { $node = new OutputImpliedDoComplex($oil1.node, $iv.node, $e1.node, $e2.node, $ceo.node); }
    ;

formatIdentifier returns [FormatIdentifierNode node]
    : lblRef { $node = new FormatIdentifierLabelRef($lblRef.node); }
    | cExpr = cExpression { $node = new FormatIdentifierCExpression($cExpr.node); }
    | STAR { $node = new FormatIdentifierStar(); }
    ;

pauseStmt returns [PauseStmtNode node]
    : PAUSE svo = stopValueOptional { $node = new PauseStmt($svo.node); }
    ;

openStmt returns [OpenStmtNode node]
    : OPEN LPAREN csl = connectSpecList RPAREN { $node = new OpenStmt($csl.node); }
    ;

connectSpecList returns [ConnectSpecListNode node]
    : uico = unitIdentifierCommaOptional cso = connectSpecOptional cslt = connectSpecListTail { $node = new ConnectSpecList($uico.node, $cso.node, $cslt.node); }
    ;
unitIdentifierComma returns [UnitIdentifierCommaNode node]
    : ui = unitIdentifier COMMA { $node = new UnitIdentifierComma($ui.node); }
    | ui = unitIdentifier { $node = new UnitIdentifierCommaSingle($ui.node); }
    ;
unitIdentifierCommaOptional returns [UnitIdentifierCommaOptionalNode node]
    : uic = unitIdentifierComma { $node = new UnitIdentifierCommaOptional($uic.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

connectSpecOptional returns [ConnectSpecOptionalNode node]
    : cs = connectSpec { $node = new ConnectSpecOptional($cs.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

connectSpecListTail returns [ConnectSpecListTailNode node]
    : COMMA cs = connectSpec { $node = new ConnectSpecListTailSingle($cs.node); }
    | COMMA cs = connectSpec cslt = connectSpecListTail { $node = new ConnectSpecListTailMultiple($cs.node, $cslt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

connectSpec returns [ConnectSpecNode node]
    : UNIT ASSIGN ui = unitIdentifier { $node = new ConnectSpecUnit($ui.node); }
    | ERR ASSIGN lbl = lblRef { $node = new ConnectSpecErr($lbl.node); }
    | FILE ASSIGN cExpr = cExpression { $node = new ConnectSpecFile($cExpr.node); }
    // Add other variations of connectSpec
    ;

inquireStmt returns [InquireStmtNode node]
    : INQUIRE LPAREN isl = inquireSpecList RPAREN { $node = new InquireStmtSpecList($isl.node); }
    | INQUIRE LPAREN IOLENGTH ASSIGN sv = scalarVariable RPAREN oil = outputItemList { $node = new InquireStmtIOLength($sv.node, $oil.node); }
    ;

inquireSpecList returns [InquireSpecListNode node]
    : uio = unitIdentifierOptional iso = inquireSpecOptional islt = inquireSpecListTail { $node = new InquireSpecList($uio.node, $iso.node, $islt.node); }
    ;

unitIdentifierOptional returns [UnitIdentifierOptionalNode node]
    : ui = unitIdentifier { $node = new UnitIdentifierOptional($ui.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

inquireSpecOptional returns [InquireSpecOptionalNode node]
    : is = inquireSpec { $node = new InquireSpecOptional($is.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

inquireSpecListTail returns [InquireSpecListTailNode node]
    : COMMA is = inquireSpec { $node = new InquireSpecListTailSingle($is.node); }
    | COMMA is = inquireSpec islt = inquireSpecListTail { $node = new InquireSpecListTailMultiple($is.node, $islt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

inquireSpec returns [InquireSpecNode node]
    : UNIT ASSIGN ui = unitIdentifier { $node = new InquireSpecUnit($ui.node); }
    // Define other variations of inquireSpec as per your CFG
    ;

assignedGotoStmt returns [AssignedGotoStmtNode node]
    : (GOTO | GO TO) vn = variableName { $node = new AssignedGotoStmtVariableName($vn.node); }
    | (GOTO | GO TO) vn = variableName LPAREN lrl = lblRefList RPAREN { $node = new AssignedGotoStmtVariableNameLblRefList($vn.node, $lrl.node); }
    | (GOTO | GO TO) vc = variableComma LPAREN lrl = lblRefList RPAREN { $node = new AssignedGotoStmtVariableCommaLblRefList($vc.node, $lrl.node); }
    ;

variableComma returns [VariableCommaNode node]
    : vn = variableName COMMA { $node = new VariableComma($vn.node); }
    ;

gotoStmt returns [GotoStmtNode node]
    : (GOTO | GO TO) lr = lblRef { $node = new GotoStmt($lr.node); }
    ;

computedGotoStmt returns [ComputedGotoStmtNode node]
    : GOTO LPAREN lrl = lblRefList RPAREN co = commaOptional expr = expression { $node = new ComputedGotoStmt($lrl.node, $co.node, $expr.node); }
    ;
lblRefList returns [LblRefListNode node]
    : lr = lblRef lrlt = lblRefListTail { $node = new LblRefList($lr.node, $lrlt.node); }
    ;

lblRefListTail returns [LblRefListTailNode node]
    : COMMA lr = lblRef { $node = new LblRefListTailSingle($lr.node); }
    | COMMA lr = lblRef lrlt = lblRefListTail { $node = new LblRefListTailMultiple($lr.node, $lrlt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

endfileStmt returns [EndfileStmtNode node]
    : (ENDFILE | END FILE) ui = unitIdentifier { $node = new EndfileStmtUnitIdentifier($ui.node); }
    | (ENDFILE | END FILE) LPAREN psl = positionSpecList RPAREN { $node = new EndfileStmtPositionSpecList($psl.node); }
    ;

continueStmt returns [ContinueStmtNode node]
    : CONTINUE { $node = new ContinueStmt(); }
    ;

closeStmt returns [CloseStmtNode node]
    : CLOSE LPAREN csl = closeSpecList RPAREN { $node = new CloseStmt($csl.node); }
    ;

closeSpecList returns [CloseSpecListNode node]
    : uico = unitIdentifierCommaOptional cso = closeSpecOptional cslt = closeSpecListTail { $node = new CloseSpecList($uico.node, $cso.node, $cslt.node); }
    ;

closeSpecOptional returns [CloseSpecOptionalNode node]
    : cs = closeSpec { $node = new CloseSpecOptional($cs.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

closeSpecListTail returns [CloseSpecListTailNode node]
    : COMMA cs = closeSpec { $node = new CloseSpecListTailSingle($cs.node); }
    | COMMA cs = closeSpec cslt = closeSpecListTail { $node = new CloseSpecListTailMultiple($cs.node, $cslt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

closeSpec returns [CloseSpecNode node]
    : UNIT ASSIGN ui = unitIdentifier { $node = new CloseSpecUnit($ui.node); }
    | ERR ASSIGN lr = lblRef { $node = new CloseSpecErr($lr.node); }
    | STATUS ASSIGN cExpr = cExpression { $node = new CloseSpecStatus($cExpr.node); }
    | IOSTAT sv = scalarVariable { $node = new CloseSpecIOStat($sv.node); }
    ;
cExpression returns [CExpressionNode node]
    : cp = cPrimary cpcol = cPrimaryConcatOpList { $node = new CExpression($cp.node, $cpcol.node); }
    ;

cPrimaryConcatOpList returns [CPrimaryConcatOpListNode node]
    : cpco = cPrimaryConcatOp { $node = new CPrimaryConcatOpListSingle($cpco.node); }
    | cpco = cPrimaryConcatOp cpcol = cPrimaryConcatOpList { $node = new CPrimaryConcatOpListMultiple($cpco.node, $cpcol.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

cPrimary returns [CPrimaryNode node]
    : cop = cOperand { $node = new CPrimaryOperand($cop.node); }
    | LPAREN cExpr = cExpression RPAREN { $node = new CPrimaryExpression($cExpr.node); }
    ;

cOperand returns [COperandNode node]
    : SCON { $node = new COperandString($SCON.text); }
    | ndr = nameDataRef { $node = new COperandNameDataRef($ndr.node); }
    | fr = functionReference { $node = new COperandFunctionReference($fr.node); }
    ;

cPrimaryConcatOp returns [CPrimaryConcatOpNode node]
    : cp = cPrimary DIV SPOFF DIV SPON { $node = new CPrimaryConcatOp($cp.node); }
    ;

callStmt returns [CallStmtNode node]
    : CALL snu = subroutineNameUse { $node = new CallStmtNoArgs($snu.node); }
    | CALL snu = subroutineNameUse LPAREN sal = subroutineArgList RPAREN { $node = new CallStmtWithArgs($snu.node, $sal.node); }
    ;

subroutineNameUse returns [SubroutineNameUseNode node]
    : NAME { $node = new SubroutineNameUse($NAME.text); }
    ;

subroutineArgList returns [SubroutineArgListNode node]
    : sao = subroutineArgOnly { $node = new SubroutineArgListSingle($sao.node); }
    | sawt = subroutineArgWithTail { $node = new SubroutineArgListMultiple($sawt.node); }
    ;

subroutineArg returns [SubroutineArgNode node]
    : expr = expression { $node = new SubroutineArgExpression($expr.node); }
    | HOLLERITH { $node = new SubroutineArgHollerith($HOLLERITH.text); }
    | STAR lr = lblRef { $node = new SubroutineArgLblRef($lr.node); }
    | NAME ASSIGN expr = expression { $node = new SubroutineArgNameAssignExpression($NAME.text, $expr.node); }
    | NAME ASSIGN HOLLERITH { $node = new SubroutineArgNameAssignHollerith($NAME.text, $HOLLERITH.text); }
    | NAME ASSIGN STAR lr = lblRef { $node = new SubroutineArgNameAssignLblRef($NAME.text, $lr.node); }
    ;

labelOptional returns [LabelOptionalNode node]
    : label { $node = new LabelOptional($label.node); }
    | { $node = new NullNode(); } // For the empty case
    ;


subroutineArgOnly returns [SubroutineArgOnlyNode node]
    : sa = subroutineArg { $node = new SubroutineArgOnly($sa.node); }
    ;

subroutineArgWithTail returns [SubroutineArgWithTailNode node]
    : sa = subroutineArg salt = subroutineArgListTail { $node = new SubroutineArgWithTail($sa.node, $salt.node); }
    ;

subroutineArgListTail returns [SubroutineArgListTailNode node]
    : COMMA sa = subroutineArg { $node = new SubroutineArgListTailSingle($sa.node); }
    | COMMA sa = subroutineArg salt = subroutineArgListTail { $node = new SubroutineArgListTailMultiple($sa.node, $salt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

arithmeticIfStmt returns [ArithmeticIfStmtNode node]
    : IF LPAREN expr = expression RPAREN lr1 = lblRef COMMA lr2 = lblRef COMMA lr3 = lblRef { $node = new ArithmeticIfStmt($expr.node, $lr1.node, $lr2.node, $lr3.node); }
    ;

lblRef returns [LblRefNode node]
    : label { $node = new LblRef($label.node); }
    ;

label returns [LabelNode node]
    : ICON { $node = new Label($ICON.text); }
    ;

assignStmt returns [AssignStmtNode node]
    : lo = labelOptional NAME sfelro = sFExprListRefOptional ssro = substringRangeOptional ASSIGN expr = expression { $node = new AssignStmt($lo.node, $NAME.text, $sfelro.node, $ssro.node, $expr.node); }
    // Add other variations of assignStmt
    ;

backspaceStmt returns [BackspaceStmtNode node]
    : BACKSPACE ui = unitIdentifier { $node = new BackspaceStmtUnitIdentifier($ui.node); }
    | BACKSPACE LPAREN psl = positionSpecList RPAREN { $node = new BackspaceStmtPositionSpecList($psl.node); }
    ;
unitIdentifier returns [UnitIdentifierNode node]
    : ufe = uFExpr { $node = new UnitIdentifierUFExpr($ufe.node); }
    | STAR { $node = new UnitIdentifierStar(); }
    ;

positionSpecList returns [PositionSpecListNode node]
    : uico = unitIdentifierCommaOptional ps = positionSpec pslt = positionSpecListTail { $node = new PositionSpecList($uico.node, $ps.node, $pslt.node); }
    ;

positionSpecListTail returns [PositionSpecListTailNode node]
    : ps = positionSpec { $node = new PositionSpecListTailSingle($ps.node); }
    | ps = positionSpec pslt = positionSpecListTail { $node = new PositionSpecListTailMultiple($ps.node, $pslt.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

positionSpec returns [PositionSpecNode node]
    : UNIT ASSIGN ui = unitIdentifier { $node = new PositionSpecUnit($ui.node); }
    | ERR ASSIGN lr = lblRef { $node = new PositionSpecErr($lr.node); }
    | IOSTAT ASSIGN sv = scalarVariable { $node = new PositionSpecIOStat($sv.node); }
    // Add other variations of positionSpec
    ;

scalarVariable returns [ScalarVariableNode node]
    : vn = variableName { $node = new ScalarVariableVariableName($vn.node); }
    | ae = arrayElement { $node = new ScalarVariableArrayElement($ae.node); }
    // Add other variations of scalarVariable
    ;

uFExpr returns [UFExprNode node]
    : uft = uFTerm { $node = new UFExprTerm($uft.node); }
    | (PLUS | MINUS) uft = uFTerm { $node = new UFExprUnary($uft.node); }
    | ufe = uFExpr (PLUS | MINUS) uft = uFTerm { $node = new UFExprBinary($ufe.node, $uft.node); }
    // Add other variations of uFExpr
    ;

uFTerm returns [UFTermNode node]
    : uff = uFFactor { $node = new UFTermFactor($uff.node); }
    | uft = uFTerm (STAR | DIV) uff = uFFactor { $node = new UFTermBinary($uft.node, $uff.node); }
    | uft = uFTerm (DIV DIV) ufp = uFPrimary { $node = new UFTermDoubleDiv($uft.node, $ufp.node); }
    // Add other variations of uFTerm
    ;

uFFactor returns [UFFactorNode node]
    : ufp = uFPrimary { $node = new UFFactorPrimary($ufp.node); }
    | ufp = uFPrimary POWER uff = uFFactor { $node = new UFFactorPower($ufp.node, $uff.node); }
    // Add other variations of uFFactor
    ;

uFPrimary returns [UFPrimaryNode node]
    : ICON { $node = new UFPrimaryIcon($ICON.text); }
    | SCON { $node = new UFPrimaryString($SCON.text); }
    | ndr = nameDataRef { $node = new UFPrimaryNameDataRef($ndr.node); }
    | fr = functionReference { $node = new UFPrimaryFunctionReference($fr.node); }
    | LPAREN ufe = uFExpr RPAREN { $node = new UFPrimaryExpression($ufe.node); }
    // Add other variations of uFPrimary
    ;

subroutineSubprogram returns [SubroutineSubprogramNode node]
    : SUBROUTINE sn = subroutineName sr = subroutineRange { $node = new SubroutineSubprogramRegular($sn.node, $sr.node); }
    | RECURSIVE SUBROUTINE sn = subroutineName sr = subroutineRange { $node = new SubroutineSubprogramRecursive($sn.node, $sr.node); }
    ;

subroutineName returns [SubroutineNameNode node]
    : NAME { $node = new SubroutineName($NAME.text); }
    ;

subroutineRange returns [SubroutineRangeNode node]
    : splwb = subroutineParListWithBody ess = endSubroutineStmt { $node = new SubroutineRangeParListWithBody($splwb.node, $ess.node); }
    | spl = subroutineParList bpi = bodyPlusInternals ess = endSubroutineStmt { $node = new SubroutineRangeParListBodyPlusInternals($spl.node, $bpi.node, $ess.node); }
    ;

subroutineParListWithBody returns [SubroutineParListWithBodyNode node]
    : spl = subroutineParList { $node = new SubroutineParListWithBodyParList($spl.node); }
    | spl = subroutineParList b = body { $node = new SubroutineParListWithBodyBody($spl.node, $b.node); }
    ;

includeStmt returns [IncludeStmtNode node]
    : INCLUDE SCON { $node = new IncludeStmt($SCON.text); }
    ;

implicitStmt returns [ImplicitStmtNode node]
    : IMPLICIT isl = implicitSpecList { $node = new ImplicitStmtSpecList($isl.node); }
    | IMPLICIT NONE { $node = new ImplicitStmtNone(); }
    ;

implicitSpecList returns [ImplicitSpecListNode node]
    : sis = singleImplicitSpec { $node = new ImplicitSpecListSingle($sis.node); }
    | mis = multipleImplicitSpecs { $node = new ImplicitSpecListMultiple($mis.node); }
    ;

singleImplicitSpec returns [SingleImplicitSpecNode node]
    : is = implicitSpec { $node = new SingleImplicitSpec($is.node); }
    ;

multipleImplicitSpecs returns [MultipleImplicitSpecsNode node]
    : is = implicitSpec COMMA isl = implicitSpecList { $node = new MultipleImplicitSpecs($is.node, $isl.node); }
    ;

implicitSpec returns [ImplicitSpecNode node]
    : ts = typeSpec ir = implicitRanges { $node = new ImplicitSpecTypeSpecRanges($ts.node, $ir.node); }
    | ts = typeSpec LPAREN ir = implicitRanges RPAREN { $node = new ImplicitSpecTypeSpecRangesParen($ts.node, $ir.node); }
    ;

implicitRanges returns [ImplicitRangesNode node]
    : irl = implicitRangeList { $node = new ImplicitRanges($irl.node); }
    ;

implicitRangeList returns [ImplicitRangeListNode node]
    : ir = implicitRange { $node = new ImplicitRangeListSingle($ir.node); }
    | irl = implicitRangeList COMMA ir = implicitRange { $node = new ImplicitRangeListMultiple($irl.node, $ir.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

implicitRange returns [ImplicitRangeNode node]
    : NAME MINUS NAME { $node = new ImplicitRange($NAME.text, $NAME.text); }
    ;
expression returns [ExpressionNode node]
    : le5 = level5Expr { $node = new ExpressionSingle($le5.node); }
    | expr = expression dbo = definedBinaryOp le5 = level5Expr { $node = new ExpressionBinary($expr.node, $dbo.node, $le5.node); }
    ;

definedBinaryOp returns [DefinedBinaryOpNode node]
    : DOP { $node = new DefinedBinaryOp($DOP.text); }
    ;

level5Expr returns [Level5ExprNode node]
    : eo = equivOperand { $node = new Level5ExprSingle($eo.node); }
    | le5e = level5ExprExtended { $node = new Level5ExprExtended($le5e.node); }
    ;

level5ExprExtended returns [Level5ExprExtendedNode node]
    : eo = equivOperand neqv = NEQV eo2 = equivOperand le5eo = level5ExprExtendedOptional { $node = new Level5ExprExtendedNEQV($eo.node, $eo2.node, $le5eo.node); }
    | eo = equivOperand eqv = EQV eo2 = equivOperand le5eo = level5ExprExtendedOptional { $node = new Level5ExprExtendedEQV($eo.node, $eo2.node, $le5eo.node); }
    ;

level5ExprExtendedOptional returns [Level5ExprExtendedOptionalNode node]
    : // Define rules for NEQV and EQV with level5ExprExtendedOptional
    | { $node = new NullNode(); } // For the empty case
    ;

equivOperand returns [EquivOperandNode node]
    : soo = singleOrOperand { $node = new EquivOperandSingleOr($soo.node); }
    | moo = multipleOrOperands { $node = new EquivOperandMultipleOr($moo.node); }
    ;

singleOrOperand returns [SingleOrOperandNode node]
    : oo = orOperand { $node = new SingleOrOperand($oo.node); }
    ;

multipleOrOperands returns [MultipleOrOperandsNode node]
    : oo = orOperand LOR ool = orOperandList { $node = new MultipleOrOperands($oo.node, $ool.node); }
    ;

orOperandList returns [OrOperandListNode node]
    : oo = orOperand { $node = new OrOperandListSingle($oo.node); }
    | ool = orOperandList LOR oo = orOperand { $node = new OrOperandListMultiple($ool.node, $oo.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

orOperand returns [OrOperandNode node]
    : sao = singleAndOperand { $node = new OrOperandSingleAnd($sao.node); }
    | mao = multipleAndOperands { $node = new OrOperandMultipleAnd($mao.node); }
    ;

singleAndOperand returns [SingleAndOperandNode node]
    : ao = andOperand { $node = new SingleAndOperand($ao.node); }
    ;

multipleAndOperands returns [MultipleAndOperandsNode node]
    : ao = andOperand LAND aol = andOperandList { $node = new MultipleAndOperands($ao.node, $aol.node); }
    ;

andOperandList returns [AndOperandListNode node]
    : ao = andOperand { $node = new AndOperandListSingle($ao.node); }
    | aol = andOperandList LAND ao = andOperand { $node = new AndOperandListMultiple($aol.node, $ao.node); }
    | { $node = new NullNode(); } // For the empty case
    ;

andOperand returns [AndOperandNode node]
    : le4 = level4Expr { $node = new AndOperandLevel4Expr($le4.node); }
    | nle4 = notLevel4Expr { $node = new AndOperandNotLevel4Expr($nle4.node); }
    ;

notLevel4Expr returns [NotLevel4ExprNode node]
    : LNOT le4 = level4Expr { $node = new NotLevel4Expr($le4.node); }
    ;
relOp returns [RelOpNode node]
    : LT { $node = new RelOpLT(); }
    | LE { $node = new RelOpLE(); }
    | EQ { $node = new RelOpEQ(); }
    | NE { $node = new RelOpNE(); }
    | GT { $node = new RelOpGT(); }
    | GE { $node = new RelOpGE(); }
    | OP { $node = new RelOpOP($OP.text); }
    ;

level4Expr returns [Level4ExprNode node]
    : le3 = level3Expr (ro = relOp le3_2 = level3Expr)* { $node = new Level4Expr($le3.node, $ro.node, $le3_2.node); }
    ;

level3Expr returns [Level3ExprNode node]
    : le2 = level2Expr (DIV SPOFF? DIV SPON? le2_2 = level2Expr)* { $node = new Level3Expr($le2.node, $le2_2.node); }
    ;

level2Expr returns [Level2ExprNode node]
    : s = sign? ao = addOperand ((PLUS | MINUS) ao2 = addOperand)* { $node = new Level2Expr($s.node, $ao.node, $ao2.node); }
    ;

addOperandList returns [AddOperandListNode node]
    : pmao = plusOrMinusAddOperand { $node = new AddOperandListSingle($pmao.node); }
    | aol = addOperandList pmao = plusOrMinusAddOperand { $node = new AddOperandListMultiple($aol.node, $pmao.node); }
    ;

plusOrMinusAddOperand returns [PlusOrMinusAddOperandNode node]
    : PLUS ao = addOperand { $node = new PlusAddOperand($ao.node); }
    | MINUS ao = addOperand { $node = new MinusAddOperand($ao.node); }
    ;

sign returns [SignNode node]
    : PLUS { $node = new SignPlus(); }
    | MINUS { $node = new SignMinus(); }
    ;

addOperand returns [AddOperandNode node]
    : smo = singleMultOperand { $node = new AddOperandSingleMult($smo.node); }
    | mmo = multipleMultOperands { $node = new AddOperandMultipleMult($mmo.node); }
    ;

singleMultOperand returns [SingleMultOperandNode node]
    : mo = multOperand { $node = new SingleMultOperand($mo.node); }
    ;

multipleMultOperands returns [MultipleMultOperandsNode node]
    : mo = multOperand sdoml = starOrDivMultOperandList { $node = new MultipleMultOperands($mo.node, $sdoml.node); }
    ;

starOrDivMultOperandList returns [StarOrDivMultOperandListNode node]
    : STAR mo = multOperand { $node = new StarMultOperandListSingle($mo.node); }
    | DIV mo = multOperand { $node = new DivMultOperandListSingle($mo.node); }
    | sdoml = starOrDivMultOperandList STAR mo = multOperand { $node = new StarMultOperandListMultiple($sdoml.node, $mo.node); }
    | sdoml = starOrDivMultOperandList DIV mo = multOperand { $node = new DivMultOperandListMultiple($sdoml.node, $mo.node); }
    ;

multOperand returns [MultOperandNode node]
    : sle1 = singleLevel1Expr { $node = new MultOperandSingleLevel1($sle1.node); }
    | mle1 = multipleLevel1Exprs { $node = new MultOperandMultipleLevel1($mle1.node); }
    ;

singleLevel1Expr returns [SingleLevel1ExprNode node]
    : le1 = level1Expr { $node = new SingleLevel1Expr($le1.node); }
    ;

multipleLevel1Exprs returns [MultipleLevel1ExprsNode node]
    : le1 = level1Expr ple1l = powerLevel1ExprList { $node = new MultipleLevel1Exprs($le1.node, $ple1l.node); }
    ;

powerLevel1ExprList returns [PowerLevel1ExprListNode node]
    : POWER le1 = level1Expr { $node = new PowerLevel1ExprListSingle($le1.node); }
    | ple1l = powerLevel1ExprList POWER le1 = level1Expr { $node = new PowerLevel1ExprListMultiple($ple1l.node, $le1.node); }
    ;

level1Expr returns [Level1ExprNode node]
    : p = primary { $node = new Level1ExprPrimary($p.node); }
    | duo = definedUnaryOp p = primary { $node = new Level1ExprDefinedUnaryOp($duo.node, $p.node); }
    ;

definedUnaryOp returns [DefinedUnaryOpNode node]
    : DOP { $node = new DefinedUnaryOp($DOP.text); }
    ;

primary returns [PrimaryNode node]
    : uac = unsignedArithmeticConstant { $node = new PrimaryUnsignedArithmeticConstant($uac.node); }
    | ndr = nameDataRef { $node = new PrimaryNameDataRef($ndr.node); }
    | fr = functionReference { $node = new PrimaryFunctionReference($fr.node); }
    | LPAREN expr = expression RPAREN { $node = new PrimaryExpression($expr.node); }
    | SCON { $node = new PrimaryString($SCON.text); }
    | lc = logicalConstant { $node = new PrimaryLogicalConstant($lc.node); }
    | ac = arrayConstructor { $node = new PrimaryArrayConstructor($ac.node); }
    ;
arrayConstructor returns [ArrayConstructorNode node]
    : OBRACKETSLASH acvl = acValueList CBRACKETSLASH { $node = new ArrayConstructor($acvl.node); }
    ;

acValueList returns [ACValueListNode node]
    : expr = expression { $node = new ACValueListSingle($expr.node); }
    | acvl1 = acValueList1 { $node = new ACValueListMultiple($acvl1.node); }
    ;

acValueList1 returns [ACValueList1Node node]
    : expr1 = expression COMMA expr2 = expression { $node = new ACValueList1TwoExpressions($expr1.node, $expr2.node); }
    // Add other variations of acValueList1
    ;

functionReference returns [FunctionReferenceNode node]
    : NAME LPAREN RPAREN { $node = new FunctionReferenceNoArgs($NAME.text); }
    | NAME LPAREN fal = functionArgList RPAREN { $node = new FunctionReferenceWithArgs($NAME.text, $fal.node); }
    ;

functionArgList returns [FunctionArgListNode node]
    : fa = functionArg { $node = new FunctionArgListSingle($fa.node); }
    | fal = functionArgList COMMA fa = functionArg { $node = new FunctionArgListMultiple($fal.node, $fa.node); }
    // Add other variations of functionArgList
    ;

functionArg returns [FunctionArgNode node]
    : NAME ASSIGN expr = expression { $node = new FunctionArg($NAME.text, $expr.node); }
    ;

nameDataRef returns [NameDataRefNode node]
    : ndrs = nameDataRefSingle { $node = new NameDataRefSingle($ndrs.node); }
    | ndrm = nameDataRefMultiple { $node = new NameDataRefMultiple($ndrm.node); }
    ;

nameDataRefSingle returns [NameDataRefSingleNode node]
    : NAME { $node = new NameDataRefSingleName($NAME.text); }
    | REAL { $node = new NameDataRefSingleReal(); }
    | SIZE { $node = new NameDataRefSingleSize(); }
    ;

nameDataRefMultiple returns [NameDataRefMultipleNode node]
    : NAME cdrtl = complexDataRefTailList { $node = new NameDataRefMultipleName($NAME.text, $cdrtl.node); }
    | REAL cdrtl = complexDataRefTailList { $node = new NameDataRefMultipleReal($cdrtl.node); }
    | SIZE cdrtl = complexDataRefTailList { $node = new NameDataRefMultipleSize($cdrtl.node); }
    ;

complexDataRefTail returns [ComplexDataRefTailNode node]
    : ssr = sectionSubscriptRef { $node = new ComplexDataRefTailSectionSubscript($ssr.node); }
    | PCT NAME { $node = new ComplexDataRefTailPercentName($NAME.text); }
    ;
sectionSubscriptRef returns [SectionSubscriptRefNode node]
    : LPAREN ssl = sectionSubscriptList RPAREN { $node = new SectionSubscriptRef($ssl.node); }
    ;
complexDataRefTailList returns [ComplexDataRefTailListNode node]
    : cdrt = complexDataRefTail { $node = new ComplexDataRefTailListSingle($cdrt.node); }
    | cdrtl = complexDataRefTailList cdrt = complexDataRefTail { $node = new ComplexDataRefTailListMultiple($cdrtl.node, $cdrt.node); }
    ;
// Continuation of the ANTLR4 grammar

acImpliedDo returns [ACImpliedDoNode node]
    : LPAREN expr = expression COMMA iv = impliedDoVariable ASSIGN e1 = expression COMMA e2 = expression RPAREN { $node = new ACImpliedDoSimple($expr.node, $iv.node, $e1.node, $e2.node); }
    | LPAREN expr = expression COMMA iv = impliedDoVariable ASSIGN e1 = expression COMMA e2 = expression COMMA e3 = expression RPAREN { $node = new ACImpliedDoExtended($expr.node, $iv.node, $e1.node, $e2.node, $e3.node); }
    | LPAREN acido = acImpliedDo COMMA iv = impliedDoVariable ASSIGN e1 = expression COMMA e2 = expression RPAREN { $node = new ACImpliedDoNestedSimple($acido.node, $iv.node, $e1.node, $e2.node); }
    | LPAREN acido = acImpliedDo COMMA iv = impliedDoVariable ASSIGN e1 = expression COMMA e2 = expression COMMA e3 = expression RPAREN { $node = new ACImpliedDoNestedExtended($acido.node, $iv.node, $e1.node, $e2.node, $e3.node); }
    ;


logicalConstant returns [LogicalConstantNode node]
    : (TRUE | FALSE) { $node = new LogicalConstant($TRUE != null ? "TRUE" : "FALSE"); }
    | TRUE UNDERSCORE kp = kindParam { $node = new LogicalConstantTrueKindParam($kp.node); }
    | FALSE UNDERSCORE kp = kindParam { $node = new LogicalConstantFalseKindParam($kp.node); }
    ;

kindParam returns [KindParamNode node]
    : ICON { $node = new KindParamIcon($ICON.text); }
    | ncu = namedConstantUse { $node = new KindParamNamedConstantUse($ncu.node); }
    ;

unsignedArithmeticConstant returns [UnsignedArithmeticConstantNode node]
    : (ICON | RDCON) { $node = new UnsignedArithmeticConstant($ICON != null ? $ICON.text : $RDCON.text); }
    | cc = complexConst { $node = new UnsignedArithmeticConstantComplexConst($cc.node); }
    | ICON UNDERSCORE kp = kindParam { $node = new UnsignedArithmeticConstantIconKindParam($ICON.text, $kp.node); }
    | RDCON UNDERSCORE kp = kindParam { $node = new UnsignedArithmeticConstantRdconKindParam($RDCON.text, $kp.node); }
    ;

complexConst returns [ComplexConstNode node]
    : LPAREN cc = complexComponent COMMA RPAREN { $node = new ComplexConst($cc.node); }
    ;

complexComponent returns [ComplexComponentNode node]
    : si = signIcon { $node = new ComplexComponentSignIcon($si.node); }
    | ICON { $node = new ComplexComponentIcon($ICON.text); }
    | RDCON { $node = new ComplexComponentRdcon($RDCON.text); }
    | NAME { $node = new ComplexComponentName($NAME.text); }
    ;

signIcon returns [SignIconNode node]
    : PLUS ICON { $node = new SignIconPlus($ICON.text); }
    | MINUS ICON { $node = new SignIconMinus($ICON.text); }
    ;

ifStmt returns [IfStmtNode node]
    : IF LPAREN expr = expression RPAREN as = actionStmt { $node = new IfStmt($expr.node, $as.node); }
    ;


RECURSIVE
   : 'RECURSIVE' | 'recursive' |'Recursive' ;


CONTAINS
   :
   ('contains'|'CONTAINS' |'Contains')
   ;

MODULE
   : 'MODULE' | 'module' |'Module'
   ;

ENDMODULE
   : 'ENDMODULE' | 'endmodule' |'Endmodule'
   ;

PROGRAM
   : 'program' | 'PROGRAM' |'Program'
   ;

ENTRY
   : 'entry' | 'ENTRY' |'Entry'
   ;

FUNCTION
   : 'function' | 'FUNCTION' | 'Function'
   ;


BLOCK
   : 'block' | 'BLOCK' | 'Block'
   ;

SUBROUTINE
   : 'subroutine' | 'SUBROUTINE' | 'Subroutine'
   ;

ENDINTERFACE
   : 'ENDINTERFACE' | ' endinterface' |'Endinterface'
   ;

PROCEDURE
   : 'procedure'  | 'PROCEDURE' | 'Procedure'
   ;

END
   : 'END' | 'end'| 'End'
   ;

DIMENSION
   : 'dimension' | 'DIMENSION' | 'Dimension'
   ;

TARGET : 'TARGET' | 'target' |'Target' ;

ALLOCATABLE : 'ALLOCATABLE' | 'allocatable' |'Allocatable' ;

OPTIONAL : 'OPTIONAL' | 'optional' |'Optional' ;

NAMELIST : 'NAMELIST' | 'namelist' ;

INTENT : 'INTENT' | 'intent' |'Intent' ;

IN : 'IN' | 'in' |'In' ;

OUT : 'OUT' | 'out' |'Out' ;

INOUT : 'INOUT' | 'inout' | 'Inout' ;

OPERATOR : 'operator' | 'OPERATOR' | 'Operator';

USE : 'USE' | 'use' |'Use' ;

ONLY : 'ONLY' | 'only' |'Only' ;

IMPLIEDT : '=>' ;

ASSIGNMENT : 'ASSIGNMENT' | 'assignment' |'Assignment' ;



DOP : '.''\\a'+'.';

OP
   :'=='
   | '!='
   | '<='
   |'>='
   |'<'
   |'>'
   |'/='
   ;

DOUBLEPRECISION : 'DOUBLEPRECISION' | 'doubleprecision' | 'double precision' | 'DOUBLE PRECISION';

DOUBLECOLON : '::' ;

ASSIGNSTMT : 'assign' | 'ASSIGN' |'Assign';

COMMON : 'COMMON' | 'common' |'Common';

ELSEWHERE : 'ELSEWHERE' | 'elsewhere' |'Elsewhere' ;

REAL
   : 'REAL' | 'real' |'Real'
   ;



EQUIVALENCE
   : 'EQUIVALENCE' | 'equivalence' |'Equivalence'
   ;


BLOCKDATA
   : 'blockdata' | 'BLOCKDATA' |'Blockdata'
   ;


POINTER
   : 'pointer' | 'POINTER' |'Pointer'
   ;

fragment PRIVATES
    : 'private' | 'PRIVATE' |'Private'
    ;

PRIVATE : PRIVATES ;

SEQUENCE
   : 'sequence' | 'SEQUENCE' |'Sequence'
   ;

fragment PUBLIC
    : 'public' | 'PUBLIC' | 'Public'
    ;

ACCESSSPEC
   : PRIVATE | PUBLIC
   ;

IMPLICIT
   : 'implicit' | 'IMPLICIT' | 'Implicit'
   ;

NONE
   : 'none' | 'NONE' | 'None'
   ;

CHARACTER
   : 'character' | 'CHARACTER' | 'Character'
   ;


PARAMETER
   : 'parameter' | 'PARAMETER' | 'Parameter'
   ;


EXTERNAL
   : 'external' | 'EXTERNAL' | 'External'
   ;


INTRINSIC
   : 'intrinsic' | 'INTRINSIC' |'Intrinsic'
   ;


SAVE
   : 'save' | 'SAVE' |'Save'
   ;


DATA
   : 'data' | 'DATA' | 'Data'
   ;


GO
   : 'GO' | 'go'  | 'Go'
   ;


GOTO
   : 'GOTO' | 'goto' | 'Goto'
   ;


IF
   : 'IF' | 'if' | 'If'
   ;


THEN
   : 'THEN' | 'then'
   ;


ELSE
   : 'ELSE' | 'else'
   ;


ENDIF
   : 'ENDIF' | 'endif'
   ;

RESULT
   : 'RESULT' | 'result'
   ;


ELSEIF
   : 'ELSEIF' | 'elseif' | 'Elseif'
   ;


DO
   : 'DO' | 'do' |'Do'
   ;

INCLUDE : 'INCLUDE' | 'include' |'Include' ;

CONTINUE
   : 'CONTINUE' | 'continue' |'Continue'
   ;

ENDWHERE : 'ENDWHERE' | 'endwhere' | 'Endwhere';

WHERE : 'WHERE' | 'where' |'Where' ;

ENDSELECT : 'ENDSELECT' | 'endselect' ;

SELECTCASE : 'SELECTCASE' | 'selectcase';

SELECT: 'SELECT' | 'select' ;

CASE : 'case' | 'CASE' |'Case' ;

DEFAULT : 'DEFAULT' | 'default' | 'Default';

DIRECT : 'DIRECT' | 'direct' |'Direct' ;

STOP
   : 'STOP' | 'stop' | 'Stop'
   ;

 REC : 'REC' | 'rec' |'Rec'
   ;

ENDDO
   : 'ENDDO' | 'enddo'
   ;


PAUSE
   : 'pause' | 'PAUSE'
   ;


WRITE
   : 'WRITE' | 'write'
   ;


READ
   : 'READ' | 'read'
   ;

SEMICOLON : ';';

PRINT
   : 'PRINT' | 'print'
   ;


OPEN
   : 'OPEN' | 'open'
   ;


FMT
   : 'FMT' | 'fmt'
   ;


UNIT
   : 'UNIT' | 'unit'
   ;

PAD : 'PAD' | 'pad' ;

ACTION : 'ACTION' | 'action' ;

DELIM : 'DELIM' | 'delim' ;

IOLENGTH : 'IOLENGTH' | 'iolength' ;

READWRITE : 'READWRITE' | 'readwrite' ;

ERR
   : 'err' | 'ERR'
   ;

SIZE : 'SIZE' | 'size' ;

ADVANCE : 'ADVANCE' | 'advance' ;

NML : 'NML' | 'nml' ;


IOSTAT
   : 'IOSTAT' | 'iostat'
   ;


FORMAT
   : 'FORMAT' | 'format'
   ;


LET
   : 'LET' | 'let'
   ;


CALL
   : 'CALL' | 'call'
   ;


RETURN
   : 'RETURN' | 'return' | 'Return'
   ;


CLOSE
   : 'CLOSE' | 'close'
   ;


DOUBLE
   : 'DOUBLE' | 'double'
   ;


IOSTART
   : 'IOSTART' | 'iostart'
   ;


SEQUENTIAL
   : 'SEQUENTIAL' | 'sequential'
   ;


LABEL
   : 'LABEL' | 'label'
   ;


FILE
   : 'file' | 'FILE'
   ;


STATUS
   : 'STATUS' | 'status'
   ;


ACCESS
   : 'ACCESS' | 'access'
   ;


POSITION
   : 'POSITION' | 'position'
   ;


FORM
   : 'FORM' | 'form'
   ;


RECL
   : 'RECL' | 'recl'
   ;


EXIST
   : 'EXIST' | 'exist'
   ;


OPENED
   : 'OPENED' | 'opened'
   ;


NUMBER
   : 'NUMBER' | 'number'
   ;


NAMED
   : 'NAMED' | 'named'
   ;


NAME_
   : 'NAME' | 'name'
   ;


FORMATTED
   : 'FORMATTED' | 'formatted'
   ;


UNFORMATTED
   : 'UNFORMATTED' | 'unformatted'
   ;


NEXTREC
   : 'NEXTREC' | 'nextrec'
   ;


INQUIRE
   : 'INQUIRE' | 'inquire'
   ;


BACKSPACE
   : 'BACKSPACE' | 'backspace'
   ;


ENDFILE
   : 'ENDFILE' | 'endfile'
   ;


REWIND
   : 'REWIND' | 'rewind'
   ;

ENDBLOCKDATA : 'endblockdata' | 'ENDBLOCKDATA' ;

ENDBLOCK : 'ENDBLOCK' | 'endblock' ;




fragment NEWLINE
	: '\r\n' | '\r' | '\n'
	| '\u0085' // <Next Line CHARACTER (U+0085)>'
	| '\u2028' //'<Line Separator CHARACTER (U+2028)>'
	| '\u2029' //'<Paragraph Separator CHARACTER (U+2029)>'
	;


KIND : 'KIND' | 'kind' ;

LEN : 'LEN' | 'len' ;

//EOS : COMMENTORNEWLINE+ ;
//EOS : (COMMENTORNEWLINE? SPACES* [\r\n] [ \t]* )+;

//RN : NEWLINE -> channel(HIDDEN) ;

WS
   :  ([ \t]  | NEWLINE)+ -> channel(HIDDEN)
   ;

COMMENT
    : '!' ~[\r\n]* -> channel(HIDDEN);


/*
COMMENTORNEWLINE
   : COMMENT
   |
   NEWLINE

   ;
*/



DOLLAR
   : '$'
   ;


COMMA
   : ','
   ;


LPAREN
   : '('
   ;

PCT : '%';

WHILE : 'while' | 'WHILE';

ALLOCATE : 'ALLOCATE' | 'allocate' ;

STAT : 'STAT' | 'stat';

RPAREN
   : ')'
   ;


COLON
   : ':'
   ;


ASSIGN
   : '='
   ;


MINUS
   : '-'
   ;


PLUS
   : '+'
   ;


DIV
   : '/'
   ;

fragment STARCHAR
   : '*'
   ;

FORMATSEP
   : '/' | ':'
   ;


POWER
   : '**'
   ;


LNOT
   : '.not.' | '.NOT.'
   ;


LAND
   : '.and.' | '.AND.'
   ;


LOR
   : '.or.' | '.OR.'
   ;


EQV
   : '.eqv.' | '.EQV.'
   ;


NEQV
   : '.neqv.' | '.NEQV.'
   ;


XOR
   : '.xor.' | '.XOR.'
   ;


EOR
   : '.eor.' | '.EOR.'
   ;


LT
   : '.lt.' | '.LT.'
   ;


LE
   : '.le.' | '.LE.'
   ;


GT
   : '.gt.' | '.GT.'
   ;


GE
   : '.ge.' | '.GE.'
   ;


NE
   : '.ne.' | '.NE.'
   ;


EQ
   : '.eq.' | '.EQ.'
   ;


TRUE
   : '.true.' | '.TRUE.'
   ;


FALSE
   : '.false.' | '.FALSE.'
   ;


XCON
   : NUM+ [xX]
   ;


PCON
   : [+-]?NUM+[pP]
   ;


FCON
   : ('a'|'A'|'b'|'B'|'e'|'E'|'d'|'D'|(('e'|'E')('n'|'N'|'s'|'S'))|'q'|'Q'|'f'|'F'|'g'|'G'|'i'|'I'|'l'|'L'|'o'|'O'|'z'|'Z')(NUM+|'*')('.'NUM+(('e'|'E'|'d'|'D'|'q'|'Q')NUM+)?)
   ;


CCON
   : 'CCON'
   ;


HOLLERITH
   : 'HOLLERITH'
   ;


CONCATOP
   : 'CONCATOP'
   ;


CTRLDIRECT
   : 'CTRLDIRECT'
   ;


CTRLREC
   : 'CTRLREC'
   ;


TO
   : 'TO'
   ;


SUBPROGRAMBLOCK
   : 'SUBPROGRAMBLOCK'
   ;


DOBLOCK
   : 'DOBLOCK'
   ;


AIF
   : 'AIF'
   ;


THENBLOCK
   : 'THENBLOCK'
   ;


ELSEBLOCK
   : 'ELSEBLOCK'
   ;


CODEROOT
   : 'CODEROOT'
   ;


COMPLEX
   : 'COMPLEX' | 'complex'
   ;


PRECISION
   : 'PRECISION' | 'precision'
   ;


INTEGER
   : 'INTEGER' | 'integer' |'Integer'
   ;


LOGICAL
   : 'LOGICAL' | 'logical' | 'Logical'
   ;

fragment SCORE : '_';

UNDERSCORE : SCORE ;

OBRACKETSLASH : '(/';

DOT : '.' ;

CBRACKETSLASH : '/)';

ZCON :  [zZ]'\''[abcdefABCDEF0-9] + '\''
   | [zZ] '"'[abcdefABCDEF0-9] +'"' ;

BCON : [bB]'\'' [01] + '\''
   | [bB]'"'[01] + '"'
   ;

 OCON
   : [oO]'"'[01234567] + '"'
   | [oO]'\''[01234567] + '\''
   ;

SCON
   : '\'' ('\'' '\'' | ~ ('\'' | '\n' | '\r') | (('\n' | '\r' ('\n')?) '     ' CONTINUATION) ('\n' | '\r' ('\n')?) '     ' CONTINUATION)* '\''
   |
   '\'' (~('\'') | ('\'''\''))*  ('\'' )
   |
   ('"') (~('"') | '""')*  ('"')
   ;

RDCON : NUM+ '.' NUM* EXPON?
      | NUM* '.' NUM+ EXPON?
      | NUM+ EXPON
      ;

DEALLOCATE : 'DEALLOCATE' | 'deallocate' ;

NULLIFY : 'NULLIFY' | 'nullify' ;

CYCLE : 'CYCLE' | 'cycle' ;

ENDTYPE : 'ENDTYPE' | 'endtype' | 'Endtype' |'EndType';

INTERFACE : 'INTERFACE' | 'interface' | 'Interface' ;

SPOFF : 'SPOFF';

SPON : 'SPON';

ICON
   : NUM+
   ;

TYPE
   : 'type' | 'TYPE' | 'Type'
   ;

NAME
   :LETTER ( ALPHANUMERIC_CHARACTER )*
   ;

EXIT : 'EXIT' | 'exit' ;

BLANK
   : 'BLANK' | 'blank'
   ;


ALPHANUMERIC_CHARACTER : LETTER | NUM | SCORE ;

fragment LETTER : ('a'..'z' | 'A'..'Z') ;


STAR
   : STARCHAR
   ;



STRINGLITERAL
   : '"' ~ ["\r\n]* '"'
   ;


EOL
   : [\r\n] +
   ;

fragment SPACES
 : [ \t] +
 ;

LINECONT
   :  (('&' SPACES? COMMENT? NEWLINE (SPACES* [ \t] * '&' )?) | ( SPACES? COMMENT? NEWLINE SPACES* [ \t] * '&' )) -> channel(HIDDEN)
   ;

fragment CONTINUATION
   : ~ ('0' | ' ')
   ;


fragment ALNUM
   : (ALPHA | NUM)
   ;


fragment HEX
   : (NUM | 'a' .. 'f')
   ;


fragment SIGN
   : ('+' | '-')
   ;


fragment FDESC
   : ('i' | 'f' | 'd') (NUM) + '.' (NUM) + | ('e' | 'g') (NUM) + '.' (NUM) + ('e' (NUM) +)?
   ;


fragment EXPON
   : ('e' | 'E' | 'd' | 'D') (SIGN)? (NUM) +
   ;


fragment ALPHA
   : ('a' .. 'z') | ('A' .. 'Z')
   ;


fragment NUM
   : ('0' .. '9')
   ;
IDENT : [a-zA-Z][a-zA-Z0-9_]*;