// VRML `deluxe': better, smaller syntax and generic/extensible field types

options {
	USER_TOKEN_MANAGER=false;
	STATIC=false;
	ERROR_REPORTING=false;
}


/* scoping rules:
 * USE and ROUTE refer to the lexically most recent DEF.
 * The scene root, and each PROTO and Inline statement has a separate scope.
 */


PARSER_BEGIN(VrmlParser)

public class VrmlParser {

	VrmlParser() {}

	//construct(String ) {}

	print(String s) {
		System.err.println(s);
	}
}

PARSER_END(VrmlParser)


<*> SKIP : {
	 "\n"
	|"\r"
	|" "
	|"\t"
	|","
//	|"\f"
}

<*> SPECIAL_TOKEN : {
	<COMMENT: "#" (~["\n","\r"])* ("\n"|"\r"|"\r\n")>
}


void vrmlScene(): {} {
	( statement() )*
	<EOF>
}

void statement(): {} {
	  nodeStatement() {
	}
	| protoStatement() {
	}
	| routeStatement() {
	}
}


void nodeStatement(): {} {
	  node() {}
	| <DEF> nodeNameId() node() {}
	| <USE> nodeNameId() {}
}

TOKEN : {
	 <DEF: "DEF">
	|<USE: "USE">
}


void rootNodeStatement(): {} {
	  node() {}
	| <DEF> nodeNameId() node() {}
}

void protoStatement(): {} {
	  proto() {}
	| externproto() {}
}

void proto(): {} {
     <PROTO> nodeTypeId() <LSQBR> ( interfaceDeclaration() )* <RSQBR>
	 <LBRACE> protoBody() <RBRACE> {}
}

TOKEN : {
	 <LSQBR: "[">
	|<RSQBR: "]">
	|<LBRACE: "{">
	|<RBRACE: "}">
	|<DOT: ".">
}

void protoBody(): {} {
     ( protoStatement() )* rootNodeStatement() ( statement() )* {}
}

// this new nonterminal was introduced to reduce redundancy in grammar
void commonInterfaceDeclaration(): {} {
	  <eventIn> fieldType() eventInId() {}
	| <eventOut> fieldType() eventOutId() {}
}

void restrictedInterfaceDeclaration(): {} {
	  commonInterfaceDeclaration()
	| <field> fieldType() fieldId() fieldValue() {}
}

TOKEN : {
	 <eventIn: "eventIn">
	|<eventOut: "eventOut">
	|<field: "field">
	|<exposedField: "exposedField">
}

void interfaceDeclaration(): {} {
	  restrictedInterfaceDeclaration()
	| <exposedField> fieldType() fieldId() fieldValue() {}
}

void externproto(): {} {
     <EXTERNPROTO> nodeTypeId()
	 <LSQBR> ( externInterfaceDeclaration() )* <RSQBR> URLList() {}
}

TOKEN : {
	 <PROTO: "PROTO">
	|<EXTERNPROTO: "EXTERNPROTO">
}

void externInterfaceDeclaration(): {} {
	  commonInterfaceDeclaration()
	| <field> fieldType() fieldId()
	| <exposedField> fieldType() fieldId()
}

void routeStatement(): {} {
	<ROUTE> nodeNameId() <DOT> eventOutId() <TO> nodeNameId() <DOT> eventInId()
}

TOKEN : {
	 <ROUTE: "ROUTE">
	|<TO: "TO">
}

// The spec prescribes mfstringValue() rather than fieldValue(). We use the
// more generic fieldValue() here, and leave type checking to semantic
// analysis.
void URLList(): {} {
	fieldValue()
}


void node(): {} { 
	  nodeTypeId() <LBRACE> ( nodeBodyElement() )* <RBRACE>
	| <Script> <LBRACE> ( scriptBodyElement() )* <RBRACE> 
}

TOKEN : {
	 <Script: "Script">
	|<IS: "IS">
}

