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>