options {
  JAVA_UNICODE_ESCAPE = true;
}

PARSER_BEGIN(RalfIIParser)
  public class RalfIIParser {}
PARSER_END(RalfIIParser)

SKIP : /* WHITE SPACE */
{
  " "
| "\t"
| "\n"
| "\r"
| "\f"
}

SPECIAL_TOKEN : /* COMMENTS */
{
  <SINGLE_LINE_COMMENT: "//" (~["\n","\r"])* ("\n"|"\r"|"\r\n")>
| <FORMAL_COMMENT: "/**" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/">
| <MULTI_LINE_COMMENT: "/*" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/">
}

TOKEN : 
{
  < COLON: ":" >
| < SEMICOLON: ";" >
| < ASSIGN: ":=" >
| < SET : "set" >   
| < PARAM : "param" >   
| < CALLERSAVE: "callerSave" >
| < FREQ: "freq" >
| < LIVE: "Live" >
| < LIVEHARDREG: "LiveHardReg" >
| < BASEPSEUDOREG: "basePseudoReg" >
| < BASEHARDREG: "baseHardReg" >
| < REQ: "req" >
| < HRREQ: "HRreq" >
| < PREVINST: "prevInst" >
| < PREVINSTS: "prevInsts" >
| < DEF: "def" >
| < DEFHARDREG: "defHardReg" >
| < LSMPSEUDOS: "lsmPseudos" >
| < MEMPSEUDOS: "memPseudos" >
| < NSEDGE: "nsEdge" >
| < EQUIV: "equiv" >
| < KNOWNSTORES: "knownStores" >
| < KNOWNHARDSTORES: "knownHardStores" >
| < KNOWNLOADS: "knownLoads" >
| < JUMPINST: "jumpInst" >
| < CALLINST: "callInst" >
| < MOVEINST: "Moves" >
| < PSEUDOS: "pseudos"> 
| < LOC: "Loc">
| < INSTS: "insts">
| < REGS: "regs">
| <LOADCOST: "loadCost">      
| <LOADPAIRCOST: "loadPairCost">  
| <INVLOADCOST: "invLoadCost">   
| <STORECOST: "storeCost">     
| <STOREPAIRCOST: "storePairCost"> 
| <INVSTORECOST: "invStoreCost">     
| <NREGS: "nRegs">         
| <NINSTS: "nInsts">        
| <NLSMPSEUDOS: "nLSMPseudos">   
| <NPSEUDOS: "nPseudos">      
| <NMOVES: "nMoves">
}

TOKEN : /* LITERALS */
{
  < INTEGER_LITERAL: ( ["1"-"9"] (["0"-"9"])* | "0" ) >
}

TOKEN : /* IDENTIFIERS */
{
  < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* >
|
  < #LETTER:
      [
       "\u0024",
       "\u0041"-"\u005a",
       "\u005f",
       "\u0061"-"\u007a",
       "\u00c0"-"\u00d6",
       "\u00d8"-"\u00f6",
       "\u00f8"-"\u00ff",
       "\u0100"-"\u1fff",
       "\u3040"-"\u318f",
       "\u3300"-"\u337f",
       "\u3400"-"\u3d2d",
       "\u4e00"-"\u9fff",
       "\uf900"-"\ufaff"
      ]
  >
|
  < #DIGIT:
      [
       "\u0030"-"\u0039",
       "\u0660"-"\u0669",
       "\u06f0"-"\u06f9",
       "\u0966"-"\u096f",
       "\u09e6"-"\u09ef",
       "\u0a66"-"\u0a6f",
       "\u0ae6"-"\u0aef",
       "\u0b66"-"\u0b6f",
       "\u0be7"-"\u0bef",
       "\u0c66"-"\u0c6f",
       "\u0ce6"-"\u0cef",
       "\u0d66"-"\u0d6f",
       "\u0e50"-"\u0e59",
       "\u0ed0"-"\u0ed9",
       "\u1040"-"\u1049"
      ]
  >
}


/************************************
 * The MiniJava Grammar Starts Here *
 ************************************/
