Please direct any questions or comments to components@llnl.gov.
/*
* The following lexical tokens are ignored.
*/
SKIP : {
< " " >
| < "\n" >
| < "\r" >
| < "\t" >
| < "//" (~["\n","\r"])* ("\n" | "\r" | "\r\n") >
| < "/**/" >
| < "/*" (~["*"])+ "*" ("*" | ~["*","/"] (~["*"])* "*")* "/" > { checkComment(image, input_stream.getBeginLine(), input_stream.getEndLine()); }
| < "[" >
| < "]" >
}
/*
* The following lexical states define the transitions necessary to
* parse documentation comments. Documentation comments may appear
* anywhere in the file, although they are only saved if they preceed
* definition or method productions. Documentation comments are
* represented by "special tokens" in the token list.
*/
SPECIAL_TOKEN : {
< T_COMMENT : "/**" > : BEGIN_DOC_COMMENT
}
<BEGIN_DOC_COMMENT> SKIP : {
< " " >
| < "\t" >
| < "*/" > : DEFAULT
| < ("\n" | "\r" | "\r\n") > : LINE_DOC_COMMENT
| < "" > : IN_DOC_COMMENT
}
<LINE_DOC_COMMENT> SKIP : {
< " " >
| < "\t" >
| < "*/" > : DEFAULT
| < "*" (" ")?> : IN_DOC_COMMENT
| < "" > : IN_DOC_COMMENT
}
<IN_DOC_COMMENT> SPECIAL_TOKEN : {
< "*/" > { trimMatch(matchedToken); } : DEFAULT
| < ("\n" | "\r" | "\r\n") > { trimMatch(matchedToken); } : LINE_DOC_COMMENT
}
<IN_DOC_COMMENT> MORE : {
< ~[] >
}
/*
* The following keywords are the lexical tokens in the SIDL grammar.
*/
TOKEN : {
< T_ABSTRACT : "abstract" >
| < T_CLASS : "class" >
| < T_COPY : "copy" >
| < T_ENUM : "enum" >
| < T_EXTENDS : "extends" >
| < T_IMPORT : "import" >
| < T_IN : "in" >
| < T_INOUT : "inout" >
| < T_FINAL : "final" >
| < T_IMPLEMENTS : "implements" >
| < T_IMPLEMENTS_ALL : "implements-all" >
| < T_INTERFACE : "interface" >
| < T_LOCAL : "local" >
| < T_ONEWAY : "oneway" >
| < T_OUT : "out" >
| < T_PACKAGE : "package" >
| < T_REQUIRE : "require" >
| < T_STATIC : "static" >
| < T_THROWS : "throws" >
| < T_VERSION : "version" >
| < T_VOID : "void" >
| < T_ARRAY : "array" >
| < T_BOOLEAN : "bool" >
| < T_CHAR : "char" >
| < T_DCOMPLEX : "dcomplex" >
| < T_DOUBLE : "double" >
| < T_FCOMPLEX : "fcomplex" >
| < T_FLOAT : "float" >
| < T_INT : "int" >
| < T_LONG : "long" >
| < T_OPAQUE : "opaque" >
| < T_STRING : "string" >
| < T_IDENTIFIER : <T_LETTER> (<T_LETTER> | <T_DIGIT> | "_")* >
| < T_VERSION_STRING : <T_INTEGER> ("." <T_INTEGER>)+ >
| < T_INTEGER : (["-","+"])? (<T_DIGIT>)+ >
| < T_DIGIT : ["0"-"9"] >
| < T_LETTER : ["a"-"z","A"-"Z"] >
| < T_CLOSE_ANGLE : ">" >
| < T_CLOSE_CURLY : "}" >
| < T_CLOSE_PAREN : ")" >
| < T_COMMA : "," >
| < T_EQUALS : "=" >
| < T_OPEN_ANGLE : "<" >
| < T_OPEN_CURLY : "{" >
| < T_OPEN_PAREN : "(" >
| < T_SEMICOLON : ";" >
| < T_SCOPE : "." >
| < T_COLUMN_MAJOR : "column-major" >
| < T_ROW_MAJOR : "row-major" >
| < T_CATCH_ALL : ~[] >
}
/**
* A SIDL Specification contains zero or more version productions followed
* by zero or more import productions followed by zero or more package
* productions followed by the end-of-file. Before leaving the specification
* scope, resolve all references in the symbol table.
*/
Specification ::= ( Require )* ( Import )* ( Package )* <EOF>
/** * A SIDL Require production begins with a "require" token and is followed * by a scoped identifer, a "version" token, and a version number. The * scoped identifier must be not defined. The version number is specified * in the general form "V1.V2...Vn" where Vi is a non-negative integer. */ Require ::= <T_REQUIRE> ScopedIdentifier <T_VERSION> ( <T_INTEGER> | <T_VERSION_STRING> ) <T_SEMICOLON>
/** * A SIDL Import production begins with an "import" token and is followed * by a scoped identifier which is optionally followed by a "version" token * and a version number. The scoped identifier must be defined and it must * be a package. The version number is specified in the general form * "V1.V2...Vn" where Vi is a non-negative integer. A particular package * may only be included in one import statement. The import package name * is added to the default search path. At the end of the parse, any import * statements that were not used to resolve a symbol name are output as * warnings. */ Import ::= <T_IMPORT> ScopedIdentifier [ <T_VERSION> ( <T_INTEGER> | <T_VERSION_STRING>) ] <T_SEMICOLON>
/** * The SIDL package specification begins with a "package" token followed by * a scoped identifier. The new package namespace begins with an open curly * brace, a set of zero or more definitions, and a close curly brace. The * closing curly brace may be followed by an optional semicolon. The package * identifier must have a version defined for it, and it must not have been * previously defined as a symbol or used as a forward reference. The parent * of the package must itself be a package and must have been defined. The * symbols within the curly braces will be defined within the package scope. */ Package ::= [ <T_FINAL> ] <T_PACKAGE> ScopedIdentifier [ <T_VERSION> ( <T_INTEGER> | <T_VERSION_STRING> ) ] <T_OPEN_CURLY> ( Definition )* <T_CLOSE_CURLY> [ <T_SEMICOLON> ]
/** * A SIDL Definition production consists of a class, interface, enumerated * type, or package. */ Definition ::= ( Class | Enum | Interface | Package )
/** * A SIDL class specification begins with an optional abstract keyword * followed by the class token followed by an identifier. The abstract * keyword is required if and only if there are abstract methods in the * class. The class keyword is followed by an identifer. The identifier * string may not have been previously defined, although it may have been * used as a forward reference. The identifier string may be preceeded * by a documentation comment. A class may optionally extend another class; * if no class is specified, then the class will automatically extend the * SIDL base class (unless it is itself the SIDL base class). Then parse * the implements-all and implements clauses. The interfaces parsed during * implements-all are saved in a set and then all those methods are defined * at the end of the class definition. The methods block begins with an * open curly-brace followed by zero or more methods followed by a close * curly-brace and optional semicolon. */ Class ::= [ <T_ABSTRACT> ] <T_CLASS> Identifier [ <T_EXTENDS> ScopedIdentifier ] [ <T_IMPLEMENTS_ALL> AddInterface ( <T_COMMA> AddInterface )* ] [ <T_IMPLEMENTS> AddInterface ( <T_COMMA> AddInterface )* ] <T_OPEN_CURLY> ( ClassMethod )* <T_CLOSE_CURLY> [ <T_SEMICOLON> ]
/** * The SIDL enumeration specification begins with an "enum" token followed by * an identifier. The enumerator list begins with an open curly brace, a set * of one or more definitions, and a close curly brace. The closing curly * brace may be followed by an optional semicolon. The enumeration symbol * identifier must have a version defined for it, and it must not have been * previously defined as a symbol. Forward references are not allowed for * enumerated types. This routine creates the enumerated class and then * grabs the list of enumeration symbols and their optional values. */ Enum ::= <T_ENUM> Identifier <T_OPEN_CURLY> Enumerator ( <T_COMMA> Enumerator )* <T_CLOSE_CURLY> [ <T_SEMICOLON> ]
/** * The SIDL enumerator specification consists of an identifier followed * by an optional assignment statement beginning with an equals and followed * by an integer value. This routine adds the new enumeration symbol to * the list and then returns. */ Enumerator ::= Identifier [ <T_EQUALS> <T_INTEGER> ]
/** * A SIDL interface specification begins with the interface token followed * by an identifier. An interface may have an extends block consisting of * a comma-separated sequence of interfaces. The methods block begins with * an open curly-brace followed by zero or more methods followed by a close * curly-brace and optional semicolon. Interfaces may be preceeded by a * documentation comment. The identifier string may not have been previously * defined, although it may have been used as a forward reference. If the * interface does not extend another interface, then it must extend the base * SIDL interface (unless, of course, this is the definition for the base * SIDL interface). */ Interface ::= <T_INTERFACE> Identifier [ <T_EXTENDS> AddInterface ( <T_COMMA> AddInterface )* ] <T_OPEN_CURLY> ( InterfaceMethod )* <T_CLOSE_CURLY> [ <T_SEMICOLON> ]
/** * This production parses the next scoped identifier and validates that * the name exists and is an interface symbol. Then each of its methods * are checked for validity with the existing methods. If everything * checks out, then the new interface is added to the existing object. */ AddInterface ::= ScopedIdentifier
/** * This production parses the SIDL method description for a class method. * A class method may start with abstract, final, or static. An error is * thrown if the method has already been defined in the class object or if * the method name is the same as the class name. An error is also thrown * if a method has been defined in a parent class and (1) the signatures * do not match, (2) either of the methods is static, (3) the existing method * is final, or (4) the new method is abstract but the existing method was * not abstract. */ ClassMethod ::= [ ( <T_ABSTRACT> | <T_FINAL> | <T_STATIC> ) ] Method
/** * This method parses a SIDL method and then checks whether it can be * added to the interface object. An error is thrown if the method has * already been added to the interface object or if the method name is * the same as the interface name. An error is also thrown if a previous * method was defined with the same name but a different signature. */ InterfaceMethod ::= Method
/** * The SIDL method production has a return type, a method identifier, * an optional argument list, an optional communication modifier, and * an optional throws clause. The return type may be void (no return * type) or any valid SIDL type. The method is built piece by piece. */ Method ::= ( <T_VOID> | [ <T_COPY> ] Type() ) Identifier [ <T_IDENTIFIER> ] <T_OPEN_PAREN> [ Argument ( <T_COMMA> Argument )* ] <T_CLOSE_PAREN> [ <T_LOCAL> | <T_ONEWAY> ] [ <T_THROWS> ScopedIdentifier ( <T_COMMA> ScopedIdentifier )* ] <T_SEMICOLON>
/** * Parse a SIDL argument. Arguments begin with an optional copy modifier * followed by in, out, or inout followed by a type and a formal argument. * The argument is returned on the top of the argument stack. This routine * also checks that the copy modifier is used only for symbol objects. For * all other types, copy is redundant. */ Argument ::= [ <T_COPY> ] ( <T_IN> | <T_OUT> | <T_INOUT> ) Type Identifier
/** * A SIDL type consists of one of the standard built-in types (boolean, * char, dcomplex, double, fcomplex, float, int, long, opaque, and string), * a user-defined type (interface, class, or enum), or an array. This * production parses the type and pushes the resulting type object on * the top of the argument stack. */ Type ::= ( <T_BOOLEAN> | <T_CHAR> | <T_DCOMPLEX> | <T_DOUBLE> | <T_FCOMPLEX> | <T_FLOAT> | <T_INT> | <T_LONG> | <T_OPAQUE> | <T_STRING> | Array | SymbolType )
/** * Parse an array construct and push the resulting type and ordering on top of * the stack. Only dimensions one through MAX_ARRAY_DIM (inclusive) are * supported. */ Array ::= <T_ARRAY> <T_OPEN_ANGLE> Type [ <T_COMMA> ( <T_INTEGER> [ <T_COMMA> ( <T_COLUMN_MAJOR> | <T_ROW_MAJOR> ) ] | ( <T_COLUMN_MAJOR>| <T_ROW_MAJOR> ) ) ] <T_CLOSE_ANGLE>
/** * This production parses a scoped identifier and verifies that it is * either a forward reference or a symbol that may be used as a type * (either an enum, an interface, or a class). */ SymbolType ::= ScopedIdentifier
/** * All SIDL scoped names are of the general form "ID ( . ID )*". Each * identifier ID is a string of letters, numbers, and underscores that * must begin with a letter. The scope resolution operator "." separates * the identifiers in a name. */ ScopedIdentifier ::= Identifier ( <T_SCOPE> Identifier )*
/** * A SIDL identifier must start with a letter and may be followed by any * number of letters, numbers, or underscores. It may not be a reserved * word in any of the SIDL implementation languages (e.g., C or C++). */ Identifier ::= <T_IDENTIFIER>