parser.jj
|
//========================================================== -*- Java -*- === // The ILOG Rules parser //=========================================================================== options { STATIC = false; JAVA_UNICODE_ESCAPE = true; CACHE_TOKENS = true; USER_CHAR_STREAM = true; } //--------------------------------------------------------------------------- // The parser class definition //--------------------------------------------------------------------------- PARSER_BEGIN(IlrParser) package ilog.rules.parser; import ilog.rules.factory.*; import ilog.rules.util.prefs.IlrMessages; import java.util.*; import java.io.*; class IlrParser { IlrRulesetParser rulesetParser; private static final int PredEQ = 1; private static final int PredNE = 2; private static final int PredLT = 3; private static final int PredLE = 4; private static final int PredGT = 5; private static final int PredGE = 6; // Modified for in and !in predicate private static final int PredIN = 7; private static final int PredNIN = 8; // End - Modified for in and !in predicate private static final int SimpleClassExpr = 1; private static final int NotClassExpr = 2; private static final int ExistsClassExpr = 3; private static final int CollectClassExpr = 4; private int flowIndex = 1; private Token lastCommonTaskToken=null; private Number parseIntegerLiteral(Token t,int sign) { IlrRulesetParser parser = rulesetParser; String str = t.image; int len = str.length(); char last = str.charAt(len-1); String prefix = (sign == 1) ? "" : "-"; if (Character.toLowerCase(last) != 'l') { try { String value = str; if (value.startsWith("0x")) return Integer.valueOf(prefix + value.substring(2),16); if (value.startsWith("0") && value.length() > 1) return Integer.valueOf(prefix + value.substring(1),8); return Integer.valueOf(prefix + value); } catch(NumberFormatException ex) { String msg = IlrMessages.format("messages.Parsing.0", str); parser.reporter.insertException(parser,t,msg); return new Integer(0); } } try { String value = str.substring(0,len-1); if (value.startsWith("0x")) return Long.valueOf(prefix + value.substring(2),16); if (value.startsWith("0") && value.length() > 1) return Long.valueOf(prefix + value.substring(1),8); return Long.valueOf(prefix + value); } catch(NumberFormatException ex) { String msg = IlrMessages.format("messages.Parsing.1", str); parser.reporter.insertException(parser,t,msg); return new Long(0); } } private Number parseFloatLiteral(Token t,int sign) { IlrRulesetParser parser = rulesetParser; String str = t.image; int len = str.length(); char last = str.charAt(len-1); // This is true if we are in double mode for float literals boolean doubleType = false; String valuestring; String prefix = (sign == 1) ? "" : "-"; if (Character.toLowerCase(last) == 'f') { doubleType = false; valuestring = prefix + str.substring(0,len-1); } else if (Character.toLowerCase(last) == 'd') { doubleType = true; valuestring = prefix + str.substring(0,len-1); } else if (rulesetParser.reflect.getDoubleModeForLiterals()) { // we are in the new double literal mode set for C++ doubleType = true; valuestring = prefix + str; } else { // we are in the old compatible float mode for JRules. doubleType = false; valuestring = prefix + str; } if (!doubleType) { try { Float x = Float.valueOf(valuestring); if (x.isInfinite()) { String msg = IlrMessages.format("messages.Parsing.2", str); parser.reporter.insertException(parser,t,msg); } return x; } catch(NumberFormatException ex) { String msg = IlrMessages.format("messages.Parsing.3", str); parser.reporter.insertException(parser,t,msg); return new Float(0); } } else { try { Double x = Double.valueOf(valuestring); if (x.isInfinite()) { String msg = IlrMessages.format("messages.Parsing.4", str); parser.reporter.insertException(parser,t,msg); } return x; } catch(NumberFormatException ex) { String msg = IlrMessages.format("messages.Parsing.5", str); parser.reporter.insertException(parser,t,msg); return new Double(0); } } } private static Character parseCharacterLiteral(String str) { int index = 0; char input = str.charAt(index++); if (input != '\\') return new Character(input); // Now, we have an escape sequence character! input = str.charAt(index++); switch(input) { case 'n': return new Character('\n'); case 't': return new Character('\t'); case 'b': return new Character('\b'); case 'r': return new Character('\r'); case 'f': return new Character('\f'); case '\\': return new Character('\\'); case '\'': return new Character('\''); case '\"': return new Character('\"'); } return null; } private static String parseStringLiteral(String str) { int len = str.length(); StringBuffer buffer = new StringBuffer(len); char input; int index = 0; while (index < len) { input = str.charAt(index++); if (input != '\\') { buffer.append(input); continue; } // Now, we have an escape sequence character! input = str.charAt(index++); switch(input) { case 'n': buffer.append('\n'); break; case 't': buffer.append('\t'); break; case 'b': buffer.append('\b'); break; case 'r': buffer.append('\r'); break; case 'f': buffer.append('\f'); break; case '\\': buffer.append('\\'); break; case '\'': buffer.append('\''); break; case '\"': buffer.append('\"'); break; } } return buffer.toString(); } private String syncOn(String[] arr) { String found = null; int len = arr.length; Token t; while ((t = getToken(1)) != null) { if (t.kind == EOF) break; for (int i = 0; i < len; i++) { if (t.image.equals(arr[i])) { found = arr[i]; break; } } if (found != null) break; else getNextToken(); } return found; } }; PARSER_END(IlrParser) //--------------------------------------------------------------------------- // White spaces to be skipped //--------------------------------------------------------------------------- SKIP: { " " | "\t" | "\n" | "\r" | "\f" } MORE: { "//" : IN_SINGLE_LINE_COMMENT | <"/**" ~["/"]> : IN_FORMAL_COMMENT | "/*" : IN_MULTI_LINE_COMMENT } <IN_SINGLE_LINE_COMMENT>SPECIAL_TOKEN : { <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : DEFAULT } <IN_FORMAL_COMMENT>SPECIAL_TOKEN: { <FORMAL_COMMENT: "*/" > { // Removes the first 3 characters and the last 2 characters // from the matched string String sstr = image.toString(); int slen = sstr.length(); matchedToken.image = sstr.substring(3,slen-2); } : DEFAULT } <IN_MULTI_LINE_COMMENT> SPECIAL_TOKEN : { <MULTI_LINE_COMMENT: "*/"> : DEFAULT } <IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT> MORE : { < ~[] > } //--------------------------------------------------------------------------- // Reserved words of the rule language //--------------------------------------------------------------------------- TOKEN : { <IMPORT: "import"> | <USING: "using"> | <NEW: "new"> | <SETUP: "setup"> | <RULESET: "ruleset"> | <RULE: "rule"> | <PROPERTY: "property"> | <PRIORITY: "priority"> | <PACKET: "packet"> | <WHEN: "when"> | <THEN: "then"> | <NOT: "not"> | <EXISTS: "exists"> | <COLLECT: "collect"> | <WHERE: "where"> | <FROM: "from"> | <IN: "in"> | <LOGICAL: "logical"> | <EVENT: "event"> | <WAIT: "wait"> | <UNTIL: "until"> | <EVALUATE: "evaluate"> | <REFRESH: "refresh"> | <ASSERT: "assert"> | <INSERT: "insert"> | <RETRACT: "retract"> | <UPDATE: "update"> | <APPLY: "apply"> | <MODIFY: "modify"> | <BIND: "bind"> | <VAR: "var"> | <EXECUTE: "execute"> | <WHILE: "while"> | <FOR: "for"> | <FUNCTION: "function"> | <RETURN: "return"> | <BREAK: "break"> | <CONTINUE: "continue"> | <IF: "if"> | <ELSE: "else"> | <TIMEOUT: "timeout"> | <INSTANCEOF: "instanceof"> | <IS: "is"> | <TIMEOF: "timeof"> | <OCCURSIN: "occursin"> | <BEFORE: "before"> | <AFTER: "after"> | <DOLLARSIGN: "$"> | <THROW: "throw"> | <TRY: "try"> | <CATCH: "catch"> | <FINALLY: "finally"> | <UNKNOWN: "isunknown"> | <KNOWN: "isknown"> | <RULETASK: "ruletask"> | <FUNCTIONTASK: "functiontask"> | <FLOWTASK: "flowtask"> | <BODY: "body"> | <SWITCH: "switch"> | <CASE: "case"> | <DEFLT: "default"> | <FORK: "fork"> | <GOTO: "goto"> | <OUT: "out"> | <INOUT: "inout"> | <INITIALACTION: "initialaction"> | <FINALACTION: "finalaction"> | <FIRING: "firing"> | <FIRINGLIMIT: "firinglimit"> | <ORDERING: "ordering"> | <SELECT: "select"> | <DYNSELECT: "dynamicselect"> | <FILTER: "filter"> | <AGENDAFILTER: "agendafilter"> | <COMPLETIONFLAG: "completionflag"> | <INSTANCES: "instances"> | <HASHER: "hasher"> | <ITERATOR: "iterator"> | <MATCHEDCLASSES: "matchedclasses"> | <ALGORITHM: "algorithm"> } //--------------------------------------------------------------------------- // Some constants //--------------------------------------------------------------------------- TOKEN : { <NULL: "null"> | <TRUE: "true"> | <FALSE: "false"> } //--------------------------------------------------------------------------- // Literals // Warning: for Character & String literals, octal escape sequences // are not supported! //--------------------------------------------------------------------------- TOKEN : { <INTEGER_LITERAL: <DECIMAL_LITERAL> (["l","L"])? | <HEX_LITERAL> (["l","L"])? | <OCTAL_LITERAL> (["l","L"])? > | < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* > | < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ > | < #OCTAL_LITERAL: "0" (["0"-"7"])* > | < FLOATING_POINT_LITERAL: (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])? | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])? | (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])? | (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"] > | <#EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ > | <CHARACTER_LITERAL: "'" ( (~["'","\\","\n","\r"]) | ("\\" ( ["n","t","b","r","f","\\","'","\""] )) ) "'" > { String cstr = image.toString(); int clen = cstr.length(); matchedToken.image = cstr.substring(1,clen-1); } | <STRING_LITERAL: "\"" ( (~["\"","\\","\n","\r"]) | ("\\" ( ["n","t","b","r","f","\\","'","\""] )) )* "\"" > { String sstr = image.toString(); int slen = sstr.length(); matchedToken.image = sstr.substring(1,slen-1); } } //--------------------------------------------------------------------------- // Identifiers // Very important: see also ilog.rules.tests.IlrUnicharGenerator class // which is used to generate the character ranges. //--------------------------------------------------------------------------- TOKEN : { <IDENTIFIER: <LETTER> (<FOLLOWING>)*> | <#LETTER: [ "\u8000"-"\u9fa5", "\uac00"-"\ud7a3", "\uf900"-"\ufa2d", "\ufb00"-"\ufb06", "\ufb13"-"\ufb17", "\ufb1f"-"\ufb28", "\ufb2a"-"\ufb36", "\ufb38"-"\ufb3c", "\ufb3e"-"\ufb3e", "\ufb40"-"\ufb41", "\ufb43"-"\ufb44", "\ufb46"-"\ufbb1", "\ufbd3"-"\ufd3d", "\ufd50"-"\ufd8f", "\ufd92"-"\ufdc7", "\ufdf0"-"\ufdfb", "\ufe33"-"\ufe34", "\ufe4d"-"\ufe4f", "\ufe69"-"\ufe69", "\ufe70"-"\ufe72", "\ufe74"-"\ufe74", "\ufe76"-"\ufefc", "\uff04"-"\uff04", "\uff21"-"\uff3a", "\uff3f"-"\uff3f", "\uff41"-"\uff5a", "\uff66"-"\uffbe", "\uffc2"-"\uffc7", "\uffca"-"\uffcf", "\uffd2"-"\uffd7", "\uffda"-"\uffdc", "\uffe0"-"\uffe1", "\uffe5"-"\uffe6", "\u0024"-"\u0024", "\u0041"-"\u005a", "\u005f"-"\u005f", "\u0061"-"\u007a", "\u00a2"-"\u00a5", "\u00aa"-"\u00aa", "\u00b5"-"\u00b5", "\u00ba"-"\u00ba", "\u00c0"-"\u00d6", "\u00d8"-"\u00f6", "\u00f8"-"\u01f5", "\u01fa"-"\u0217", "\u0250"-"\u02a8", "\u02b0"-"\u02b8", "\u02bb"-"\u02c1", "\u02d0"-"\u02d1", "\u02e0"-"\u02e4", "\u037a"-"\u037a", "\u0386"-"\u0386", "\u0388"-"\u038a", "\u038c"-"\u038c", "\u038e"-"\u03a1", "\u03a3"-"\u03ce", "\u03d0"-"\u03d6", "\u03da"-"\u03da", "\u03dc"-"\u03dc", "\u03de"-"\u03de", "\u03e0"-"\u03e0", "\u03e2"-"\u03f3", "\u0401"-"\u040c", "\u040e"-"\u044f", "\u0451"-"\u045c", "\u045e"-"\u0481", "\u0490"-"\u04c4", "\u04c7"-"\u04c8", "\u04cb"-"\u04cc", "\u04d0"-"\u04eb", "\u04ee"-"\u04f5", "\u04f8"-"\u04f9", "\u0531"-"\u0556", "\u0559"-"\u0559", "\u0561"-"\u0587", "\u05d0"-"\u05ea", "\u05f0"-"\u05f2", "\u0621"-"\u063a", "\u0640"-"\u064a", "\u0671"-"\u06b7", "\u06ba"-"\u06be", "\u06c0"-"\u06ce", "\u06d0"-"\u06d3", "\u06d5"-"\u06d5", "\u06e5"-"\u06e6", "\u0905"-"\u0939", "\u093d"-"\u093d", "\u0958"-"\u0961", "\u0985"-"\u098c", "\u098f"-"\u0990", "\u0993"-"\u09a8", "\u09aa"-"\u09b0", "\u09b2"-"\u09b2", "\u09b6"-"\u09b9", "\u09dc"-"\u09dd", "\u09df"-"\u09e1", "\u09f0"-"\u09f3", "\u0a05"-"\u0a0a", "\u0a0f"-"\u0a10", "\u0a13"-"\u0a28", "\u0a2a"-"\u0a30", "\u0a32"-"\u0a33", "\u0a35"-"\u0a36", "\u0a38"-"\u0a39", "\u0a59"-"\u0a5c", "\u0a5e"-"\u0a5e", "\u0a72"-"\u0a74", "\u0a85"-"\u0a8b", "\u0a8d"-"\u0a8d", "\u0a8f"-"\u0a91", "\u0a93"-"\u0aa8", "\u0aaa"-"\u0ab0", "\u0ab2"-"\u0ab3", "\u0ab5"-"\u0ab9", "\u0abd"-"\u0abd", "\u0ae0"-"\u0ae0", "\u0b05"-"\u0b0c", "\u0b0f"-"\u0b10", "\u0b13"-"\u0b28", "\u0b2a"-"\u0b30", "\u0b32"-"\u0b33", "\u0b36"-"\u0b39", "\u0b3d"-"\u0b3d", "\u0b5c"-"\u0b5d", "\u0b5f"-"\u0b61", "\u0b85"-"\u0b8a", "\u0b8e"-"\u0b90", "\u0b92"-"\u0b95", "\u0b99"-"\u0b9a", "\u0b9c"-"\u0b9c", "\u0b9e"-"\u0b9f", "\u0ba3"-"\u0ba4", "\u0ba8"-"\u0baa", "\u0bae"-"\u0bb5", "\u0bb7"-"\u0bb9", "\u0c05"-"\u0c0c", "\u0c0e"-"\u0c10", "\u0c12"-"\u0c28", "\u0c2a"-"\u0c33", "\u0c35"-"\u0c39", "\u0c60"-"\u0c61", "\u0c85"-"\u0c8c", "\u0c8e"-"\u0c90", "\u0c92"-"\u0ca8", "\u0caa"-"\u0cb3", "\u0cb5"-"\u0cb9", "\u0cde"-"\u0cde", "\u0ce0"-"\u0ce1", "\u0d05"-"\u0d0c", "\u0d0e"-"\u0d10", "\u0d12"-"\u0d28", "\u0d2a"-"\u0d39", "\u0d60"-"\u0d61", "\u0e01"-"\u0e2e", "\u0e30"-"\u0e30", "\u0e32"-"\u0e33", "\u0e3f"-"\u0e46", "\u0e81"-"\u0e82", "\u0e84"-"\u0e84", "\u0e87"-"\u0e88", "\u0e8a"-"\u0e8a", "\u0e8d"-"\u0e8d", "\u0e94"-"\u0e97", "\u0e99"-"\u0e9f", "\u0ea1"-"\u0ea3", "\u0ea5"-"\u0ea5", "\u0ea7"-"\u0ea7", "\u0eaa"-"\u0eab", "\u0ead"-"\u0eae", "\u0eb0"-"\u0eb0", "\u0eb2"-"\u0eb3", "\u0ebd"-"\u0ebd", "\u0ec0"-"\u0ec4", "\u0ec6"-"\u0ec6", "\u0edc"-"\u0edd", "\u0f40"-"\u0f47", "\u0f49"-"\u0f69", "\u10a0"-"\u10c5", "\u10d0"-"\u10f6", "\u1100"-"\u1159", "\u115f"-"\u11a2", "\u11a8"-"\u11f9", "\u1e00"-"\u1e9b", "\u1ea0"-"\u1ef9", "\u1f00"-"\u1f15", "\u1f18"-"\u1f1d", "\u1f20"-"\u1f45", "\u1f48"-"\u1f4d", "\u1f50"-"\u1f57", "\u1f59"-"\u1f59", "\u1f5b"-"\u1f5b", "\u1f5d"-"\u1f5d", "\u1f5f"-"\u1f7d", "\u1f80"-"\u1fb4", "\u1fb6"-"\u1fbc", "\u1fbe"-"\u1fbe", "\u1fc2"-"\u1fc4", "\u1fc6"-"\u1fcc", "\u1fd0"-"\u1fd3", "\u1fd6"-"\u1fdb", "\u1fe0"-"\u1fec", "\u1ff2"-"\u1ff4", "\u1ff6"-"\u1ffc", "\u203f"-"\u2040", "\u207f"-"\u207f", "\u20a0"-"\u20ac", "\u2102"-"\u2102", "\u2107"-"\u2107", "\u210a"-"\u2113", "\u2115"-"\u2115", "\u2118"-"\u211d", "\u2124"-"\u2124", "\u2126"-"\u2126", "\u2128"-"\u2128", "\u212a"-"\u2131", "\u2133"-"\u2138", "\u2160"-"\u2182", "\u3005"-"\u3005", "\u3007"-"\u3007", "\u3021"-"\u3029", "\u3031"-"\u3035", "\u3041"-"\u3094", "\u309b"-"\u309e", "\u30a1"-"\u30fa", "\u30fc"-"\u30fe", "\u3105"-"\u312c", "\u3131"-"\u318e", "\u4e00"-"\u7fff" ]> | <#FOLLOWING: [ "\u8000"-"\u9fa5", "\uac00"-"\ud7a3", "\uf900"-"\ufa2d", "\ufb00"-"\ufb06", "\ufb13"-"\ufb17", "\ufb1e"-"\ufb28", "\ufb2a"-"\ufb36", "\ufb38"-"\ufb3c", "\ufb3e"-"\ufb3e", "\ufb40"-"\ufb41", "\ufb43"-"\ufb44", "\ufb46"-"\ufbb1", "\ufbd3"-"\ufd3d", "\ufd50"-"\ufd8f", "\ufd92"-"\ufdc7", "\ufdf0"-"\ufdfb", "\ufe20"-"\ufe23", "\ufe33"-"\ufe34", "\ufe4d"-"\ufe4f", "\ufe69"-"\ufe69", "\ufe70"-"\ufe72", "\ufe74"-"\ufe74", "\ufe76"-"\ufefc", "\ufeff"-"\ufeff", "\uff04"-"\uff04", "\uff10"-"\uff19", "\uff21"-"\uff3a", "\uff3f"-"\uff3f", "\uff41"-"\uff5a", "\uff66"-"\uffbe", "\uffc2"-"\uffc7", "\uffca"-"\uffcf", "\uffd2"-"\uffd7", "\uffda"-"\uffdc", "\uffe0"-"\uffe1", "\uffe5"-"\uffe6", "\u0000"-"\u0008", "\u000e"-"\u001b", "\u0024"-"\u0024", "\u0030"-"\u0039", "\u0041"-"\u005a", "\u005f"-"\u005f", "\u0061"-"\u007a", "\u007f"-"\u009f", "\u00a2"-"\u00a5", "\u00aa"-"\u00aa", "\u00b5"-"\u00b5", "\u00ba"-"\u00ba", "\u00c0"-"\u00d6", "\u00d8"-"\u00f6", "\u00f8"-"\u01f5", "\u01fa"-"\u0217", "\u0250"-"\u02a8", "\u02b0"-"\u02b8", "\u02bb"-"\u02c1", "\u02d0"-"\u02d1", "\u02e0"-"\u02e4", "\u0300"-"\u0345", "\u0360"-"\u0361", "\u037a"-"\u037a", "\u0386"-"\u0386", "\u0388"-"\u038a", "\u038c"-"\u038c", "\u038e"-"\u03a1", "\u03a3"-"\u03ce", "\u03d0"-"\u03d6", "\u03da"-"\u03da", "\u03dc"-"\u03dc", "\u03de"-"\u03de", "\u03e0"-"\u03e0", "\u03e2"-"\u03f3", "\u0401"-"\u040c", "\u040e"-"\u044f", "\u0451"-"\u045c", "\u045e"-"\u0481", "\u0483"-"\u0486", "\u0490"-"\u04c4", "\u04c7"-"\u04c8", "\u04cb"-"\u04cc", "\u04d0"-"\u04eb", "\u04ee"-"\u04f5", "\u04f8"-"\u04f9", "\u0531"-"\u0556", "\u0559"-"\u0559", "\u0561"-"\u0587", "\u0591"-"\u05a1", "\u05a3"-"\u05b9", "\u05bb"-"\u05bd", "\u05bf"-"\u05bf", "\u05c1"-"\u05c2", "\u05c4"-"\u05c4", "\u05d0"-"\u05ea", "\u05f0"-"\u05f2", "\u0621"-"\u063a", "\u0640"-"\u0652", "\u0660"-"\u0669", "\u0670"-"\u06b7", "\u06ba"-"\u06be", "\u06c0"-"\u06ce", "\u06d0"-"\u06d3", "\u06d5"-"\u06dc", "\u06df"-"\u06e8", "\u06ea"-"\u06ed", "\u06f0"-"\u06f9", "\u0901"-"\u0903", "\u0905"-"\u0939", "\u093c"-"\u094d", "\u0951"-"\u0954", "\u0958"-"\u0963", "\u0966"-"\u096f", "\u0981"-"\u0983", "\u0985"-"\u098c", "\u098f"-"\u0990", "\u0993"-"\u09a8", "\u09aa"-"\u09b0", "\u09b2"-"\u09b2", "\u09b6"-"\u09b9", "\u09bc"-"\u09bc", "\u09be"-"\u09c4", "\u09c7"-"\u09c8", "\u09cb"-"\u09cd", "\u09d7"-"\u09d7", "\u09dc"-"\u09dd", "\u09df"-"\u09e3", "\u09e6"-"\u09f3", "\u0a02"-"\u0a02", "\u0a05"-"\u0a0a", "\u0a0f"-"\u0a10", "\u0a13"-"\u0a28", "\u0a2a"-"\u0a30", "\u0a32"-"\u0a33", "\u0a35"-"\u0a36", "\u0a38"-"\u0a39", "\u0a3c"-"\u0a3c", "\u0a3e"-"\u0a42", "\u0a47"-"\u0a48", "\u0a4b"-"\u0a4d", "\u0a59"-"\u0a5c", "\u0a5e"-"\u0a5e", "\u0a66"-"\u0a74", "\u0a81"-"\u0a83", "\u0a85"-"\u0a8b", "\u0a8d"-"\u0a8d", "\u0a8f"-"\u0a91", "\u0a93"-"\u0aa8", "\u0aaa"-"\u0ab0", "\u0ab2"-"\u0ab3", "\u0ab5"-"\u0ab9", "\u0abc"-"\u0ac5", "\u0ac7"-"\u0ac9", "\u0acb"-"\u0acd", "\u0ae0"-"\u0ae0", "\u0ae6"-"\u0aef", "\u0b01"-"\u0b03", "\u0b05"-"\u0b0c", "\u0b0f"-"\u0b10", "\u0b13"-"\u0b28", "\u0b2a"-"\u0b30", "\u0b32"-"\u0b33", "\u0b36"-"\u0b39", "\u0b3c"-"\u0b43", "\u0b47"-"\u0b48", "\u0b4b"-"\u0b4d", "\u0b56"-"\u0b57", "\u0b5c"-"\u0b5d", "\u0b5f"-"\u0b61", "\u0b66"-"\u0b6f", "\u0b82"-"\u0b83", "\u0b85"-"\u0b8a", "\u0b8e"-"\u0b90", "\u0b92"-"\u0b95", "\u0b99"-"\u0b9a", "\u0b9c"-"\u0b9c", "\u0b9e"-"\u0b9f", "\u0ba3"-"\u0ba4", "\u0ba8"-"\u0baa", "\u0bae"-"\u0bb5", "\u0bb7"-"\u0bb9", "\u0bbe"-"\u0bc2", "\u0bc6"-"\u0bc8", "\u0bca"-"\u0bcd", "\u0bd7"-"\u0bd7", "\u0be7"-"\u0bef", "\u0c01"-"\u0c03", "\u0c05"-"\u0c0c", "\u0c0e"-"\u0c10", "\u0c12"-"\u0c28", "\u0c2a"-"\u0c33", "\u0c35"-"\u0c39", "\u0c3e"-"\u0c44", "\u0c46"-"\u0c48", "\u0c4a"-"\u0c4d", "\u0c55"-"\u0c56", "\u0c60"-"\u0c61", "\u0c66"-"\u0c6f", "\u0c82"-"\u0c83", "\u0c85"-"\u0c8c", "\u0c8e"-"\u0c90", "\u0c92"-"\u0ca8", "\u0caa"-"\u0cb3", "\u0cb5"-"\u0cb9", "\u0cbe"-"\u0cc4", "\u0cc6"-"\u0cc8", "\u0cca"-"\u0ccd", "\u0cd5"-"\u0cd6", "\u0cde"-"\u0cde", "\u0ce0"-"\u0ce1", "\u0ce6"-"\u0cef", "\u0d02"-"\u0d03", "\u0d05"-"\u0d0c", "\u0d0e"-"\u0d10", "\u0d12"-"\u0d28", "\u0d2a"-"\u0d39", "\u0d3e"-"\u0d43", "\u0d46"-"\u0d48", "\u0d4a"-"\u0d4d", "\u0d57"-"\u0d57", "\u0d60"-"\u0d61", "\u0d66"-"\u0d6f", "\u0e01"-"\u0e2e", "\u0e30"-"\u0e3a", "\u0e3f"-"\u0e4e", "\u0e50"-"\u0e59", "\u0e81"-"\u0e82", "\u0e84"-"\u0e84", "\u0e87"-"\u0e88", "\u0e8a"-"\u0e8a", "\u0e8d"-"\u0e8d", "\u0e94"-"\u0e97", "\u0e99"-"\u0e9f", "\u0ea1"-"\u0ea3", "\u0ea5"-"\u0ea5", "\u0ea7"-"\u0ea7", "\u0eaa"-"\u0eab", "\u0ead"-"\u0eae", "\u0eb0"-"\u0eb9", "\u0ebb"-"\u0ebd", "\u0ec0"-"\u0ec4", "\u0ec6"-"\u0ec6", "\u0ec8"-"\u0ecd", "\u0ed0"-"\u0ed9", "\u0edc"-"\u0edd", "\u0f18"-"\u0f19", "\u0f20"-"\u0f29", "\u0f35"-"\u0f35", "\u0f37"-"\u0f37", "\u0f39"-"\u0f39", "\u0f3e"-"\u0f47", "\u0f49"-"\u0f69", "\u0f71"-"\u0f84", "\u0f86"-"\u0f8b", "\u0f90"-"\u0f95", "\u0f97"-"\u0f97", "\u0f99"-"\u0fad", "\u0fb1"-"\u0fb7", "\u0fb9"-"\u0fb9", "\u10a0"-"\u10c5", "\u10d0"-"\u10f6", "\u1100"-"\u1159", "\u115f"-"\u11a2", "\u11a8"-"\u11f9", "\u1e00"-"\u1e9b", "\u1ea0"-"\u1ef9", "\u1f00"-"\u1f15", "\u1f18"-"\u1f1d", "\u1f20"-"\u1f45", "\u1f48"-"\u1f4d", "\u1f50"-"\u1f57", "\u1f59"-"\u1f59", "\u1f5b"-"\u1f5b", "\u1f5d"-"\u1f5d", "\u1f5f"-"\u1f7d", "\u1f80"-"\u1fb4", "\u1fb6"-"\u1fbc", "\u1fbe"-"\u1fbe", "\u1fc2"-"\u1fc4", "\u1fc6"-"\u1fcc", "\u1fd0"-"\u1fd3", "\u1fd6"-"\u1fdb", "\u1fe0"-"\u1fec", "\u1ff2"-"\u1ff4", "\u1ff6"-"\u1ffc", "\u200c"-"\u200f", "\u202a"-"\u202e", "\u203f"-"\u2040", "\u206a"-"\u206f", "\u207f"-"\u207f", "\u20a0"-"\u20ac", "\u20d0"-"\u20dc", "\u20e1"-"\u20e1", "\u2102"-"\u2102", "\u2107"-"\u2107", "\u210a"-"\u2113", "\u2115"-"\u2115", "\u2118"-"\u211d", "\u2124"-"\u2124", "\u2126"-"\u2126", "\u2128"-"\u2128", "\u212a"-"\u2131", "\u2133"-"\u2138", "\u2160"-"\u2182", "\u3005"-"\u3005", "\u3007"-"\u3007", "\u3021"-"\u302f", "\u3031"-"\u3035", "\u3041"-"\u3094", "\u3099"-"\u309e", "\u30a1"-"\u30fa", "\u30fc"-"\u30fe", "\u3105"-"\u312c", "\u3131"-"\u318e", "\u4e00"-"\u7fff" ]> | <VARIABLE: "?" <IDENTIFIER>> { matchedToken.image = image.toString().substring(1); } } //--------------------------------------------------------------------------- // This token matches ALL UNMATCHED characters. // If some lexical error occurs, we should add a token to cover that // case instead of catching lexical token errors. In fact, the lexical // analysis should always be successful. //--------------------------------------------------------------------------- TOKEN : { < LPAREN: "(" > | < RPAREN: ")" > | < LBRACE: "{" > | < RBRACE: "}" > | < LBRACKET: "[" > | < RBRACKET: "]" > | < SEMICOLON: ";" > | < COMMA: "," > | < DOT: "." > | <QMARK: "?"> | <INCR: "++"> | <DECR: "--"> | <UNMATCHED: ~["!","&","+","-","*","%","/",":","=","<",">"]> } //--------------------------------------------------------------------------- // Identifiers and variables (to support old "?name" syntax) // This is a list of reserved keywords (can not used as identifiers): // // Java: // "return", "break", "continue", "if", "else","new", "instanceof" // JRules: // "not", "exists", "collect", "logical", "bind", "var", "wait", "until", // "timeout", "evaluate", "execute", "refresh", "event", "timeof", // "isunknown", "isknown" //--------------------------------------------------------------------------- Token Identifier() : { Token t; } { (t=<IDENTIFIER> | t="assert" | t="insert" | t="retract" | t="update" | t="modify" | t="apply" | t="execute" | t="rule" | t="packet" | t="priority" | t="property" | t="ruleset" | t="import" | t="using" | t="setup" | t="when" | t="then" | t="where" | t="from" | t="in" | t="while" | t="for" | t="function" | t="occursin" | t="before" | t="after" | t="$" | t="functiontask" | t="ruletask" | t="flowtask" | t="body" | t="initialaction" | t="finalaction" | t="firing" | t="firinglimit" | t="ordering" | t="select" | t="dynamicselect" | t="filter" | t="agendafilter" | t="out" | t="inout" | t="completionflag" | t="default" | t="iterator" | t="algorithm" | t="matchedclasses" | t="wait" // BR2003.816 | t="is" // BR2002.1147 ) { return t; } } Token[] ExtendedIdentifier() : { Vector tokens = new Vector(); Token[] tokenArray; Token t1,t2; } { ( t1=Identifier() { tokens.addElement( t1 ); } ( ( t1="." t2=Identifier() ) { tokens.addElement( t1 ); tokens.addElement( t2 ); } )* ) { tokenArray = new Token[ tokens.size() ]; for ( int i=0; i<tokens.size(); i++) { tokenArray[i] = (Token) tokens.elementAt(i); } return tokenArray; } } // User Wish 2000.19: "Use of JRules language keywords in package names" Token PossiblePackageName() : { Token t; } { t=PossiblePacketName() { return t; } } Token PossiblePacketName() : { Token t; } { (t=Identifier() | t="return" | t="break" | t="continue" | t="if" | t="else" | t="new" | t="instanceof" | t="timeof" | t="not" | t="exists" | t="collect" | t="logical" | t="event" | t="bind" | t="var" | t="until" | t="timeout" | t="evaluate" | t="refresh" | t="throw" | t="try" | t="catch" | t="finally" | t="isunknown" | t="isknown" ) { return t; } } Token Variable() : { Token t; } { (t=Identifier() | t=<VARIABLE>) { return t; } } //--------------------------------------------------------------------------- // Literals of the language //--------------------------------------------------------------------------- void LiteralLookahead() : { } { <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <CHARACTER_LITERAL> | <STRING_LITERAL> | "true" | "false" | "null" } // This rule is bad (missing the sign for the integers and floats) // and should not be used anymore. IlrConstantExpression Literal() : { Object object; IlrReflect reflect; IlrReflectClass type; IlrConstantExpression expr; IlrConstantValue value; Token t; } { t=<INTEGER_LITERAL> { reflect = rulesetParser.reflect; object = parseIntegerLiteral(t,1); if (object instanceof Integer) type = reflect.intType(); else type = reflect.longType(); value = new IlrConstantValue(reflect,type,object); return new IlrConstantExpression(t,value); } | t=<FLOATING_POINT_LITERAL> { reflect = rulesetParser.reflect; object = parseFloatLiteral(t,1); if (object instanceof Float) type = reflect.floatType(); else type = reflect.doubleType(); value = new IlrConstantValue(reflect,type,object); return new IlrConstantExpression(t,value); } | t=<CHARACTER_LITERAL> { reflect = rulesetParser.reflect; object = parseCharacterLiteral(t.image); type = reflect.charType(); value = new IlrConstantValue(reflect,type,object); return new IlrConstantExpression(t,value); } | t=<STRING_LITERAL> { reflect = rulesetParser.reflect; object = parseStringLiteral(t.image); type= reflect.stringClass(); value = new IlrConstantValue(reflect,type,object); return new IlrConstantExpression(t,value); } | t="true" { reflect = rulesetParser.reflect; value = reflect.factory.TRUE; return new IlrConstantExpression(t,value); } | t="false" { reflect = rulesetParser.reflect; value = reflect.factory.FALSE; return new IlrConstantExpression(t,value); } | t="null" { reflect = rulesetParser.reflect; value = reflect.factory.NULL; return new IlrConstantExpression(t,value); } } // This rule should be used instead of previous one. IlrConstantExpression SignedLiteral() : { Object object; IlrReflect reflect; IlrReflectClass type; IlrConstantExpression expr; IlrConstantValue value; Token t; int sign = 1; } { ( ( "+" ) { sign = 1; } | ( "-" ) { sign = -1; } ) ? ( t=<INTEGER_LITERAL> { reflect = rulesetParser.reflect; object = parseIntegerLiteral(t,sign); if (object instanceof Integer) type = reflect.intType(); else type = reflect.longType(); value = new IlrConstantValue(reflect,type,object); return new IlrConstantExpression(t,value); } | t=<FLOATING_POINT_LITERAL> { reflect = rulesetParser.reflect; object = parseFloatLiteral(t,sign); if (object instanceof Float) type = reflect.floatType(); else type = reflect.doubleType(); value = new IlrConstantValue(reflect,type,object); return new IlrConstantExpression(t,value); } ) | t=<CHARACTER_LITERAL> { reflect = rulesetParser.reflect; object = parseCharacterLiteral(t.image); type = reflect.charType(); value = new IlrConstantValue(reflect,type,object); return new IlrConstantExpression(t,value); } | t=<STRING_LITERAL> { reflect = rulesetParser.reflect; object = parseStringLiteral(t.image); type= reflect.stringClass(); value = new IlrConstantValue(reflect,type,object); return new IlrConstantExpression(t,value); } | t="true" { reflect = rulesetParser.reflect; value = reflect.factory.TRUE; return new IlrConstantExpression(t,value); } | t="false" { reflect = rulesetParser.reflect; value = reflect.factory.FALSE; return new IlrConstantExpression(t,value); } | t="null" { reflect = rulesetParser.reflect; value = reflect.factory.NULL; return new IlrConstantExpression(t,value); } } void SignedNumberLookahead () : {} { ( "+" | "-" ) ( <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> ) } IlrConstantExpression SignedNumberExpression (): { IlrFactory factory; IlrConstantExpression expr; IlrConstantValue value; Token t; Number number; int sign = 0; } { ( ( "+" ) { sign = 1; } | ( "-" ) { sign = -1; } ) ( t=<INTEGER_LITERAL> { factory = rulesetParser.reflect.factory; number = parseIntegerLiteral(t,sign); if (number instanceof Integer) value = factory.new ConstantValue(number.intValue()); else value = factory.new ConstantValue(number.longValue()); return new IlrConstantExpression(t,value); } | t=<FLOATING_POINT_LITERAL> { factory = rulesetParser.reflect.factory; number = parseFloatLiteral(t,sign); if (number instanceof Float) value = factory.new ConstantValue(number.floatValue()); else value = factory.new ConstantValue(number.doubleValue()); return new IlrConstantExpression(t,value); } ) } //--------------------------------------------------------------------------- // The type names // Simple type name is used to specify simple type, eventually using // package name. They are used in the import statement. type name is // used for a general type, including array type. // Example: ilog.rules.IlrRule, java.util.Vector, Form, or int[] //--------------------------------------------------------------------------- IlrSimpleTypeExpression SimpleTypeName() : { Vector vector = new Vector(5,2); Token t; } { t=Identifier() { vector.addElement(t); } (LOOKAHEAD(2) "." t=Identifier() { vector.addElement(t); })* { int len = vector.size(); Token[] tokens = new Token[len]; for (int i = 0; i < len; i++) tokens[i] = (Token)vector.elementAt(i); return new IlrSimpleTypeExpression(tokens); } } // Wish 2002.127 IlrSimpleTypeExpression SimplePackageTypeName() : { Vector vector = new Vector(5,2); Token t; } { t=PossiblePackageName() { vector.addElement(t); } (LOOKAHEAD(2) "." t=PossiblePackageName() { vector.addElement(t); })* { int len = vector.size(); Token[] tokens = new Token[len]; for (int i = 0; i < len; i++) tokens[i] = (Token)vector.elementAt(i); return new IlrSimpleTypeExpression(tokens); } } IlrTypeExpression TypeName() : { Token open; Token close; IlrTypeExpression type; } { type=SimpleTypeName() ( open="[" close="]" { type = new IlrArrayTypeExpression(open,close,type); } )* { return type; } } //--------------------------------------------------------------------------- // Utility methods: parser entry points //--------------------------------------------------------------------------- IlrRuleDefinition ParseRuleDefinition() : { IlrRuleDefinition rule = null; Token keyword; Token[] t; } { keyword="rule" t=ExtendedIdentifier() { rule = new IlrRuleDefinition(keyword,t); } "{" RuleBodyDefinition(rule) "}" (";")? <EOF> { return rule; } } //--------------------------------------------------------------------------- // The ruleset definition // A ruleset begins with some imports statements (can be absent), // Then an initialization rule (optional), // Then some rule definitions. // Then EOF. //--------------------------------------------------------------------------- void RulesetDefinition(IlrRulesetParser ruleset) : {} { (ImportDefinition(ruleset))* (PropertyDefinition(ruleset))? (SetupDefinition(ruleset))? ( FunctionDefinition(ruleset) | RuleDefinition(ruleset) | TaskDefinition() )* <EOF> } //--------------------------------------------------------------------------- // The taskset definition // Then some task definitions. // Then EOF. //--------------------------------------------------------------------------- void TasksetDefinition(IlrRulesetParser ruleset) : {} { (ImportDefinition(ruleset))* (PropertyDefinition(ruleset))? (SetupDefinition(ruleset))? (TaskDefinition())* <EOF> } //--------------------------------------------------------------------------- // Imports // This statement imports Java classes used in the rules. // Specific class names or whole package can be used. // In the subsequent class names, when package are not specified, they // are seached in the imported classes and packages. // Examples: // import java.util.*; // import mypackage.myclass; // Note: Implicit imports are: // import java.lang.*; // import ilog.rules.*; //--------------------------------------------------------------------------- void ImportDefinition(IlrRulesetParser ruleset) : {} { try { ProtectedImportDefinition(ruleset) } catch(ParseException ex) { ruleset.reporter.insertException(ruleset,ex); String[] arr = {"import", "rule", "function", "functiontask", "ruletask", "flowtask"}; syncOn(arr); ruleset.currentDefinition = null; } } // Wish 2002.127: SimpleTypeName replaced by SimplePackageTypeName // to allow 'event' in package name void ProtectedImportDefinition(IlrRulesetParser ruleset) : { Token keyword; IlrSimpleTypeExpression type; IlrImportDefinition definition; } { keyword="import" type=SimplePackageTypeName() { definition = new IlrImportDefinition(keyword,type); ruleset.addDefinition(definition); ruleset.currentDefinition = definition; } ["." "*" { definition.importAll=true; } ] ";" { ruleset.currentDefinition = null; } | keyword="using" type=SimplePackageTypeName() ";" { definition = new IlrImportDefinition(keyword,type); definition.importAll=true; ruleset.addDefinition(definition); ruleset.currentDefinition = definition; } }
Defines the values for properties. The property values can be any literal, or a type name (can be an array) such as java.lang.String. If the type name is followed by ("a string"), then we use a format. |
IlrPropertyDefinition.Element Property() : { Token token=null; IlrSimpleTypeExpression property; IlrConstantExpression constant; IlrTypeExpression type; Token t = null; IlrPropertyDefinition.Element el; } { try { token="property" property=SimpleTypeName() "=" ( constant=SignedLiteral() { el = new IlrPropertyDefinition.Element(token,property,constant); } | type=TypeName() ("(" t=<STRING_LITERAL> ")")? { el = new IlrPropertyDefinition.Element(token,property,type,t); } ) ";" { return el; } } catch(ParseException ex) { lastCommonTaskToken = token; throw ex; } } //--------------------------------------------------------------------------- // The ruleset properties //--------------------------------------------------------------------------- void PropertyDefinition(IlrRulesetParser ruleset) : { Token keyword; IlrSimpleTypeExpression rulesetName; IlrPropertyDefinition definition; IlrPropertyDefinition.Element prop; } { keyword="ruleset" rulesetName=SimpleTypeName() { definition = new IlrPropertyDefinition(keyword,rulesetName); ruleset.addDefinition(definition); ruleset.currentDefinition = definition; } ( ";" | "{" ( RulesetSettings(definition) )* "}" (";")? ) { ruleset.currentDefinition = null; } } void RulesetSettings(IlrPropertyDefinition definition) : { IlrPropertyDefinition.Element prop; } { LOOKAHEAD(1) prop=Property() { if (!definition.containsProperty(prop)) definition.addProperty(prop); else { String msg = IlrMessages.format("messages.Parsing.6", prop.getName()); rulesetParser.reporter.insertError(prop.getError(rulesetParser,msg)); } } | RulesetVariableDeclaration() | ClassInstancesDeclaration() | HasherDeclaration() {} } void ClassInstancesDeclaration() : { IlrClassInstancesDefinition instances=null; Token keyword; IlrTypeExpression type; IlrExpression expr; } { keyword = "instances" "(" type = TypeName() ")" "=" { instances = new IlrClassInstancesDefinition(keyword, type); rulesetParser.addDefinition(instances); } ( InstancesList(instances) | expr = Expression() ";" { instances.setInstances(expr); } ) {} } void InstancesList(IlrClassInstancesDefinition instances) : { IlrExpression expr; } { "{" ("}" | ( expr = Expression() { instances.addInstance(expr); } ("," expr = Expression() { instances.addInstance(expr); })* "}" ) ) (";")? {} } void HasherDeclaration() : { IlrExpression expr=null; IlrTypeExpression typeExpr=null; Token variable=null; Token keyword=null; IlrHasherDefinition definition=null; } { keyword = "hasher" "(" typeExpr = TypeName() variable = Variable() ")" "=" expr = Expression() ";" { definition = new IlrHasherDefinition(keyword, typeExpr, variable, expr); rulesetParser.addDefinition(definition); } } void ModifierLookAhead() : { } { ("in" | "inout") TypeName() Variable() } void RulesetVariableDeclaration() : { IlrRulesetVariableDefinition definition=null; // rulesetParser.rulesetVariableDefinition; Token keyword=null; Token name; IlrTypeExpression type; IlrRulesetVariable expr; IlrBindExpression bindExpr; IlrExpression value=null; Token end; int modifier=IlrRulesetVariable.RulesetBind; } { ( LOOKAHEAD(3) (keyword = "in" { modifier |= IlrRulesetVariable.In; } | keyword = "inout" { modifier |= IlrRulesetVariable.In | IlrRulesetVariable.Out; } ) type = TypeName() name = Variable() end = ";" { if (definition == null) { definition = new IlrRulesetVariableDefinition(keyword); // rulesetParser.rulesetVariableDefinition = definition; rulesetParser.addDefinition(definition); } expr = new IlrRulesetVariable(keyword, end, name, type, modifier); definition.addVariable(expr); } | [ LOOKAHEAD(3) keyword = "out" { modifier |= IlrRulesetVariable.Out; } ] type = TypeName() name = Variable() ("=" value = Expression() end = ";" | end = ";") { if (keyword == null) keyword = type.getBeginToken(); if (definition == null) { definition = new IlrRulesetVariableDefinition(keyword); // rulesetParser.rulesetVariableDefinition = definition; rulesetParser.addDefinition(definition); } if (value != null) { bindExpr = new IlrBindExpression(keyword,end,name,value); bindExpr.modifier = modifier; if ((modifier & IlrRulesetVariable.Out) != 0) { definition.addReturnBindingExpression(bindExpr); definition.addReturnBindingType(type); } else { definition.addVariableBindingExpression(bindExpr); definition.addVariableBindingType(type); } } else { expr = new IlrRulesetVariable(keyword, end, name, type, modifier); definition.addVariable(expr); } } ) { } } //--------------------------------------------------------------------------- // The setup rule (or initialization rule) // Is used to initialize the execution context. This is a rule without // conditions (with only actions). The actions are executed as soon // as the context is created. //--------------------------------------------------------------------------- void SetupDefinition(IlrRulesetParser ruleset) : {} { try { ProtectedSetupDefinition(ruleset) } catch(ParseException ex) { ruleset.reporter.insertException(ruleset,ex); String[] arr = {"rule", "function", "functiontask", "flowtask", "ruletask"}; syncOn(arr); ruleset.currentDefinition = null; } } void ProtectedSetupDefinition(IlrRulesetParser ruleset) : { Token keyword,obrace,cbrace; IlrSetupDefinition definition; IlrActionExpression action; } { keyword="setup" { definition = new IlrSetupDefinition(keyword); ruleset.addDefinition(definition); ruleset.currentDefinition = definition; } obrace="{" { definition.obrace = obrace; } (action=ActionStatement() { definition.actions.addElement(action); })* cbrace="}" { definition.cbrace = cbrace; } (";")? { ruleset.currentDefinition = null; } } //--------------------------------------------------------------------------- // The rule definition // See the next grammar for the rule definition syntax. //--------------------------------------------------------------------------- void RuleDefinition(IlrRulesetParser ruleset) : {} { try { ProtectedRuleDefinition(ruleset) } catch(ParseException ex) { if (!ex.specialConstructor && "NextRule".equals(ex.getMessage())) {} else { ruleset.reporter.insertException(ruleset,ex); String[] arr = {"rule", "function", "functiontask", "flowtask", "ruletask"}; syncOn(arr); ruleset.currentDefinition = null; } } } void ProtectedRuleDefinition(IlrRulesetParser ruleset) : { Token[] trule; Token ruleToken; } { ruleToken="rule" trule=ExtendedIdentifier() { IlrRuleDefinition rule = new IlrRuleDefinition(ruleToken,trule); ruleset.addDefinition(rule); ruleset.currentDefinition = rule; if (ruleToken.specialToken != null && ruleToken.specialToken.kind == FORMAL_COMMENT) rule.setComments(ruleToken.specialToken.image); } "{" RuleBodyDefinition(rule) "}" (";")? { ruleset.currentDefinition = null; } } //--------------------------------------------------------------------------- // The function definition // See the next grammar for the function definition syntax. //--------------------------------------------------------------------------- void FunctionDefinition(IlrRulesetParser ruleset) : {} { try { ProtectedFunctionDefinition(ruleset) } catch(ParseException ex) { ruleset.reporter.insertException(ruleset,ex); String[] arr = {"rule", "function", "functiontask", "flowtask", "ruletask"}; syncOn(arr); ruleset.currentDefinition = null; } } void ProtectedFunctionDefinition(IlrRulesetParser ruleset) : { Token keyword,obrace,cbrace; Token[] name=null; IlrTypeExpression returnType=null; IlrFunctionDefinition function; IlrActionExpression action; } { keyword="function" returnType=TypeName() name=ExtendedIdentifier() { function = new IlrFunctionDefinition ( keyword, name, returnType ); ruleset.addDefinition(function); ruleset.currentDefinition = function; if (keyword.specialToken != null && keyword.specialToken.kind == FORMAL_COMMENT) function.setComments(keyword.specialToken.image); } FunctionArgsDefinition ( function ) obrace="{" { function.obrace = obrace; } ( action = ActionStatement () { function.addAction( action ); } )* cbrace="}" { function.cbrace = cbrace; } (";")? { ruleset.currentDefinition = null; } } void FunctionArgsDefinition(IlrFunctionDefinition function ) : { IlrFunctionArgExpression arg; } { "(" ( ")" | ( arg=FunctionArgDefinition() { function.addArgument ( arg ); } ) ( "," arg=FunctionArgDefinition() { function.addArgument ( arg ); } )* ")" ) } IlrFunctionArgExpression FunctionArgDefinition () : { IlrTypeExpression type; Token name; } { type=TypeName() name=Variable() { return new IlrFunctionArgExpression ( name, type ); } } //--------------------------------------------------------------------------- // Rule body //--------------------------------------------------------------------------- void RuleBodyDefinition(IlrRuleDefinition rule) : {} { try { (RuleParameterAssignments(rule))* } catch(ParseException ex) { IlrRulesetParser ruleset = rulesetParser; lastCommonTaskToken = null; ruleset.reporter.insertException(ruleset,ex); String[] arr = {"rule","when"}; String found = syncOn(arr); if ((found == null) || (!found.equals("when"))) return; } try { RuleConditions(rule) } catch(ParseException ex) { IlrRulesetParser ruleset = rulesetParser; ruleset.reporter.insertException(ruleset,ex); String[] arr = {"rule","then"}; String found = syncOn(arr); if ((found == null) || (!found.equals("then"))) throw new ParseException("NextRule"); } RuleActions(rule) } void RuleParameterAssignments(IlrRuleDefinition rule) : { Token token = null; Token t; IlrExpression expr = null; IlrPropertyDefinition.Element prop; } { t="packet" "=" token=PossiblePacketName() ";" { if (token != null) { if (rule.packetToken == null) rule.packetToken = token; else { String msg = IlrMessages.getMessage("messages.Parsing.7"); rulesetParser.reporter.insertException(rulesetParser,t,msg); } } } | t="priority" "=" expr=Expression() ";" { if (expr != null) { if (rule.priority == null) rule.setPriority(expr); else { String msg = IlrMessages.getMessage("messages.Parsing.8"); rulesetParser.reporter.insertException(rulesetParser,t,msg); } } } | prop=Property() { if (!rule.properties.containsProperty(prop)) rule.properties.addProperty(prop); else { String msg = IlrMessages.format("messages.Parsing.6", prop.getName()); rulesetParser.reporter.insertError(prop.getError(rulesetParser,msg)); } } } //--------------------------------------------------------------------------- // The task definition //--------------------------------------------------------------------------- void TaskDefinition() : { IlrTaskDefinition task=null; } { try { task = ProtectedRuleTaskDefinition() {} | task = ProtectedFunctionTaskDefinition() {} | task = ProtectedFlowTaskDefinition() {} } catch(ParseException ex) { if (!ex.specialConstructor) {} else { rulesetParser.reporter.insertException(rulesetParser,ex); String[] arr = {"rule", "function", "functiontask", "flowtask", "ruletask"}; String found = syncOn(arr); rulesetParser.currentDefinition = null; } } } IlrTaskDefinition ProtectedRuleTaskDefinition() : { Token[] ttask; Token taskToken; IlrTaskDefinition task = null; IlrTasksetDefinition taskset = rulesetParser.taskset; } { taskToken="ruletask" ttask=ExtendedIdentifier() { if (taskset == null) { taskset = new IlrTasksetDefinition(); rulesetParser.taskset = taskset; rulesetParser.addDefinition(taskset); } task = new IlrTaskDefinition(taskToken, ttask, IlrTaskDefinition.RuleTask); rulesetParser.currentDefinition = task; taskset.addTask(task); if (taskToken.specialToken != null && taskToken.specialToken.kind == FORMAL_COMMENT) task.setComments(taskToken.specialToken.image); } "{" RuleTaskBodyDefinition(task) "}" (";")? { rulesetParser.currentDefinition = null; return task; } } IlrTaskDefinition ProtectedFunctionTaskDefinition() : { Token[] ttask; Token taskToken; IlrTaskDefinition task = null; IlrTasksetDefinition taskset = rulesetParser.taskset; } { taskToken="functiontask" ttask=ExtendedIdentifier() { if (taskset == null) { taskset = new IlrTasksetDefinition(); rulesetParser.taskset = taskset; rulesetParser.addDefinition(taskset); } task = new IlrTaskDefinition(taskToken, ttask, IlrTaskDefinition.FunctionTask); rulesetParser.currentDefinition = task; taskset.addTask(task); if (taskToken.specialToken != null && taskToken.specialToken.kind == FORMAL_COMMENT) task.setComments(taskToken.specialToken.image); } "{" FunctionTaskBodyDefinition(task) "}" (";")? { rulesetParser.currentDefinition = null; return task; } } IlrTaskDefinition ProtectedFlowTaskDefinition() : { Token[] ttask; Token taskToken; IlrTaskDefinition task = null; IlrTasksetDefinition taskset = rulesetParser.taskset; } { taskToken="flowtask" ttask=ExtendedIdentifier() { if (taskset == null) { taskset = new IlrTasksetDefinition(); rulesetParser.taskset = taskset; rulesetParser.addDefinition(taskset); } task = new IlrTaskDefinition(taskToken, ttask, IlrTaskDefinition.FlowTask); rulesetParser.currentDefinition = task; taskset.addTask(task); if (taskToken.specialToken != null && taskToken.specialToken.kind == FORMAL_COMMENT) task.setComments(taskToken.specialToken.image); } "{" FlowTaskBodyDefinition(task) "}" (";")? { rulesetParser.currentDefinition = null; return task; } } //--------------------------------------------------------------------------- // Task body //--------------------------------------------------------------------------- void RuleTaskBodyDefinition(IlrTaskDefinition task) : {} { (RuleTaskParameterAssignments(task))* {} } void FunctionTaskBodyDefinition(IlrTaskDefinition task) : {} { (FunctionTaskParameterAssignments(task))* {} } void FlowTaskBodyDefinition(IlrTaskDefinition task) : {} { (FlowTaskParameterAssignments(task))* {} } void RuleTaskParameterAssignments(IlrTaskDefinition task) : { Token key = null; Token filter = null; Token mode=null; IlrPropertyDefinition.Element prop; Vector actions; Token var = null; int sign = 1; IlrExpression filterExpr=null; IlrExpression iteratorExpr=null; IlrExpression matchOnExpr=null; Vector matchOnClasses=null; Token algo=null; boolean dynamic=false; } { try { ( key = "body" { task.tbody = key; } ( LOOKAHEAD(2) "=" ( filter = "select" { dynamic = false; } | filter = "dynamicselect" { dynamic = true; } ) "(" var = Variable() ")" try { actions = TaskActions(task) (";")? { task.setComputeRuleInfos(var, actions); task.dynamicBody = dynamic; } } catch(ParseException ex) { lastCommonTaskToken = key; throw ex; } | ("=")? "{" (RuleList(task) "}" | "}" ) (";")? ) | ( key = "ordering" { task.tordering = key; } "=" try { mode = Identifier() ";" { if ("dynamic".equals(mode.image)) task.setOrdering(IlrTaskDefinition.Dynamic); else if ("literal".equals(mode.image)) task.setOrdering(IlrTaskDefinition.Literal); else if ("sorted".equals(mode.image)) task.setOrdering(IlrTaskDefinition.Sorted); else { String msg = IlrMessages.format("messages.Parsing.9", mode.image); rulesetParser.reporter.insertException(rulesetParser, key, msg); } } } catch(ParseException ex) { lastCommonTaskToken = key; throw ex; } ) ) | ( key = "firing" { task.tfiring = key; } "=" try { mode = Identifier() ";" { if ("rule".equals(mode.image)) task.setFiring(IlrTaskDefinition.Rule); else if ("allrules".equals(mode.image)) task.setFiring(IlrTaskDefinition.AllRules); else { String msg = IlrMessages.format("messages.Parsing.10", mode.image); rulesetParser.reporter.insertException(rulesetParser, key, msg); } } } catch(ParseException ex) { lastCommonTaskToken = key; throw ex; } ) | ( key = "firinglimit" { task.tfiringLimit = key; } "=" try { ( "+" { sign = 1; } | "-" { sign = -1; } )? mode = <INTEGER_LITERAL> ";" { Number object = parseIntegerLiteral(mode,sign); task.setFiringLimit(object.intValue()); } } catch(ParseException ex) { lastCommonTaskToken = key; throw ex; } ) | ( key = "agendafilter" "=" { task.tagendafilter = key; } (LOOKAHEAD(3) filter = "filter" "(" var = Variable() ")" try{ actions = TaskActions(task) (";")? { task.setAgendaFilter(var, actions); } } catch(ParseException ex) { lastCommonTaskToken = key; throw ex; } | filterExpr = Expression() ";" { task.setAgendaFilter(filterExpr); } ) ) | ( key = "iterator" { task.titerator = key; } "=" iteratorExpr = Expression() ";" { task.setIterator(iteratorExpr); } ) | ( key = "algorithm" { task.talgorithm = key; } "=" try { algo = Identifier() ";" { if ("default".equals(algo.image)) task.setAlgorithm(IlrTaskDefinition.DefaultAlgorithm); else if ("sequential".equals(algo.image)) task.setAlgorithm(IlrTaskDefinition.SequentialAlgorithm); else { String msg = IlrMessages.format("messages.Parsing.14", algo.image); rulesetParser.reporter.insertException(rulesetParser, key, msg); } } } catch(ParseException ex) { lastCommonTaskToken = key; throw ex; } ) | ( key = "matchedclasses" { task.tmatchOn = key; } try { ( LOOKAHEAD(2) "=" matchOnExpr = Expression() ";" { task.setMatchOnExpr(matchOnExpr); } | ("=")? "{" matchOnClasses = MatchOnList(task) "}" (";")? { task.setMatchOnClasses(key, matchOnClasses); } ) } catch(ParseException ex) { lastCommonTaskToken = key; throw ex; } ) | CommonTaskParameterAssignments(task) } catch(ParseException ex) { IlrRulesetParser ruleset = rulesetParser; if (lastCommonTaskToken != null) { String message = ruleset.reporter.computeTaskErrorMessage(ex, lastCommonTaskToken, task.name); ruleset.reporter.insertException(ruleset, ex.currentToken, message); lastCommonTaskToken = null; } else ruleset.reporter.insertException(ruleset,ex); Vector topLevelTokens = new Vector(); topLevelTokens.addElement("rule"); topLevelTokens.addElement("function"); topLevelTokens.addElement("ruletask"); topLevelTokens.addElement("functiontask"); topLevelTokens.addElement("flowtask"); Vector tokens = new Vector(); tokens.addAll(topLevelTokens); tokens.addElement("property"); if (task.tbody == null) tokens.addElement("body"); if (task.tinitialactions == null) tokens.addElement("initialaction"); if (task.tfinalactions == null) tokens.addElement("finalaction"); if (task.tordering == null) tokens.addElement("ordering"); if (task.tfiring == null) tokens.addElement("firing"); if (task.tfiringLimit == null) tokens.addElement("firinglimit"); if (task.talgorithm == null) tokens.addElement("algorithm"); if (task.titerator == null) tokens.addElement("iterator"); if (task.tagendafilter == null) tokens.addElement("agendafilter"); if (task.tcompletionflag == null) tokens.addElement("completionflag"); if (task.tmatchOn == null) tokens.addElement("matchedclasses"); String[] arr = new String[tokens.size()]; tokens.copyInto(arr); String found = syncOn(arr); if ((found == null) || topLevelTokens.contains(found)) throw ex; } } void RuleList(IlrTaskDefinition task) : { Token[] expr; Vector rules = new Vector(5, 5); } { expr=ExtendedIdentifier() { rules.addElement(expr); } ("," expr=ExtendedIdentifier() { rules.addElement(expr); })* { task.setRules(rules); } } Vector MatchOnList(IlrTaskDefinition task) : { IlrTypeExpression expr; Vector classes = new Vector(5, 5); } { expr=TypeName() { classes.addElement(expr); } ("," expr=TypeName() { classes.addElement(expr); })* { return classes; } } void FunctionTaskParameterAssignments(IlrTaskDefinition task) : { Token body = null; Vector actions; } { try { body = "body" ("=")? { task.tbody = body; } actions = TaskActions(task) (";")? { IlrFunctionDefinition def = new IlrFunctionDefinition(body, new Token[0], null); if (actions != null) { for(int i=0; i<actions.size(); i++) def.addAction((IlrActionExpression)actions.elementAt(i)); } task.setFunction(def); } | CommonTaskParameterAssignments(task) } catch(ParseException ex) { IlrRulesetParser ruleset = rulesetParser; if (lastCommonTaskToken != null) { String message = ruleset.reporter.computeTaskErrorMessage(ex, lastCommonTaskToken, task.name); ruleset.reporter.insertException(ruleset, ex.currentToken, message); lastCommonTaskToken = null; } else ruleset.reporter.insertException(ruleset,ex); Vector topLevelTokens = new Vector(); topLevelTokens.addElement("rule"); topLevelTokens.addElement("function"); topLevelTokens.addElement("ruletask"); topLevelTokens.addElement("functiontask"); topLevelTokens.addElement("flowtask"); Vector tokens = new Vector(); tokens.addAll(topLevelTokens); tokens.addElement("property"); if (task.tbody == null) tokens.addElement("body"); if (task.tinitialactions == null) tokens.addElement("initialaction"); if (task.tfinalactions == null) tokens.addElement("finalaction"); if (task.tcompletionflag == null) tokens.addElement("completionflag"); String[] arr = new String[tokens.size()]; tokens.copyInto(arr); String found = syncOn(arr); if ((found == null) || topLevelTokens.contains(found)) throw ex; } } Vector TaskActions(IlrTaskDefinition task) : { Token keyword,obrace,cbrace; IlrActionExpression action; Vector actions = new Vector(5, 5); } { obrace="{" { task.bodyobrace = obrace; } ( action = ActionStatement () { actions.addElement( action ); } )* cbrace="}" { task.bodycbrace = cbrace; } { return actions; } } void FlowTaskParameterAssignments(IlrTaskDefinition task) : { Token body = null; IlrFlowDefinition flow=null; IlrTasksetDefinition taskset = rulesetParser.taskset; } { try { body = "body" ("=")? { task.tbody = body; flow = new IlrFlowDefinition(body, rulesetParser.reflect); taskset.addFlow(flow); task.setFlow(flow); } try { FlowDefinition(flow) (";")? } catch(ParseException ex) { lastCommonTaskToken = body; throw ex; } | CommonTaskParameterAssignments(task) } catch(ParseException ex) { IlrRulesetParser ruleset = rulesetParser; if (lastCommonTaskToken != null) { String message = ruleset.reporter.computeTaskErrorMessage(ex, lastCommonTaskToken, task.name); ruleset.reporter.insertException(ruleset, ex.currentToken, message); lastCommonTaskToken = null; } else ruleset.reporter.insertException(ruleset,ex); Vector topLevelTokens = new Vector(); topLevelTokens.addElement("rule"); topLevelTokens.addElement("function"); topLevelTokens.addElement("ruletask"); topLevelTokens.addElement("functiontask"); topLevelTokens.addElement("flowtask"); Vector tokens = new Vector(); tokens.addAll(topLevelTokens); tokens.addElement("property"); if (task.tbody == null) tokens.addElement("body"); if (task.tinitialactions == null) tokens.addElement("initialaction"); if (task.tfinalactions == null) tokens.addElement("finalaction"); if (task.tcompletionflag == null) tokens.addElement("completionflag"); String[] arr = new String[tokens.size()]; tokens.copyInto(arr); String found = syncOn(arr); if ((found == null) || topLevelTokens.contains(found)) throw ex; } } void CommonTaskParameterAssignments(IlrTaskDefinition task) : { IlrPropertyDefinition.Element prop; IlrExpression expr=null; Token keyword=null; } { try { (prop=Property() { if (!task.properties.containsProperty(prop)) task.properties.addProperty(prop); else { String msg = IlrMessages.format("messages.Parsing.6", prop.getName()); rulesetParser.reporter.insertError(prop.getError(rulesetParser,msg)); } } | InitialFinalAction(task) | keyword = "completionflag" { task.tcompletionflag = keyword; } "=" expr = Expression() ";" { task.setCompletionFlag(expr); } ) } catch(ParseException ex) { if (lastCommonTaskToken == null) lastCommonTaskToken = keyword; throw ex; } } void FlowDefinition(IlrFlowDefinition flow) : { Token obrace; Token cbrace; IlrFlowNodeExpression node; IlrFlowNodeExpression previousNode=null; } { { flowIndex = 1; } obrace = "{" ("}" | ( node = FlowStatement(flow) { flow.setRoot(node); if (!node.isSplitNode()) previousNode = node; else { previousNode = ((IlrSplitNodeExpression)node).joinNode; previousNode.scope = node.scope; } } (node = FlowStatement(flow) { if (node != null) { previousNode.addOutputNode(node); if (!node.isSplitNode()) previousNode = node; else { previousNode = ((IlrSplitNodeExpression)node).joinNode; previousNode.scope = node.scope; } } } )* ) cbrace = "}" ) } IlrFlowNodeExpression FlowStatement(IlrFlowDefinition flow) : { IlrFlowNodeExpression node=null; } { (LOOKAHEAD(TaskStatement(flow)) node = TaskStatement(flow) | LOOKAHEAD(WhileFlowStatementLookAhead()) node = WhileFlowStatement(flow) | LOOKAHEAD(SwitchFlowStatementLookAhead()) node = SwitchFlowStatement(flow) | LOOKAHEAD(IfFlowStatementLookAhead()) node = IfFlowStatement(flow) | node = ForkFlowStatement(flow) | node = GotoStatement(flow) | node = BreakOrContinueFlowStatement(flow) ) { return node; } } IlrFlowNodeExpression BreakOrContinueFlowStatement(IlrFlowDefinition flow) : { Token keyword; IlrTaskGotoNodeExpression node=null; int kind = 0; Token end=null; } { (keyword = "break" { kind = IlrTaskGotoNodeExpression.Break; } | keyword = "continue" {kind = IlrTaskGotoNodeExpression.Continue; } ) end = ";" { node = new IlrTaskGotoNodeExpression(flow, keyword, null, kind, end); node.setFlowIndex(flowIndex++); flow.recordGotoNode(node); return node; } } IlrFlowNodeExpression GotoStatement(IlrFlowDefinition flow) : { Token keyword; Token tlabel; IlrFlowNodeExpression node=null; IlrTaskGotoNodeExpression gotoNode=null; Token end=null; } { keyword = "goto" tlabel = Identifier() end=";" { gotoNode = new IlrTaskGotoNodeExpression(flow, keyword, tlabel, IlrTaskGotoNodeExpression.Goto, end); gotoNode.setFlowIndex(flowIndex++); node = flow.getNode(tlabel); if (node != null) { gotoNode.setTargetNode(node); } flow.recordGotoNode(gotoNode); return gotoNode; } } IlrFlowNodeExpression TaskStatement(IlrFlowDefinition flow) : { Token label = null; Token[] ttask; IlrFlowNodeExpression node=null; Token end=null; } { (LOOKAHEAD(3) label = Identifier() ":" ttask = ExtendedIdentifier() end = ";" { node = flow.getNode(label); if (node == null) { node = new IlrTaskInstanceExpression(flow, label, ttask, end); node.setFlowIndex(flowIndex++); flow.addNamedNode(node); } else { String msg = IlrMessages.format("messages.Parsing.11", label.image); rulesetParser.reporter.insertException(rulesetParser, label, msg); } } | ttask = ExtendedIdentifier() end = ";" { node = new IlrTaskInstanceExpression(flow, ttask, end); node.setFlowIndex(flowIndex++); } ) { return node; } } void IfFlowStatementLookAhead() : { } { [Identifier() ":"] "if" } IlrFlowNodeExpression IfFlowStatement(IlrFlowDefinition flow) : { Token keyword; Token label=null; Token elsekeyword=null; Token opar; Token cpar; Token obrace; Token cbrace; IlrTestExpression test; IlrTaskIfNodeExpression ifNode=null; IlrReflect reflect = rulesetParser.reflect; IlrConstantValue tvalue = reflect.factory.TRUE; IlrConstantValue fvalue = reflect.factory.FALSE; IlrTaskJoinNodeExpression joinNode=null; } { [label = Identifier() ":" ] keyword = "if" opar = "(" test=TestExpression() cpar = ")" { if (label == null) ifNode = new IlrTaskIfNodeExpression(flow, keyword, opar, cpar); else { ifNode = new IlrTaskIfNodeExpression(flow, label, keyword, opar, cpar); flow.addNamedNode(ifNode); } ifNode.setFlowIndex(flowIndex++); ifNode.setTest(test); } // Then part Branch(flow, ifNode, tvalue) // Else part [ LOOKAHEAD(1) elsekeyword="else" Branch(flow, ifNode, fvalue) ] { if (elsekeyword == null) flow.addPendingNode(ifNode, ifNode, fvalue); ifNode.close(flow, keyword); return ifNode; } } void SwitchFlowStatementLookAhead() : { } { [Identifier() ":"] "switch" } IlrFlowNodeExpression SwitchFlowStatement(IlrFlowDefinition flow) : { Token keyword; boolean defFound=false; Token obrace; Token cbrace; Token label=null; IlrExpression expr; Token tcase; Object object; IlrReflectClass type; IlrConstantValue constant=null; IlrReflect reflect = rulesetParser.reflect; IlrTaskSwitchNodeExpression switchNode = null; IlrTaskJoinNodeExpression joinNode=null; Token opar=null; Token cpar=null; } { [label = Identifier() ":" ] keyword = "switch" opar="(" expr = Expression() cpar=")" { if (label == null) switchNode = new IlrTaskSwitchNodeExpression(flow, keyword, opar, cpar); else { switchNode = new IlrTaskSwitchNodeExpression(flow, label, keyword, opar, cpar); flow.addNamedNode(switchNode); } switchNode.setFlowIndex(flowIndex++); switchNode.setExpression(expr); } obrace = "{" // Case part ( (LOOKAHEAD(1) keyword = "case" tcase = <INTEGER_LITERAL> ":" { object = parseIntegerLiteral(tcase,1); if (object instanceof Integer) type = reflect.intType(); else type = reflect.longType(); constant = new IlrConstantValue(reflect,type,object); } | keyword = "default" ":" { defFound = true; } ) Branch(flow, switchNode, constant) { constant = null; } )* cbrace = "}" { if (!defFound) flow.addPendingNode(switchNode, switchNode, null); switchNode.close(flow, keyword); return switchNode; } } void WhileFlowStatementLookAhead() : { } { LOOKAHEAD(2) "while" "(" | Identifier() ":" "while" "(" } IlrFlowNodeExpression WhileFlowStatement(IlrFlowDefinition flow) : { Token keyword; Token obrace; Token cbrace; Token label=null; IlrTestExpression test; IlrTaskWhileNodeExpression whileNode=null; IlrTaskJoinNodeExpression joinNode=null; Token opar=null; Token cpar=null; } { ( LOOKAHEAD(2) keyword = "while" opar="(" | label = Identifier() ":" keyword = "while" opar="(" ) test=TestExpression() cpar=")" { if (label == null) { whileNode = new IlrTaskWhileNodeExpression(flow, keyword, opar, cpar); } else { whileNode = new IlrTaskWhileNodeExpression(flow, keyword, label, opar, cpar); flow.addNamedNode(whileNode); } whileNode.setFlowIndex(flowIndex++); whileNode.setTestExpression(test); } Branch(flow, whileNode, null) { whileNode.close(flow, keyword); return whileNode; } } void BracedBranch(IlrFlowDefinition flow, IlrSplitNodeExpression fatherNode, IlrConstantValue value) : { IlrFlowNodeExpression node=null; IlrFlowNodeExpression node1=null; IlrReflect reflect = rulesetParser.reflect; Token obrace; Token cbrace; } { obrace = "{" ( "}" { flow.addPendingNode(fatherNode, fatherNode, value); } | ( node = FlowStatement(flow) { node.scope = fatherNode; if (fatherNode.isIfNode()) { if (value == reflect.factory.TRUE) ((IlrTaskIfNodeExpression)fatherNode).setTrueNode(node); else ((IlrTaskIfNodeExpression)fatherNode).setFalseNode(node); } else if (fatherNode.isSwitchNode()) { if (value == null) ((IlrTaskSwitchNodeExpression)fatherNode).setDefaultNode(node); else ((IlrTaskSwitchNodeExpression)fatherNode).setCaseNode(value, node); } else { fatherNode.addOutputNode(node); } if (node.isSplitNode()) { ((IlrSplitNodeExpression)node).joinNode.scope = node.scope; node = ((IlrSplitNodeExpression)node).joinNode; } } ) ( node1 = FlowStatement(flow) { if (node1 != null) { node1.scope = fatherNode; node.addOutputNode(node1); if (!node1.isSplitNode()) node = node1; else { ((IlrSplitNodeExpression)node1).joinNode.scope = node1.scope; node = ((IlrSplitNodeExpression)node1).joinNode; } } } )* { flow.addPendingNode(fatherNode, node, value); } cbrace = "}" ) } void Branch(IlrFlowDefinition flow, IlrSplitNodeExpression fatherNode, IlrConstantValue value) : { IlrFlowNodeExpression node=null; IlrFlowNodeExpression node1=null; IlrReflect reflect = rulesetParser.reflect; boolean gotoFound=false; Token obrace; Token cbrace; } { ( node = FlowStatement(flow) { node.scope = fatherNode; if (fatherNode.isIfNode()) { if (value == reflect.factory.TRUE) ((IlrTaskIfNodeExpression)fatherNode).setTrueNode(node); else ((IlrTaskIfNodeExpression)fatherNode).setFalseNode(node); } else if (fatherNode.isSwitchNode()) { if (value == null) ((IlrTaskSwitchNodeExpression)fatherNode).setDefaultNode(node); else ((IlrTaskSwitchNodeExpression)fatherNode).setCaseNode(value, node); } else fatherNode.addOutputNode(node); if (node.isSplitNode()) flow.addPendingNode(fatherNode, ((IlrSplitNodeExpression)node).joinNode, value); else flow.addPendingNode(fatherNode, node, value); } ) | BracedBranch(flow, fatherNode, value) } IlrFlowNodeExpression ForkFlowStatement(IlrFlowDefinition flow) : { Token keyword=null; Token label=null; IlrTaskForkNodeExpression forkNode=null; Token obrace=null; Token cbrace=null; IlrTaskJoinNodeExpression joinNode=null; IlrFlowNodeExpression node=null; } { [label = Identifier() ":" ] keyword = "fork" { if (label == null) forkNode = new IlrTaskForkNodeExpression(flow, keyword); else { forkNode = new IlrTaskForkNodeExpression(flow, keyword, label); flow.addNamedNode(forkNode); } forkNode.setFlowIndex(flowIndex++); } BracedBranch(flow, forkNode, null) (LOOKAHEAD("&&") "&&" BracedBranch(flow,forkNode,null) )* (";")? { forkNode.close(flow, keyword); return forkNode; } } void InitialFinalAction(IlrTaskDefinition task) : { Token keyword; IlrTestExpression test; boolean initial=true; Vector actions; } { (keyword = "initialaction" { if (!task.hasInitialActions()) { task.tinitialactions = keyword; initial = true; } else { String msg = IlrMessages.format("messages.Parsing.12", task.name); rulesetParser.reporter.insertException(rulesetParser, keyword, msg); return; } } | keyword = "finalaction" { if (!task.hasFinalActions()) { task.tfinalactions = keyword; initial = false; } else { String msg = IlrMessages.format("messages.Parsing.13", task.name); rulesetParser.reporter.insertException(rulesetParser, keyword, msg); return; } } ) ("=")? try { (actions = TaskActions(task) (";")? { IlrFunctionDefinition def = new IlrFunctionDefinition(keyword, new Token[0], null); if (actions != null) { for(int i=0; i<actions.size(); i++) def.addAction((IlrActionExpression)actions.elementAt(i)); } if (initial) task.setInitialActions(def); else task.setFinalActions(def); } ) } catch(ParseException ex) { lastCommonTaskToken = keyword; throw ex; } } //--------------------------------------------------------------------------- // Conditions //--------------------------------------------------------------------------- void RuleConditions(IlrRuleDefinition rule) : { Token t,obrace,cbrace; IlrConditionExpression cond; } { t="when" { rule.whenToken = t; } obrace="{" { rule.whenObrace = obrace; } cond=FirstPattern() { rule.addCondition(cond); } ( cond=LhsPattern() { rule.addCondition(cond); } )* cbrace="}" { rule.whenCbrace = cbrace; } } //--------------------------------------------------------------------------- // Condition part //--------------------------------------------------------------------------- IlrConditionExpression FirstPattern() : { IlrConditionExpression cond; Token t = null; } { cond=NotPattern() { return cond; } | cond=ExistsPattern() { return cond; } | (LOOKAHEAD(2) t=Variable() ":")? ( cond=ClassPattern(t) { return cond; } | cond=CollectPattern(t) { return cond; } ) } IlrConditionExpression LhsPattern() : { IlrConditionExpression cond; } { LOOKAHEAD(4) cond=FirstPattern() { return cond; } | cond=EvaluatePattern() { return cond; } | cond=WaitPattern() { return cond; } } IlrConditionExpression ClassPattern(Token t) : { IlrClassExpression expr; } { expr=ClassCondition(SimpleClassExpr) ";" { IlrSimpleClassExpression cond = (IlrSimpleClassExpression)expr; cond.setObjectBinding(t); return cond; } } IlrConditionExpression CollectPattern(Token t) : { IlrExpression container = null; IlrClassExpression element = null; IlrAndExpression tests = null; IlrCollectExpression cond; } { "collect" [ "(" [container=Expression()] ")" ] element=ClassCondition(CollectClassExpr) [ "where" "(" tests=TestAssignmentSuite() ")" ] ";" { cond = new IlrCollectExpression(container, element, tests); cond.setObjectBinding(t); return cond; } } IlrConditionExpression NotPattern() : { IlrClassExpression cond; } { "not" cond=ClassCondition(NotClassExpr) ";" { return cond; } } IlrConditionExpression ExistsPattern() : { IlrClassExpression cond; } { "exists" cond=ClassCondition(ExistsClassExpr) ";" { return cond; } } IlrConditionExpression EvaluatePattern() : { Token t; IlrAndExpression expr; } { t="evaluate" "(" expr=TestAssignmentSuite() ")" ";" { return new IlrEvaluateExpression(t,expr); } } IlrConditionExpression WaitPattern() : { Token keyword; Token label = null; Token logicalToken = null; boolean until = false; IlrExpression time; IlrTimeExpression cond; IlrConditionExpression element; } { (LOOKAHEAD(2) label=Variable() ":")? // LOOKAHEAD to correct BR2003.816 keyword="wait" (logicalToken="logical")? { cond = new IlrTimeExpression(keyword,logicalToken); if (label != null) cond.setObjectBinding(label); } ( ("until" { until=true; } )? time=Expression() { cond.setTime(until,time); } )? ( ";" | "{" ( element=FirstPattern() { cond.addCondition(element); } )* "}" ) { return cond; } } //--------------------------------------------------------------------------- // Class Condition //--------------------------------------------------------------------------- IlrClassExpression ClassCondition(int kind) : { Token event = null; IlrTypeExpression type; IlrAndExpression expr = null; IlrExpression enumerator = null; Token clause = null; } { [ event="event" ] type=TypeName() "(" [ expr=TestAssignmentSuite() ] ")" [ (clause="from" | clause="in") enumerator=Expression() ] { IlrClassExpression condition; switch(kind) { case SimpleClassExpr: condition = new IlrSimpleClassExpression(type,expr); break; case NotClassExpr: condition = new IlrNotClassExpression(type,expr); break; case ExistsClassExpr: condition = new IlrExistsClassExpression(type,expr); break; case CollectClassExpr: condition = new IlrCollectElementExpression(type,expr); break; default: condition = null; break; } condition.eventKeyword = event; condition.enumeratorClause = clause; condition.enumerator = enumerator; return condition; } } //--------------------------------------------------------------------------- // Tests //--------------------------------------------------------------------------- IlrAndExpression TestAssignmentSuite() : { IlrAndExpression expr = new IlrAndExpression(); IlrOrExpression tmp; } { tmp=TestAssignmentSet() { expr.tests.addElement(tmp); } (LOOKAHEAD(2) ";" tmp=TestAssignmentSet() { expr.tests.addElement(tmp);})* [";"] { return expr; } } //--------------------------------------------------------------------------- // Decomposition of tests and assignment (combination of OR, AND) //--------------------------------------------------------------------------- IlrOrExpression TestAssignmentSet() : { IlrOrExpression expr; } { expr=OrTestAssignmentSet() { return expr; } } IlrOrExpression OrTestAssignmentSet() : { IlrOrExpression expr = new IlrOrExpression(); IlrAndExpression test; } { test=AndTestAssignmentSet() { expr.tests.addElement(test); } ("||" test=AndTestAssignmentSet() { expr.tests.addElement(test); } )* { return expr; } } IlrAndExpression AndTestAssignmentSet() : { IlrAndExpression expr = new IlrAndExpression(); IlrTestExpression test; } { test=TestAssignment() { expr.tests.addElement(test); } ("&&" test=TestAssignment() { expr.tests.addElement(test); } )* { return expr; } } IlrTestExpression TestAssignment() : { IlrTestExpression expr; } { ( LOOKAHEAD(Variable() ":") expr=VariableAssignment() | LOOKAHEAD(UnaryExpression()) expr=BooleanExpression() | "(" expr=TestAssignmentSet() ")" | "!" expr=TestAssignment() { expr = new IlrFalseTestExpression(expr); } ) { return expr; } } //--------------------------------------------------------------------------- // Assignments //--------------------------------------------------------------------------- IlrAndExpression VariableAssignment() : { IlrAndExpression expr = new IlrAndExpression(); IlrVariableExpression variable; IlrExpression value; Token t; IlrTestExpression test; } { t=Variable() ":" value=Expression() { variable = new IlrVariableExpression(t); expr.tests.addElement(new IlrBindingExpression(variable,value)); } ("&" test=BooleanArguments(variable) { expr.tests.addElement(test); } )* { return expr; } } //--------------------------------------------------------------------------- // Tests //--------------------------------------------------------------------------- IlrAndExpression BooleanExpression() : { IlrAndExpression expr = new IlrAndExpression(); IlrExpression initial; IlrTestExpression test; } { initial=Expression() [ test=BooleanArguments(initial) { expr.tests.addElement(test); } ("&" test=BooleanArguments(initial) { expr.tests.addElement(test); } )* ] { if (expr.tests.size() == 0) expr.tests.addElement(new IlrTrueTestExpression(initial)); return expr; } } IlrTestExpression BooleanArguments(IlrExpression e1) : { IlrTestExpression test; } { (LOOKAHEAD(TypeTestArgumentsLookAhead()) test=TypeTestArguments(e1) | LOOKAHEAD(TemporalTestOperator()) test=TemporalTestArguments(e1) | test=ValueTestArguments(e1) | test=UnknownTestArguments(e1) | test=KnownTestArguments(e1)) { return test; } } IlrTestExpression UnknownTestArguments(IlrExpression e1) : { } { "isunknown" { return new IlrUnknownTestExpression(e1, true); } } IlrTestExpression KnownTestArguments(IlrExpression e1) : { } { "isknown" { return new IlrUnknownTestExpression(e1, false); } } void TypeTestArgumentsLookAhead() : { } { ("instanceof" | "is") TypeName() } IlrTypeTestExpression TypeTestArguments(IlrExpression e1) : { IlrTypeExpression type; } { ("instanceof" | "is") type=TypeName() { return new IlrTypeTestExpression(e1,type); } } // Modified for in and !in predicate IlrBinaryTestExpression ValueTestArguments(IlrExpression e1) : { IlrBinaryTestExpression expr=null; } { (LOOKAHEAD(3) expr = ValueTestArguments1(e1) | expr = ValueTestArguments2(e1)) { return expr; } } IlrExpression ListExpression() : { IlrExpression expr = null; Vector values = new Vector(); Token begin=null; Token end=null; } { begin = "{" expr = Expression() { values.addElement(expr); } ("," expr = Expression() { values.addElement(expr); } )* end = "}" { return new IlrNewArrayInstanceExpression(begin, end, null, values); } } IlrBinaryTestExpression ValueTestArguments1(IlrExpression e1) : { IlrExpression e2; Token t = null; Token t1 = null; boolean not=false; int kind = 0; } { [t = "!" { not = true; }] t1 = "in" e2=ListExpression() { if (!not) { kind = IlrBinaryTester.IN; return new IlrContainExpression(kind, e1, e2); } else { kind = IlrBinaryTester.NOT_IN; return new IlrContainExpression(kind, e1, e2); } } } IlrBinaryTestExpression ValueTestArguments2(IlrExpression e1) : { IlrExpression e2; Token t = null; Token t1 = null; int p = 0; int kind = 0; } { (p=PredefinedPredicate() | t1 = "!" t = "in" | t=Identifier()) e2=Expression() { switch(p) { case PredEQ: kind = IlrBinaryTester.EQUAL; return new IlrComparativeExpression(kind,e1,e2); case PredNE: kind = IlrBinaryTester.NOT_EQUAL; return new IlrComparativeExpression(kind,e1,e2); case PredLT: kind = IlrBinaryTester.LESS_THAN; return new IlrComparativeExpression(kind,e1,e2); case PredGT: kind = IlrBinaryTester.GREATER_THAN; return new IlrComparativeExpression(kind,e1,e2); case PredLE: kind = IlrBinaryTester.LESS_OR_EQUAL; return new IlrComparativeExpression(kind,e1,e2); case PredGE: kind = IlrBinaryTester.GREATER_OR_EQUAL; return new IlrComparativeExpression(kind,e1,e2); default: if (t.image.equals("in")) { if (t1 == null) { kind = IlrBinaryTester.IN; return new IlrContainExpression(kind, e1, e2); } else { kind = IlrBinaryTester.NOT_IN; return new IlrContainExpression(kind, e1, e2); } } else return new IlrPredicateExpression(t,e1,e2); } } } // End - Modified for in and !in predicate int PredefinedPredicate() : {} { "==" { return PredEQ; } | "!=" { return PredNE; } | "<" { return PredLT; } | ">" { return PredGT; } | "<=" { return PredLE; } | ">=" { return PredGE; } } void TemporalTestOperator() : { } { "occursin" | "before" | "after" } IlrTemporalTestExpression TemporalTestArguments(IlrExpression e1) : { IlrTemporalTestExpression test; } { (test = UnaryTemporalTestArguments(e1) | test = BinaryTemporalTestArguments(e1)) { return test; } } IlrTemporalTestExpression UnaryTemporalTestArguments(IlrExpression e1) : { IlrTimeInterval interval; Token keyword=null; } { keyword = "occursin" interval=TimeInterval() { return new IlrUnaryTemporalTestExpression(e1,interval, keyword); } } IlrTemporalTestExpression BinaryTemporalTestArguments(IlrExpression e1) : { Token operator; IlrTimeInterval interval = null; IlrExpression e2; } { ( operator="before" | operator="after" ) [ interval=TimeInterval() ] e2=Expression() { return new IlrBinaryTemporalTestExpression(operator,e1,e2,interval); } } IlrTimeInterval TimeInterval() : { IlrExpression lo, hi; } { "[" ( LOOKAHEAD("$") "$" { lo = null; } | lo = Expression() ) "," ( LOOKAHEAD("$") "$" { hi = null; } | hi = Expression() ) "]" { return new IlrTimeInterval(lo,hi); } } //--------------------------------------------------------------------------- // Expressions //--------------------------------------------------------------------------- /* IlrExpression Expression() : { IlrExpression expr; } { expr=ConditionalExpression() { return expr; } } IlrExpression ConditionalExpression() : {} { AdditiveExpression() [ "?" Expression() ":" ConditionalExpression() ] { return null; } } */ IlrExpression ExpressionEof() : { IlrExpression expr; } { expr=Expression() <EOF> { return expr; } } IlrExpression Expression() : { IlrExpression expr; } { expr=AdditiveExpression() { return expr; } } IlrExpression AdditiveExpression() : { IlrExpression expr,e1,e2; Token t; int op; } { ( expr=MultiplicativeExpression() ( (t="+" | t="-") e2=MultiplicativeExpression() { e1 = expr; if (t.image.equals("+")) op = IlrBinaryOperator.ADD; else op = IlrBinaryOperator.SUBTRACT; expr = new IlrBinaryExpression(t,op,e1,e2); } )* ) { return expr; } } IlrExpression MultiplicativeExpression() : { IlrExpression expr,e1,e2; Token t; int op; } { ( expr=UnaryExpression() ( (t="*" | t="/" | t="%") e2=UnaryExpression() { e1 = expr; if (t.image.equals("*")) op = IlrBinaryOperator.MULTIPLY; else if (t.image.equals("/")) op = IlrBinaryOperator.DIVIDE; else op = IlrBinaryOperator.REMAINDER; expr = new IlrBinaryExpression(t,op,e1,e2); } )* ) { return expr; } } IlrExpression UnaryExpression() : { IlrExpression expr; IlrExpression tmp; Token t; } { ( LOOKAHEAD ( SignedNumberLookahead() ) expr=SignedNumberExpression () | (t="+" | t="-" | t="!" | t="++" | t="--") expr=UnaryExpression() { tmp = expr; if (t.image.equals("!")) expr = new IlrUnaryExpression(t,IlrUnaryOperator.NOT,tmp); else if (t.image.equals("+")) expr = new IlrUnaryExpression(t,IlrUnaryOperator.POSITIVE,tmp); else if (t.image.equals("-")) expr = new IlrUnaryExpression(t,IlrUnaryOperator.NEGATIVE,tmp); else if (t.image.equals("++")) expr = new IlrUnaryExpression(t,IlrUnaryOperator.PREFIX_INCR,tmp); else expr = new IlrUnaryExpression(t,IlrUnaryOperator.PREFIX_DECR,tmp); } | expr=UnaryExpressionNotPlusMinus() ) { return expr; } } IlrExpression UnaryExpressionNotPlusMinus() : { IlrExpression expr; Token t = null; int kind; } { ( LOOKAHEAD(CastLookahead()) expr=CastExpression() | LOOKAHEAD(TimeofLookahead()) expr=TimeofExpression() | expr=PrimaryExpression() [ (t="++" | t="--") ] { if (t != null) { if (t.image.equals("++")) kind = IlrUnaryOperator.POSTFIX_INCR; else kind = IlrUnaryOperator.POSTFIX_DECR; expr = new IlrUnaryExpression(t,kind,expr); } } ) { return expr; } } void CastLookahead() : {} { "(" TypeName() ")" ( "!" | "+" | "-" | "++" | "--" | "(" | "new" | LiteralLookahead() | Name() ) } IlrExpression CastExpression() : { Token open; Token close; IlrTypeExpression type; IlrExpression expr; } { open="(" type=TypeName() close=")" expr=UnaryExpression() { return new IlrCastExpression(open,close,type,expr); } } void TimeofLookahead() : { } { "timeof" } IlrExpression TimeofExpression() : { Token timeof, open, close; IlrExpression expr; } { timeof="timeof" open="(" expr=Expression() close=")" { return new IlrTimeofExpression(timeof, open, expr, close); } } IlrExpression PrimaryExpression() : { IlrExpression expr; } { expr=PrimaryPrefix() ( LOOKAHEAD(2) expr=PrimarySuffix(expr) )* { return expr; } } IlrExpression PrimaryPrefix() : { IlrExpression expr; } { ( expr=Literal() | expr=Name() | expr=AllocationExpression() | "(" expr=Expression() ")" ) { return expr; } } IlrExpression AllocationExpression() : { IlrSimpleTypeExpression type; IlrArgumentList arguments; Token t; } { t="new" type=SimpleTypeName() ( arguments=Arguments() { return new IlrNewInstanceExpression(t,type,arguments); } | arguments=ArrayDims() { return new IlrNewArrayInstanceExpression(t,type,arguments); } ) } IlrArgumentList ArrayDims() : { IlrExpression expr; Token open; Token close; Vector vect = new Vector(5); } { open="[" expr = Expression() close="]" { vect.addElement(expr); } (LOOKAHEAD(2) "[" expr = Expression() close="]" { vect.addElement(expr); } )* { return new IlrArgumentList(open,close,vect); } } IlrExpression PrimarySuffix(IlrExpression expr) : { IlrArgumentList args; Token t; } { ( "." (t= Identifier() | // BR 2003.675 t=<VARIABLE> { t.image = '?' + t.image; } ) { return new IlrNameAccessExpression(expr,t); } | args=ArrayArguments() { return new IlrArrayElementExpression(expr,args); } | args=Arguments() { return new IlrFunctionCallExpression(expr,args); } ) } IlrArgumentList ArrayArguments() : { Token open; Token close; Vector v = new Vector(5); } { open="[" [ ArgumentList(v) ] close="]" { return new IlrArgumentList(open,close,v); } } IlrArgumentList Arguments() : { Token open; Token close; Vector v = new Vector(5); } { open="(" [ ArgumentList(v) ] close=")" { return new IlrArgumentList(open,close,v); } } void ArgumentList(Vector args) : { IlrExpression expr; } { expr=Expression() { args.addElement(expr); } ( "," expr=Expression() { args.addElement(expr); } )* } // // Warning: Here, a name is starting with an Identifier() or // a Variable(). As Variable() is more generic, we use this form // for desambiguiting the grammar. But the action should build // objects of different classes. Thus, a form "?XXX" is never considered // to be a name, while "XXX" can be processed as a variable. // IlrExpression Name() : { Token t; IlrExpression expr; } { t=Variable() { if (t.kind == VARIABLE) expr = new IlrVariableExpression(t); else expr = new IlrIdentifierExpression(t); } (LOOKAHEAD(2) "." t=Identifier() { expr = new IlrNameAccessExpression(expr,t); } )* { return expr; } } //--------------------------------------------------------------------------- // Rule Actions //--------------------------------------------------------------------------- void RuleActions(IlrRuleDefinition rule) : { Token t,obrace,cbrace; IlrActionExpression statement; } { t="then" { rule.thenToken = t; } obrace="{" { rule.thenObrace = obrace; } (statement=ActionStatement() { rule.addAction(statement); })* (statement=TimeOutStatement() { rule.addAction(statement); })* cbrace="}" { rule.thenCbrace = cbrace; } ( t = "else" { rule.elseToken = t; } obrace="{" { rule.elseObrace = obrace; } (statement=ActionStatement() { rule.addElseAction(statement); })* (statement=TimeOutStatement() { rule.addElseAction(statement); })* cbrace="}" { rule.elseCbrace = cbrace; } )? } IlrActionExpression ActionStatement() : { IlrActionExpression statement; } { ( LOOKAHEAD(SimpleStatement()) statement=SimpleStatement() | LOOKAHEAD(3) statement=BindStatement() | LOOKAHEAD(3) statement=AssertStatement() | LOOKAHEAD(3) statement=RetractStatement() | LOOKAHEAD(3) statement=UpdateStatement() | LOOKAHEAD(3) statement=ModifyStatement() | LOOKAHEAD(3) statement=ApplyStatement() | LOOKAHEAD(3) statement=IfStatement() | LOOKAHEAD(3) statement=ExecuteStatement() | LOOKAHEAD(3) statement=WhileStatement() | LOOKAHEAD(3) statement=ForStatement() | LOOKAHEAD(3) statement=ReturnStatement() | LOOKAHEAD(3) statement=BreakStatement() | LOOKAHEAD(3) statement=ContinueStatement() | LOOKAHEAD(3) statement=ThrowStatement() | LOOKAHEAD(3) statement=TryStatement() ) { return statement; } } IlrActionExpression TryStatement() : { Token keyword; Token obrace = null; Token cbrace = null; Vector actions = new Vector(5,5); IlrActionExpression action; IlrFinallyBlockExpression finallyExpr = null; IlrTryCatchFinallyExpression expr; Vector catches = null; } { keyword="try" obrace="{" ( (action=ActionStatement() { actions.addElement(action); })* ) cbrace="}" ( finallyExpr = Finally() | (catches = Catches())+ (finallyExpr = Finally())? ) { expr = new IlrTryCatchFinallyExpression(keyword, obrace, cbrace, null, actions); if (catches != null) expr.setCatchPart(catches); if (finallyExpr != null) expr.setFinallyPart(finallyExpr); return expr; } } Vector Catches() : { IlrCatchBlockExpression catchClause = null; Vector catchExpressions = new Vector(5); } { catchClause = CatchClause() { catchExpressions.add(catchClause); } ( LOOKAHEAD(2) catchClause = CatchClause() { catchExpressions.addElement(catchClause); } )* { return catchExpressions; } } IlrCatchBlockExpression CatchClause() : { Token begin; Token variable; Token obrace = null; Token cbrace = null; Token opar; Token cpar; Vector actions = new Vector(5,5); IlrActionExpression action; IlrFunctionArgExpression arg; IlrCatchBlockExpression expr; } { begin="catch" opar = "(" (arg = FunctionArgDefinition()) cpar = ")" obrace="{" ( (action=ActionStatement() { actions.addElement(action); })* ) cbrace="}" { expr = new IlrCatchBlockExpression(begin, obrace, cbrace, null, actions, arg); return expr; } } IlrFinallyBlockExpression Finally() : { Token begin; Token variable; Token obrace = null; Token cbrace = null; Vector actions = new Vector(5,5); IlrActionExpression action; IlrFinallyBlockExpression expr; } { begin="finally" obrace="{" ( (action=ActionStatement() { actions.addElement(action); })* ) cbrace="}" { expr = new IlrFinallyBlockExpression(begin,obrace,cbrace, null, actions); return expr; } } IlrActionExpression ThrowStatement() : { Token begin; Token variable; IlrExpression expr=null; Token end; } { begin="throw" (expr=Expression()) end=";" { return new IlrThrowExpression(begin, end, expr); } } IlrActionExpression ReturnStatement() : { Token begin; Token variable; IlrExpression expr=null; Token end; } { begin="return" (expr=Expression())? end=";" { return new IlrReturnExpression(begin, end, expr); } } IlrActionExpression BreakStatement() : { Token begin; Token end; } { begin="break" end=";" { return new IlrBreakExpression(begin, end ); } } IlrActionExpression ContinueStatement() : { Token begin; Token end; } { begin="continue" end=";" { return new IlrContinueExpression(begin, end ); } } IlrActionExpression BindStatement() : { Token keyword; Token variable; IlrExpression expr; Token end; } { ( keyword= "bind" | keyword = "var" ) variable=Variable() "=" expr=Expression() end=";" { return new IlrBindExpression(keyword,end,variable,expr); } } IlrAssertExpression AssertStatement() : { IlrAssertExpression.Sketch sketch = new IlrAssertExpression.Sketch(); } { (sketch.keyword="assert" | sketch.keyword="insert") ( [ "logical" { sketch.logical = true; } ] AssertedObjectAndInitStatements(sketch) | "event" { sketch.event = true; } AssertedEventAndInitStatements(sketch) ) { return new IlrAssertExpression(sketch); } } void AssertedObjectAndInitStatements(IlrAssertExpression.Sketch sketch) : { IlrSimpleTypeExpression type; IlrArgumentList args = null; } { ( type=SimpleTypeName() [args=Arguments()] { sketch.object = new IlrNewInstanceExpression(null,type,args); } | "(" sketch.object=Expression() ")" ) AssertInitStatements(sketch) } void AssertedEventAndInitStatements(IlrAssertExpression.Sketch sketch) : { IlrSimpleTypeExpression type; IlrArgumentList args = null; IlrExpression expr = null; } { ( type=SimpleTypeName() [args=Arguments()] { sketch.object = new IlrNewInstanceExpression(null,type,args); } AssertInitStatements(sketch) | "(" expr=Expression() ")" ( AssertInitStatements(sketch) { sketch.object = expr; } | AssertedObjectAndInitStatements(sketch) { sketch.timeexpr = expr; } ) ) } void AssertInitStatements(IlrAssertExpression.Sketch sketch) : { } { ( sketch.obrace="{" SimpleStatementBlock(sketch.actions) sketch.cbrace="}" [ sketch.semiColon=";" ] | sketch.semiColon=";" ) } IlrRetractExpression RetractStatement() : { Token keyword; Token end; IlrExpression object; } { keyword="retract" object=PrimaryExpression() end=";" { return new IlrRetractExpression(keyword,end,object); } } IlrUpdateExpression UpdateStatement() : { Token keyword; Token end; IlrExpression object; boolean refresh = false; } { keyword="update" ["refresh" { refresh = true; } ] object=PrimaryExpression() end=";" { return new IlrUpdateExpression(keyword,end,object,refresh); } } IlrModifyExpression ModifyStatement() : { Token keyword; Token obrace = null; Token cbrace = null; Token end = null; IlrExpression object; Vector actions = new Vector(5,5); boolean refresh = false; } { keyword="modify" ["refresh" { refresh = true; } ] object=PrimaryExpression() obrace="{" SimpleStatementBlock(actions) cbrace="}" [end=";"] { return new IlrModifyExpression(keyword,obrace,obrace,end, object,actions,refresh); } } IlrApplyExpression ApplyStatement() : { Token keyword; Token obrace = null; Token cbrace = null; Token end = null; IlrExpression object; Vector actions = new Vector(5,5); } { keyword="apply" object=PrimaryExpression() obrace="{" SimpleStatementBlock(actions) cbrace="}" [end=";"] { return new IlrApplyExpression(keyword,obrace,obrace,end, object,actions); } } IlrExecuteExpression ExecuteStatement() : { Token keyword; Token obrace = null; Token cbrace = null; Token end = null; Vector actions = new Vector(5,5); IlrActionExpression action; } { keyword="execute" ( action=ActionStatement() { actions.addElement(action); } | obrace="{" (action=ActionStatement() { actions.addElement(action); })* cbrace="}" [end=";"] ) { return new IlrExecuteExpression(keyword,obrace,cbrace,end,actions); } } IlrActionExpression IfStatement() : { IlrIfElseExpression expr; Token keyword; Token opar; Token cpar; Token obrace = null; Token cbrace = null; IlrTestExpression test; Vector ifStatements = new Vector(5,5); Token elseKeyword = null; Vector elseStatements = new Vector(5,5); IlrActionExpression stat; } { keyword="if" opar="(" test=TestExpression() cpar=")" ( stat=ActionStatement() { ifStatements.addElement(stat); } | obrace="{" ( stat=ActionStatement() { ifStatements.addElement(stat); } )* cbrace="}" ) { expr = new IlrIfElseExpression(keyword,obrace,cbrace, opar,cpar,null,test,ifStatements); } [ LOOKAHEAD(1) elseKeyword="else" ( stat=ActionStatement() { elseStatements.addElement(stat); } | obrace="{" ( stat=ActionStatement() { elseStatements.addElement(stat); } )* cbrace="}" ) { expr.setElsePart(elseKeyword,obrace,cbrace,elseStatements); } ] { return expr; } } IlrActionExpression WhileStatement() : { Token keyword; Token obrace = null; Token cbrace = null; Token opar; Token cpar; Token end = null; Vector actions = new Vector(5,5); IlrActionExpression action; IlrTestExpression test; } { keyword="while" opar="(" test=TestExpression() cpar=")" ( action=ActionStatement() { actions.addElement(action); } | obrace="{" (action=ActionStatement() { actions.addElement(action); })* cbrace="}" [end=";"] ) { return new IlrWhileExpression(keyword,obrace,cbrace,opar,cpar,end, test,actions); } } IlrActionExpression ForStatement() : { Token keyword; Token obrace = null; Token cbrace = null; Token opar; Token cpar; Token semiColonEnd = null; Token semiColon1; Token semiColon2; Vector actions = new Vector(5,5); IlrForBlockExpression init = null; IlrForBlockExpression next = null; IlrActionExpression action; IlrTestExpression test = null; } { keyword="for" opar="(" [init = ForBlockExpression()] semiColon1=";" [test=TestExpression()] semiColon2=";" [next = ForBlockExpression ()] cpar=")" ( action=ActionStatement() { actions.addElement(action); } | obrace="{" (action=ActionStatement() { actions.addElement(action); })* cbrace="}" [semiColonEnd=";"] ) { return new IlrForExpression(keyword,obrace,cbrace,opar,cpar, semiColon1, semiColon2, semiColonEnd, init, test, next, actions); } } IlrForBlockExpression ForBlockExpression() : { IlrActionExpression action; IlrForBlockExpression block = new IlrForBlockExpression ( getToken(1), getToken(1) ); } { ( action=ForSimpleStatement() | action=ForBindStatement() ) { block.addStatement( action ); } ( "," ( action=ForSimpleStatement() | action=ForBindStatement() ) { block.addStatement( action ); } )* { return block; } } IlrActionStatement ForSimpleStatement() : { IlrExpression expr; IlrExpression right = null; int kind = -1; } { expr=UnaryExpression() [kind=AssignmentOperator() right=Expression()] { if (right == null) return new IlrActionStatement(expr,getToken(1)); else return new IlrActionAssignStatement(expr,kind,right,getToken(1)); } } IlrActionExpression ForBindStatement() : { Token keyword; Token variable; IlrExpression expr; } { ( keyword= "bind" | keyword = "var" ) variable=Variable() "=" expr=Expression() { return new IlrBindExpression(keyword,getToken(1),variable,expr); } } IlrActionExpression TimeOutStatement() : { Token keyword; Token obrace = null; Token cbrace = null; Token end = null; Vector actions = new Vector(5,5); IlrActionExpression action; Token label; } { keyword="timeout" label=Variable() ( action=ActionStatement() { actions.addElement(action); } | obrace="{" (action=ActionStatement() { actions.addElement(action); })* cbrace="}" [end=";"] ) { return new IlrTimeOutExpression(keyword,obrace,cbrace,end, label,actions); } } void StatementBlockEof(Vector vector) : { IlrActionExpression stat; } { ( ( stat=ActionStatement() ) { vector.addElement(stat); } )* <EOF> } void SimpleStatementBlock(Vector vector) : { IlrActionExpression stat; } { ( (stat=SimpleStatement() | stat=BindStatement()) { vector.addElement(stat); } )* } IlrActionStatement SimpleStatement() : { IlrExpression expr; IlrExpression right = null; int kind = -1; Token end; } { expr=UnaryExpression() [kind=AssignmentOperator() right=Expression()] end=";" { if (right == null) return new IlrActionStatement(expr,end); else return new IlrActionAssignStatement(expr,kind,right,end); } } int AssignmentOperator() : {} { "=" { return IlrAssignment.SIMPLE_ASSIGN; } | "*=" { return IlrAssignment.MULTIPLY_ASSIGN; } | "/=" { return IlrAssignment.DIVIDE_ASSIGN; } | "%=" { return IlrAssignment.REMAINDER_ASSIGN; } | "+=" { return IlrAssignment.ADD_ASSIGN; } | "-=" { return IlrAssignment.SUBTRACT_ASSIGN; } } //--------------------------------------------------------------------------- // Conventional test expressions to be used in RHS //--------------------------------------------------------------------------- IlrTestExpression TestExpression() : { IlrOrExpression expr = new IlrOrExpression(); IlrTestExpression test; } { test=AndTestExpression() { expr.tests.addElement(test); } ("||" test=AndTestExpression() { expr.tests.addElement(test); } )* { if (expr.tests.size() == 1) return test; else return expr; } } IlrTestExpression AndTestExpression() : { IlrAndExpression expr = new IlrAndExpression(); IlrTestExpression test; } { test=OtherTestExpression() { expr.tests.addElement(test); } ("&&" test=OtherTestExpression() { expr.tests.addElement(test); } )* { if (expr.tests.size() == 1) return test; else return expr; } } IlrTestExpression OtherTestExpression() : { IlrTestExpression expr; } { ( LOOKAHEAD(UnaryExpression()) expr=SimpleTestExpression() | "(" expr=TestExpression() ")" | "!" expr=OtherTestExpression() { expr = new IlrFalseTestExpression(expr); } ) { return expr; } } IlrTestExpression SimpleTestExpression() : { IlrExpression initial; IlrTestExpression test = null; } { initial=Expression() [ test=BooleanArguments(initial) ] { if (test == null) test = new IlrTrueTestExpression(initial); return test; } } // // end of file //
This file was generated on Wed Dec 10 14:24:53 PST 2003 from file parser.jj
by the ilog.language.tools.Hilite Java tool written by Hassan Aït-Kaci