void Goal() :
{}
{
  scalarParams()
  setCollection()
  paramCollection()
  <EOF>
}
void setCollection() :
{}
{
  pseudoSet()
  locSet()
  instSet()
  regSet()
}
void paramCollection():
{}
{
  callerSaveParam()
  freqParam()
  liveParam()
  liveHardRegParam()
  basePseudoRegParam()
  baseHardRegParam()
  reqParam()
  HRreqParam()
  prevInstParam()
  prevInstsParam()
  defParam()
  defHardRegParam()
  lsmPseudosParam()
  memPseudosParam()
  nsEdgeParam()
  equivParam()
  knownStoresParam()
  knownHardStoresParam()
  knownLoadsParam()
  jumpInstParam()
  callInstParam()
  moveInstParam()

}
void pseudoSet() :
{}
{
        <SET> <PSEUDOS> <ASSIGN> 
        (pseudo())*
        <SEMICOLON>
}
void regSet() :
{}
{
        <SET> <REGS> <ASSIGN> 
        (register())*
        <SEMICOLON>
}
void locSet() :
{}
{
        <SET> <LOC> <ASSIGN> 
        (location())*
        <SEMICOLON>
}
void instSet() :
{}
{
        <SET> <INSTS> <ASSIGN> 
        (instruction())*
        <SEMICOLON>
}


void callerSaveParam() :
{}
{
        <PARAM> (<COLON>)? <CALLERSAVE> <ASSIGN>
        (callerSaveInfo())*
        <SEMICOLON>
}

void   freqParam() :
{}
{
	<PARAM> <COLON> <FREQ> <ASSIGN>
        (freqInfo())*
	<SEMICOLON>
}

void   liveParam() :
{}
{
	<PARAM> <COLON> <LIVE> <ASSIGN>
        (liveInfo())*
	<SEMICOLON>
}

void   liveHardRegParam() :
{}
{
	<PARAM> <COLON> <LIVEHARDREG> <ASSIGN>
        (liveHardRegInfo())*
	<SEMICOLON>
}
void   basePseudoRegParam() :
{}
{
	<PARAM> <COLON> <BASEPSEUDOREG> <ASSIGN>
        (basePseudoRegInfo())*
	<SEMICOLON>
}

void   baseHardRegParam() :
{}
{
	<PARAM> <COLON> <BASEHARDREG> <ASSIGN>
        (baseHardRegInfo())*
	<SEMICOLON>
}
void   reqParam():
{}
{
	<PARAM> <COLON> <REQ> <ASSIGN>
        (reqInfo())*
	<SEMICOLON>
}
void   HRreqParam():
{}
{
	<PARAM> <COLON> <HRREQ> <ASSIGN>
        (HRreqInfo())*
	<SEMICOLON>
}

void   prevInstParam() :
{}
{
	<PARAM> <COLON> <PREVINST> <ASSIGN>
        (prevInstInfo())*
	<SEMICOLON>
}
void   prevInstsParam() :
{}
{
	<PARAM> <COLON> <PREVINSTS> <ASSIGN>
        (prevInstsInfo())* 
	<SEMICOLON>
}
void   defParam() :
{}
{
	<PARAM> <COLON> <DEF> <ASSIGN>
        (defInfo())*
	<SEMICOLON>
}
void   defHardRegParam() :
{}
{
	<PARAM> <COLON> <DEFHARDREG> <ASSIGN>
        (defHardRegInfo())*
	<SEMICOLON>
}

void   lsmPseudosParam() :
{}
{
	<PARAM> <COLON> <LSMPSEUDOS> <ASSIGN>
        (lsmPseudoInfo())*
	<SEMICOLON>
}
void   memPseudosParam() :
{}
{
	<PARAM> <COLON> <MEMPSEUDOS> <ASSIGN>
        (memPseudoInfo())*
	<SEMICOLON>
}
void   nsEdgeParam() :
{}
{
	 <PARAM> <COLON> <NSEDGE> <ASSIGN>
        (nsEdgeInfo())*
	<SEMICOLON>
}
void   equivParam() :
{}
{
	<PARAM> <COLON> <EQUIV> <ASSIGN>
        (equivInfo())*
	<SEMICOLON>
}