// this rule is an equivalent to the original (which is not LALR(1)!).
void scriptBodyElement(): {} {
	  nodeBodyElement()
	| <eventIn> fieldType() eventInId() [ <IS> eventInId() ] {}
	| <eventOut> fieldType() eventOutId() [ <IS> eventOutId() ] {}
	| <field> fieldType() fieldId() ( fieldValue() | <IS> fieldId() ) {}
}

// Rule simplified to make parseable at all. We have to check semantically
// whether we're dealing with a field, an eventin, or an eventout.
void nodeBodyElement(): {} {
	  <Id> ( fieldValue() | <IS> <Id> )
	| routeStatement()
	| protoStatement()
}

void nodeNameId(): {} {
	<Id>
}

void nodeTypeId(): {} {
	<Id>
}

void fieldId(): {} {
	<Id>
}

void eventInId(): {} {
	<Id>
}

void eventOutId(): {} {
	<Id>
}

// The type identifier is parsed during semantic analysis. (In fact, the type
// identifiers in the ISO spec are NOT keywords, i.e. their names might be
// used as identifiers elsewhere, so they cannot be parsed as tokens as the
// spec suggests!)
void fieldType(): {} {
	<Id>
}

//void fieldType(): {} {
//	  <MFColor>
//	| <MFFloat>
//	| <MFInt32>
//	| <MFNode>
//	| <MFRotation>
//	| <MFString>
//	| <MFTime>
//	| <MFVec2f>
//	| <MFVec3f>
//	| <SFBool>
//	| <SFColor>
//	| <SFFloat>
//	| <SFImage>
//	| <SFInt32>
//	| <SFNode>
//	| <SFRotation>
//	| <SFString>
//	| <SFTime>
//	| <SFVec2f>
//	| <SFVec3f>
//}

// XXX these are not really tokens!
//TOKEN : {
//	  <MFColor: "MFColor">
//	| <MFFloat: "MFFloat">
//	| <MFInt32: "MFInt32">
//	| <MFNode: "MFNode">
//	| <MFRotation: "MFRotation">
//	| <MFString: "MFString">
//	| <MFTime: "MFTime">
//	| <MFVec2f: "MFVec2f">
//	| <MFVec3f: "MFVec3f">
//	| <SFBool: "SFBool">
//	| <SFColor: "SFColor">
//	| <SFFloat: "SFFloat">
//	| <SFImage: "SFImage">
//	| <SFInt32: "SFInt32">
//	| <SFNode: "SFNode">
//	| <SFRotation: "SFRotation">
//	| <SFString: "SFString">
//	| <SFTime: "SFTime">
//	| <SFVec2f: "SFVec2f">
//	| <SFVec3f: "SFVec3f">
//}

//void fieldValue(): {} {
//	  sfboolValue()
//	| sfcolorValue()
//	| sffloatValue()
//	| sfimageValue()
//	| sfint32Value()
//	| sfnodeValue()
//	| sfrotationValue()
//	| sfstringValue()
//	| sftimeValue()
//	| sfvec2fValue()
//	| sfvec3fValue()
//	| mfcolorValue()
//	| mffloatValue()
//	| mfint32Value()
//	| mfnodeValue()
//	| mfrotationValue()
//	| mfstringValue()
//	| mftimeValue()
//	| mfvec2fValue()
//	| mfvec3fValue()
//}

// Unlike the ISO grammar, we don't have a fixed set of specific types but
// rather, allow any combination of the supported tokens and square-bracketed
// lists of tokens. The checking with the actual type needed is done during
// semantic analysis.
void fieldValue(): {} {
	  <TRUE>
	| <FALSE>
	| <int32>
	| <string>
	| <Float>
	| <Double>
	| <LSQBR> ( fieldValue() )* <RSQBR>
	| nodeStatement()
	| <NULL>
}


TOKEN : {
	 <TRUE: "TRUE">
	|<FALSE: "FALSE">
	|<NULL: "NULL">
}

