grammar AllocationRuleGrammar; /* Mit dieser Grammatik werden die Allokationsregeln der Template-Schaubilder geparst. */ options { language = Java; } // Lexer Rules L1 : '(' ; R1 : ')' ; L2 : '[' ; R2 : ']' ; COMMA : ',' ; DOT : '.' ; EXCLAMATIONMARK : '!' ; PERCENT : '%' ; QUOTE : '"' ; LOGICALVALUE : 'true' | 'false' ; NATNUM : ('0'..'9')+ ; RELEQUAL : '==' ; NOTEQUAL : '!=' ; GT : '>' ; GE : '>=' ; LT : '<' ; LE : '<=' ; EQUAL : '=' ; PLUS : '+' ; MINUS : '-' ; MULT : '*' ; DIV : '/' ; MIN : 'MIN' ; MAX : 'MAX' ; IN : 'IN' ; LIKE : 'LIKE' ; NOT : 'NOT' ; IS : 'IS' ; NULL : 'NULL' ; LOGICALOPERATOR : '&&' | '||' ; MINUSONE : '(-1)' ; ATTRIBUTWERT : 'ATTRIBUTWERT' ; COUNT : 'Count' ; DURCHSCHNITT : 'DURCHSCHNITT' ; QUANTIL : 'QUANTIL' ; TOP : 'TOP' ; WERT : 'Wert' ; WERTART : 'WERTART' ; WITH : 'WITH' ; ROWNUM : 'rownum' ; /* Bsp. COLUMNREFERENCE: * c050 * */ COLUMNREFERENCE : 'c' ('0'..'9') ('0'..'9') ('0'..'9') ('0'..'9')? ; /* Bsp: ROWREFERENCE: * r260 */ ROWREFERENCE : 'r' ('0'..'9') ('0'..'9') ('0'..'9') ('0'..'9')? ; /* Bsp. ATTRIBUTE: * WM.AI_Einheitennummer_ID * GFW.AI_Wertart_Code * GKA12 * GF122 */ ATTRIBUTE : (ENTITY DOT)? 'AI_' ('a'..'z' | 'A'..'Z' | '0'..'9' | '_')+ // AI-Attribute | ('A'..'Z') ('A'..'Z') 'A'? ('0'..'9') ('0'..'9') ('0'..'9')* | 'AI_Belegnummer_Code' ; /* Bsp. ENTITY: * KR * GFW */ ENTITY : ('A'..'Z') ('A'..'Z') 'W'? ; /* Subschlüssellisten müssen in doppelten Hochkommas angeführt werden und auf "_GL" enden. * Bsp. CODESUBSETKEY: * "RES_Intragroup_Verbindlichkeitenkategorie_GL" * "Sicherungseinrichtung_Resolution_Planning_GL" */ CODESUBSETKEY : QUOTE ('a'..'z' | 'A'..'Z') ('a'..'z' | 'A'..'Z' | '0'..'9' | '_' | '-')* '_GL' QUOTE ; /* Bsp. LIKEKEY: * "E%" */ LIKEKEY : QUOTE ('a'..'z' | 'A'..'Z' | '0'..'9')+ PERCENT QUOTE ; /* Wird für Schlüssel (und Wertarten) verwendet. * Bsp. KEY: * "1Jk2J" * "99991231" * "F 13.02, (r040, c010)" * "N/A" * "ONA" */ KEY : QUOTE ('a'..'z' | 'A'..'Z' | '0'..'9' | '_' | '-' | '/' | DOT | COMMA | L1 | R1 | ' ')+ QUOTE ; /* Bsp TIMEVAR: * (t) * (t0) */ TIMEVAR : L1 't' NATNUM* R1 ; /* Whitespaces werden übersprungen * */ WS : ( ' ' | '\t' | '\n' | '\r' )+ -> skip ; // Parser Rules parse : expression EOF ; /* * * * Bsp. rownumExpression * rownum == 3 * * Bsp. expressionWithTableArithmetic * [KE.AI_Belegnummer_Code == "FinRep" && KE.AI_Meldeposition == "01.00, (r380, c010)"] - c010 * * Bsp. exressionWithFilteredWertartArithmetic * [KE.AI_Belegnummer_Code == "CoRep" && KE.AI_Meldeposition == "01.00, (r010, c010)"] + (-1) [WERTART("NBW") && RP01 IN ("R0520", "R0530") && GF200 NOT IN ("EWR_GR") && GF184 == "NO"] * [KE.AI_Belegnummer_Code == "CoRep" && KE.AI_Meldeposition == "01.00, (r010, c010)"] + [WERTART("ONA", "ZH") && RP01 IN ("R0100", "R0300")] || [SK00 IN ("R0120", "R0161", "R0170", "R0180", "R0190", "R0200", "R0390", "R0400") && WERTART("BW")] * * Bsp. logicalOperatorExpression: * "J" && WM44 IS NOT NULL * GF213 == true || SK14 == true * Alle anderen: Siehe unten. */ expression : expressionInRoundBracket #expRoundBracket | expressionInSquareBracket #expSquareBracket | negatedExpression #expNegated | left=expression op=LOGICALOPERATOR right=expression #expLogicalOp | filterExpression #expFilter | attributeWertExpression #expAttributeWert | attributwertComparisonExpression #expAttributeComparison | countExpression #expCount | durchschnittExpression #expDurchschnitt | likeExpression #expLike | minMaxExpression #expMinMax | quantilExpression #expQuantil | topExpression #expTop | columnArithmetic #expColumnArithmetic | rowArithmetic #expRowArithmetic | columnEquationExpression #expColumnEquation | rowEquationExpression #expRowEquation | wertartExpression #expWertart | filteredWertartArithmetic #expFilteredWertartArithmetic | wertExpression #expExpression | rownumExpression #expRownum | exp=expression op=arithmeticOperator column=COLUMNREFERENCE #expTableArithmeticWithColumn | exp=expression op=arithmeticOperator row=ROWREFERENCE #expTableArithmeticWithRow | left=expression op=arithmeticOperator right=filteredWertartExpression #expExpressionArithmeticFilteredWertartExpression | keyExpression #expKey ; expressionInRoundBracket : L1 exp=expression R1; expressionInSquareBracket : L2 exp=expression R2; /* * Bsp. negatedExpression: * !(WM02 == "NSV" && GF108 == false) */ negatedExpression : EXCLAMATIONMARK exp=expression; /* Bsp. filterExpression: * RP01 IN ("R0520", "R0530") && GF200 NOT IN ("EWR_GR") */ filterExpression : pFilter=filter #filterExpressionDefault | L1 exp=filterExpression R1 #filterExpressionRoundBracket | L2 exp=filterExpression R2 #filterExpressionSquareBracket | left=filterExpression op=LOGICALOPERATOR right=filterExpression #filterExpressionLogicalOperator ; /* * attributenullevaluationexpression: * GKA16 IS NULL * EO40 IS NOT NULL * * Bsp. attributeequationexpression: * WM.AI_Einheitennummer_ID == EM.AI_Einheitennummer_ID * GE00 != "S" * GFA173 == true * * membershipexpression: * BEA03 IN ("1W_2W") * EMA77 IN ("1", "2") * GF200 NOT IN ("EU_GR") */ filter : attribute=ATTRIBUTE IS NULL #filterAttributeIsNull | attribute=ATTRIBUTE IS NOT NULL #filterAttributeIsNotNull | attribute=ATTRIBUTE op=(RELEQUAL | NOTEQUAL) otherAttribute=ATTRIBUTE #filterAttributeEquationExpressionWithAttribute | attribute=ATTRIBUTE op=(RELEQUAL | NOTEQUAL) key=KEY #filterAttributeEquationExpressionWithKey | attribute=ATTRIBUTE op=(RELEQUAL | NOTEQUAL) logicValue=LOGICALVALUE #filterAttributeEquationExpressionWithLogicValue | attribute=ATTRIBUTE IN keyList #filterAttributeMembershipExpressionWithKeyList | attribute=ATTRIBUTE NOT IN keyList #filterAttributeMembershipExpressionWithoutKeyList ; columnEquationExpression : exp=columnEquation ; rowEquationExpression : exp=rowEquation ; rownumExpression : ROWNUM RELEQUAL value=NATNUM ; keyExpression : value=KEY ; /* Bsp. wertartexpression * WERTART("NN") * WERTART("RUECK", "RUEDER") * (-1)WERTART("PWB", "BWB", "WBI1", "WBI1I", "WBI2", "WBI2I") * (-1) WERTART("EWBG") (t0) */ wertartExpression : MINUSONE? WERTART keyList TIMEVAR? ; /* Bsp. attributwertexpression: * ATTRIBUTWERT(EMA83) * ATTRIBUTWERT(GFA203,"RES_ABIL_Risiko_GL") */ attributeWertExpression : ATTRIBUTWERT L1 attribute=ATTRIBUTE (COMMA codesubset)? R1 ; /* Bsp. attributwertcomparisonexpression * ATTRIBUTWERT(GFA188) <= 180 * ATTRIBUTWERT(GFA189) IS NULL */ attributwertComparisonExpression : ATTRIBUTWERT L1 attribute=ATTRIBUTE R1 op=relationalOperator value=NATNUM #attributwertComparisonExpressionHasValue | ATTRIBUTWERT L1 attribute=ATTRIBUTE R1 IS NULL #attributwertComparisonExpressionIsNull | ATTRIBUTWERT L1 attribute=ATTRIBUTE R1 IS NOT NULL #attributwertComparisonExpressionIsNotNull ; /* Bsp. countexpression * Count(EMA72_Identer_Kunde_ID) */ countExpression : COUNT L1 attribute=ATTRIBUTE R1 ; /* * Bsp. topExpression * TOP(5) AI_Einheitennummer_ID WITH (GF00 == "Q" && EMA78 == false && GKA08 != "T2"), WERTART("NN") */ topExpression : TOP L1 value=NATNUM R1 attribute=ATTRIBUTE WITH condition=filterExpression COMMA wertart=wertartExpression; /* Es muss zumindest ein Argument angegeben werden, theoretisch sind unbegrenzt viele Argumente möglich. * Bsp. durchschnittexpression: * DURCHSCHNITT(WERTART("UEJHR")) * DURCHSCHNITT(WERTART("BELQ"),WERTART("NV"))/100 */ durchschnittExpression : DURCHSCHNITT L1 attributwertOderWertart (COMMA attributwertOderWertart)* R1 (arithmeticOperator value=NATNUM)? ; attributwertOderWertart : (ATTRIBUTWERT L1 attribute=ATTRIBUTE R1) #attributWertValue | (WERTART keylist=keyList) #wertartValue ; /* Wird benötigt, da diese Art von Ausdrücken durch arithmetische Operationen mit anderen Ausdrücken verknüpft werden können soll. * Bsp. filteredwerartexpression: * [WERTART("ONA", "ZH") && RP01 IN ("R0100", "R0300")] * (-1) [WERTART("NBW") && RP01 IN ("R0520", "R0530") && GF200 NOT IN ("EWR_GR") && GF184 == "NO"] * [WERTART("ONA", "ZH") && RP01 IN ("R0100", "R0300")] */ filteredWertartExpression : wertartExp=wertartExpression #filteredWertartExpressionDefault | L1 exp=filteredWertartExpression R1 #filteredWertartExpressionRoundBracket | L2 exp=filteredWertartExpression R2 #filteredWertartExpressionSquareBracket | left=filteredWertartExpression op=LOGICALOPERATOR rightFilter=filter #filteredWertartExpressionWithFilterRight | leftFilter=filter op=LOGICALOPERATOR right=filteredWertartExpression #filteredWertartExpressionWithFilterLeft | MINUSONE exp=filteredWertartExpression #filteredWertartExpressionMinusOne ; /* Bsp. likeexpression: * EM06 LIKE "N%" */ likeExpression : attribute=ATTRIBUTE LIKE value=LIKEKEY ; /* Es muss zumindest ein Argument angegeben werden, theoretisch sind unbegrenzt viele Argumente möglich. * Bsp. minmaxexpression: * MIN(WERTART("HBV"), WERTART("IMRELB")) * MAX(WERTART("NDGG") - WERTART("NDAS"), 0) * MAX(GF00 == "Q" && WERTART("NN"), 0) * MAX([RP01 IN ("R0300_GR", "G") && (WERTART("IMRELB") - WERTART("UAPPI"))] || [SK00 IN ("UGPPI") && (-1)WERTART("NN")] || [(-1)WERTART("IMRELDC")], 0) */ minMaxExpression : MIN L1 filteredWertartArithmeticOrNatNum (COMMA filteredWertartArithmeticOrNatNum)* R1 #minExpression | MAX L1 filteredWertartArithmeticOrNatNum (COMMA filteredWertartArithmeticOrNatNum)* R1 #maxExpression ; filteredWertartArithmeticOrNatNum : filteredWertartArithmetic #filteredWertartArithmeticValue | NATNUM #natnumValue ; /* Wird für minMaxExpreccion benötigt * Bsp. filteredWertartArithmetic: * (RP01 IN ("R0510_GR", "R0520_GR", "R0530_GR", "R0300_GR") && (WERTART("MRELB") - WERTART("UAPP"))) || (SK00 IN ("CET1", "AT1", "T2") && WERTART("MREL")/100 * WERTART("BW")) || (SK00 IN ("UGPPS", "UGPPN") && (-1)WERTART("NN")) */ filteredWertartArithmetic : wertartExp=wertartArithmetic #filteredWertartArithmeticDefault | L1 exp=filteredWertartArithmetic R1 #filteredWertartArithmeticRoundBracket | L2 exp=filteredWertartArithmetic R2 #filteredWertartArithmeticSquareBracket | leftFilter=filterExpression op=LOGICALOPERATOR rightFilterArithmetic=filteredWertartArithmetic #filteredWertartArithmeticWithFilterLeft | leftFilterArithmetic=filteredWertartArithmetic op=LOGICALOPERATOR rightFilter=filterExpression #filteredWertartArithmeticWithFilterRight | leftFilterArithmetic=filteredWertartArithmetic op=LOGICALOPERATOR rightFilterArithmetic=filteredWertartArithmetic #filteredWertartArithmeticRecursive ; /* Bsp. quantilexpression: * QUANTIL(WERTART("BELQ"),10)/100 * QUANTIL(ATTRIBUTWERT(GFA189),25) */ quantilExpression : QUANTIL L1 attributwertOderWertart COMMA value=NATNUM R1 (arithmeticOperator secondValue=NATNUM)? ; /* Bsp. columnequation * c060 = c070 - c010 - c020 - c030 - c040 - c050 */ columnEquation : value=COLUMNREFERENCE EQUAL columnArithmetic ; /* Bsp. rowequation * r260 = r270 - (r010 + r020 + r080 + r150 + r160 + r230 + r240 + r250) * r0320 = r0200 / r0110 */ rowEquation : value=ROWREFERENCE EQUAL rowArithmetic ; /* Bsp. columnarithmetic: * c070 - c010 - c020 - c030 - c040 - c050 */ columnArithmetic : value=COLUMNREFERENCE #columnArithmeticValue | L1 exp=columnArithmetic R1 #columnArithmeticRoundBracket | L2 exp=columnArithmetic R2 #columnArithmeticSquareBracket | left=columnArithmetic op=arithmeticOperator right=columnArithmetic #columnArithmeticArithmeticOperator | MINUSONE exp=columnArithmetic #columnArithmeticMinusOne ; /* Bsp. rowarithmetic: * r010 - (r020 + r030 + r040 + r120) */ rowArithmetic : value=ROWREFERENCE #rowArithmeticValue | L1 exp=rowArithmetic R1 #rowArithmeticRoundBracket | L2 exp=rowArithmetic R2 #rowArithmeticSquareBracket | left=rowArithmetic op=arithmeticOperator right=rowArithmetic #rowArithmeticArithmeticOperator | MINUSONE exp=rowArithmetic #rowArithmeticMinusOne ; /* * Bsp. wertartarithmetic: * WERTART("NN") - WERTART("MNN") * WERTART("GAE")/100 * WERTART("WBQ") * (-1)WERTART("WBGES") + WERTART("KAEBZNP") * (-1)WERTART("WB") + WERTART ("BBWp")/100 * WERTART("BBW") */ wertartArithmetic : wertart=wertartExpression #wertartArithmeticDefault | L1 exp=wertartArithmetic R1 #wertartArithmeticRoundBracket | L2 exp=wertartArithmetic R2 #wertartArithmeticSquareBracket | left=wertartArithmetic op=arithmeticOperator right=wertartArithmetic #wertartArithmeticArithmeticOperator | leftValue=NATNUM op=arithmeticOperator right=wertartArithmetic #wertartArithmeticArithmeticOperatorLeftNatNum | left=wertartArithmetic op=arithmeticOperator rightValue=NATNUM #wertartArithmeticArithmeticOperatorRightNatNum | MINUSONE exp=wertartArithmetic #wertartArithmeticMinusOne ; /* Bsp. wertexpression * Wert(GFW.AI_Wertart_Code == "MW") < 0 * Wert(GFW.AI_Wertart_Code == "BWB") (t0) > 0 * Wert(AI_Wertart_Code == "NBW") IS NULL */ wertExpression : WERT L1 attribute=ATTRIBUTE RELEQUAL value=KEY R1 TIMEVAR? relationalOperatorOrNull ; relationalOperatorOrNull : relationalOperator value=NATNUM #relationalOperatorWithNumber | IS NULL #relationalOperatorIsNull | IS NOT NULL #relationalOperatorIsNotNull ; codesubset : CODESUBSETKEY ; /* Bsp. keylist: Schlüssel oder Schlüsselgruppe * ("DV") * ("10J_15J", "15J_20J", "20J_30J", "30J") * Bei Namensgleichheit einer Schlüsselgruppe und eines Schlüssels erhält der Schlüssel priorität. */ keyList : L1 KEY (COMMA KEY)* R1 ; relationalOperator : GT | GE | LT | LE | RELEQUAL | NOTEQUAL ; arithmeticOperator : PLUS | MINUS | MULT | DIV ;