void   knownStoresParam() :
{}
{
	<PARAM> <COLON> <KNOWNSTORES> <ASSIGN>
        (knownStoreInfo())*
	<SEMICOLON>
}

void   knownHardStoresParam() :
{}
{
	<PARAM> <COLON> <KNOWNHARDSTORES> <ASSIGN>
        (knownHardStoreInfo())*
	<SEMICOLON>
}
void   knownLoadsParam() :
{}
{
	<PARAM> <COLON> <KNOWNLOADS> <ASSIGN>
        (knownLoadInfo())*
	<SEMICOLON>
}
void   jumpInstParam() :
{}
{
	<PARAM> <COLON> <JUMPINST> <ASSIGN>
        (jumpInstInfo())*
	<SEMICOLON>
}
void   callInstParam() :
{}
{
	<PARAM> <COLON> <CALLINST> <ASSIGN>
        (callInstInfo())*
	<SEMICOLON>
}
void   moveInstParam() :
{}
{
	<PARAM> <COLON> <MOVEINST> <ASSIGN>
        (moveInstInfo())*
	<SEMICOLON>
}
void   scalarParams() :
{}
{
	<PARAM> <LOADCOST>      <ASSIGN> value() <SEMICOLON>
	<PARAM> <LOADPAIRCOST>  <ASSIGN> value() <SEMICOLON>
	<PARAM> <INVLOADCOST>   <ASSIGN> value() <SEMICOLON>
	<PARAM> <STORECOST>     <ASSIGN> value() <SEMICOLON>
	<PARAM> <STOREPAIRCOST> <ASSIGN> value() <SEMICOLON>
	<PARAM> <INVSTORECOST>  <ASSIGN> value() <SEMICOLON>
	<PARAM> <NREGS>         <ASSIGN> value() <SEMICOLON>
	<PARAM> <NINSTS>        <ASSIGN> value() <SEMICOLON>
	<PARAM> <NLSMPSEUDOS>   <ASSIGN> value() <SEMICOLON>
	<PARAM> <NPSEUDOS>      <ASSIGN> value() <SEMICOLON>
	<PARAM> <NMOVES>        <ASSIGN> value() <SEMICOLON>
}


void callerSaveInfo() :
{}
{
        register() value()
}
void callInstInfo() :
{}
{
        instruction() value()
}
void moveInstInfo() :
{}
{
        instruction() value()
}
void jumpInstInfo() :
{}
{
        instruction() value()
}
void freqInfo() :
{}
{
        instruction() value()
}
void liveInfo(): 
{}
{
        instruction() pseudo() value()
}void reqInfo(): 
{}
{
        instruction() pseudo() value()
}void defInfo(): 
{}
{
        instruction() pseudo() value()
}void knownLoadInfo(): 
{}
{
        instruction() pseudo() value()
}
void liveHardRegInfo():
{}
{
        instruction() register() value()
}void defHardRegInfo():
{}
{
        instruction() register() value()
}void HRreqInfo():
{}
{
        instruction() register() value()
}
void basePseudoRegInfo() :
{}
{
        pseudo() pseudo()
}void equivInfo() :
{}
{
        pseudo() pseudo()
}

void baseHardRegInfo() :
{}
{
        pseudo() register()
}
void prevInstInfo() :
{}
{
        instruction() instruction() value()
}void prevInstsInfo() :
{}
{
        instruction() instruction() value()
}
void lsmPseudoInfo() :
{}
{
        pseudo() value()
}void memPseudoInfo() :
{}
{
        pseudo() value()
}void nsEdgeInfo() :
{}
{
        pseudo() pseudo() value()
}
void knownStoreInfo() :
{}
{
        instruction() pseudo() pseudo() value()
}
void knownHardStoreInfo() :
{}
{
        instruction() pseudo() pseudo() value()
}
void value() :
{}
{
<INTEGER_LITERAL>
}
void instruction() :
{}
{
<INTEGER_LITERAL>
}
void pseudo() :
{}
{
<INTEGER_LITERAL>
}
void register() :
{}
{
<INTEGER_LITERAL>
} 
void location() :
{}
{
<INTEGER_LITERAL>
}