/*
 *
 *  RPC grammar for JavaCC
 *
 *  Contributed by Adelene Ng (awln@asia1.com>
 *
 *  Date: 06/26/01
 *  Version: 01
 *
 *  References: 
 *  1. XDR: External Data Representation Standard, rfc1832, R. Srinivasan, 
 *     Aug 1995
 *  2. RPC: Remote Procedure Call Specification Version 2, rfc1831, 
 *     R. Srinivasan, Aug 1995 
 *  3. Power Programming with RPC, John Bloomer, O'Reilly
 *
 */

options {
	LOOKAHEAD = 2;
}

PARSER_BEGIN(rpc)

public class rpc {
	public static void main(String args[]) {
		rpc rpcparser;
		if(args.length == 0) {
        		System.out.println("RPC Parser Version 0.1 Alpha:  Reading from standard input . . .");
			rpcparser = new rpc(System.in);
      			}
      		else if(args.length == 1) {
        		System.out.println("RPC Parser Version 0.1 Alpha:  Reading from file " + args[0] + " . . ." );
      			try {
        			rpcparser = new rpc(new java.io.FileInputStream(args[0]));
      			}
		        catch(java.io.FileNotFoundException e) {
        			System.out.println("RPC Parser Version 0.1:  File " + args[0] + " not found.");
        			return ;
        		}
      		}
      		else {
		        System.out.println("RPC Parser Version 0.1Alpha:  Usage is one of:");
       			System.out.println("         java rpc < inputfile");
        		System.out.println("OR");
        		System.out.println("         java rpc inputfile");
        		return ;
      		}
      		try {
        		rpcparser.TranslationUnit();
        		System.out.println("RPC Parser Version 0.1 Alpha:  RPC program parsed successfully.");
      		}
      		catch(ParseException e){
        		System.out.println("RPC Parser Version 0.1 Alpha:  Encountered errors during parse.");
      		}
	}
}


PARSER_END(rpc)

SKIP : {
 " "
|  "\t"
|  "\n"
|  "\r"
|  <"//" (~["\n","\r"])* ("\n" | "\r" | "\r\n")>
|  <"/*" (~["*"])* "*" ("*" | ~["*","/"] (~["*"])* "*")* "/">
}

TOKEN : 
{
	<FLOAT: "float"> |
	<DOUBLE: "double"> |
	<QUADRUPLE: "quadruple"> |
	<BOOL: "bool"> |
	<INT: "int"> |
	<HYPER: "hyper"> |
	<UNSIGNED: "unsigned"> |
	<STRUCT: "struct"> |
	<TYPEDEF: "typedef"> |
	<ENUM: "enum"> |
	<UNION: "union"> |
	<CASE: "case"> |
	<SWITCH: "switch"> |
	<DEF: "default"> |
	<CONST: "const"> |
	<OPAQUE: "opaque"> |
	<STRING: "string"> |
	<VOID: "void"> |
	<PROGRAM: "program"> |
	<VERSION: "version">
}

TOKEN : 
{
<IDENTIFIER: <LETTER> (<LETTER> | <DIGIT>)*>
|  <#LETTER: ["$","A"-"Z","_","a"-"z"]>
|  <#DIGIT: ["0"-"9"]>
}

TOKEN : 
{
<NUMBER: ( <DIGIT> )+>
}


void TranslationUnit() :
{
}
{
//specification() [program_def()] specification() 
specification()
}

void declaration() : 
{
}
{
(type_specifier() ( "*" )* <IDENTIFIER> [ ("[" value() "]") ]  [ ("<" [ value() ] ">") ])
| (<OPAQUE> <IDENTIFIER> (("[" value() "]") | ("<" (value())* ">")) )
| (<STRING> <IDENTIFIER> "<" (value())* ">" )
| <VOID>
}

void value() : 
{
}
{
<NUMBER> | <IDENTIFIER>
}

void type_specifier() : 
{
}
{
((<UNSIGNED>)* <INT>)
| ((<UNSIGNED>)* <HYPER>)
| <FLOAT>
| <DOUBLE>
| <QUADRUPLE>
| <BOOL>
| <IDENTIFIER>
| <VOID>
| enum_type_spec()
| struct_type_spec()
| union_type_spec()
}

void enum_type_spec() : 
{
}
{
<ENUM> enum_body()
}

void enum_body() : 
{
}
{
"{"
	( <IDENTIFIER> "=" value())
	( "," <IDENTIFIER> "=" value())*
"}"
}

void struct_type_spec() : 
{
}
{
<STRUCT> struct_body()
}

void struct_body() : 
{
}
{
"{"
	(declaration() ";") 
	(declaration() ";")* 
"}"
}

void union_type_spec() : 
{
}
{
<UNION> union_body()
}

void union_body() : 
{
}
{
<SWITCH> "(" declaration() ")" "{"
	(<CASE> value() ":" declaration() ";")
	(<CASE> value() ":" declaration() ";")*
	(<DEF> ":" declaration() ";")*
	"}"
}

void constant_def() : 
{
}
{
<CONST> <IDENTIFIER> "=" <NUMBER> ";"
}

void type_def() : 
{
}
{
(<TYPEDEF> declaration() ";") 
| (<ENUM> <IDENTIFIER> enum_body() ";") 
| (<STRUCT> <IDENTIFIER> struct_body() ";")
| (<UNION> <IDENTIFIER> union_body() ";")
}

void definition() : 
{
}
{
type_def() | constant_def() | program_def()
}

void specification() : 
{
}
{
(definition())+
}

void program_def() :
{
}
{
<PROGRAM> <IDENTIFIER> "{"
	version_def() [ version_def() ]
"}" "=" <NUMBER> ";"
}

void version_def() :
{
}
{
<VERSION> <IDENTIFIER> "{"
	procedure_def() [ procedure_def() ]
"}" "=" <NUMBER> ";"
}

void procedure_def() :
{
}
{
type_specifier() <IDENTIFIER> "(" type_specifier() ( "," type_specifier() )* ")" "=" <NUMBER> ";"
}