//void sfboolValue(): {} { 
//	  <TRUE>
//	| <FALSE>
//}
//
//void sfcolorValue(): {} {
//	<Float> <Float> <Float>
//}
//
//void sffloatValue(): {} {
//	<Float>
//}
//
//void sfimageValue(): {} {
//     ( <int32> )*   // is this what is meant by `int32 int32 int32 ...'?
//}
//
//void sfint32Value(): {} {
//	<int32>
//}
//
//void sfnodeValue(): {} { 
//	  nodeStatement()
//	| <NULL>
//}
//
//void sfrotationValue(): {} {
//	<Float> <Float> <Float> <Float>
//}
//
//void sfstringValue(): {} {
//	<string>
//}
//
//void sftimeValue(): {} {
//	<Double>
//}
//
//void sfvec2fValue(): {} {
//	<Float> <Float>
//}
//
//
//void mftimeValue(): {} {
//	  sftimeValue()
//	| <LSQBR> ( sftimeValue() )* <RSQBR>
//}
//
//void sfvec3fValue(): {} {
//	<Float> <Float> <Float>
//}
//
//void mfcolorValue(): {} {
//	  sfcolorValue()
//	| <LSQBR> ( sfcolorValue() )* <RSQBR>
//}
//
//void mffloatValue(): {} {
//	  sffloatValue()
//	| <LSQBR> ( sffloatValue() )* <RSQBR>
//}
//
//void mfint32Value(): {} {
//	  sfint32Value()
//	| <LSQBR> ( sfint32Value() )* <RSQBR>
//}
//
//void mfnodeValue(): {} {
//	  nodeStatement()
//	| <LSQBR> ( nodeStatement() )* <RSQBR>
//}
//
//void mfrotationValue(): {} {
//	  sfrotationValue()
//	| <LSQBR> ( sfrotationValue() )* <RSQBR>
//}
//
//void mfstringValue(): {} {
//	  sfstringValue()
//	| <LSQBR> ( sfstringValue() )* <RSQBR>
//}
//
//void mfvec2fValue(): {} {
//	  sfvec2fValue()
//	| <LSQBR> ( sfvec2fValue() )* <RSQBR>
//}
//
//void mfvec3fValue(): {} {
//	  sfvec3fValue()
//	| <LSQBR> ( sfvec3fValue() )* <RSQBR>
//}

// These specs are optimised for performance
TOKEN : {
    // ISO spec is:
	//     ([+/-]?((([0-9]+(\.)?)|([0-9]*\.[0-9]+))([eE][+\-]?[0-9]+)?))
	// This spec is less restrictive about the placement of `.'.
	 <Float:
	     (["+","-"])?
	     (["0"-"9","."])+
	     (["e","E"]  (["+","-"])?  (["0"-"9"])+ )? >

	// same as Float
	|<Double:
	     (["+","-"])?
	     (["0"-"9","."])+
	     (["e","E"]  (["+","-"])?  (["0"-"9"])+ )? >

    // ISO spec is:
	//     ([+\-]?(([0-9]+)|(0[xX][0-9a-fA-F]+)))
	// This spec is less restrictive about the placement of `0' and `x'
	|<int32:
	     (["+","-"])? (["0"-"9", "x", "X", "a"-"f", "A"-"F"])+ >

	// ISO spec is:
	//     (".*"), double-quotes must be '\"', backslashes must be '\\'
	|<string:
	     ( "\"" )
		 ( (~["\\","\""]) | "\\" (["\"","\\"]) )*
		 ( "\"" )  >
}


TOKEN : {
	// IdFirstChar ::= 
	//     Any ISO-10646 character encoded using UTF-8 except:
	//     0x30-0x39, 0x0-0x20, 0x22, 0x23, 0x27, 0x2b, 0x2c, 0x2d, 0x2e, 0x5b,
	//     0x5c, 0x5d, 0x7b, 0x7d, 0x7f ; 
	// IdRestChars ::= 
	//     Any number of ISO-10646 characters except:
	//     0x0-0x20, 0x22, 0x23, 0x27, 0x2c, 0x2e, 0x5b, 0x5c, 0x5d,
	//     0x7b, 0x7d, 0x7f ; 
	<Id:
	     (["!", "$"-"%", "("-"*", "/", ":"-"Z", "^"-"z", "|", "~"])
	     (["!", "$"-"%", "("-"+", "-", "/"-"Z", "^"-"z", "|", "~"])* >
}