/*******************************************************************************
* Copyright (c) 2006, 2007 Eclipse.org
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*******************************************************************************/
package org.eclipse.gmf.internal.xpand.parser;
import lpg.lpgjavaruntime.*;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.gmf.internal.xpand.util.ParserException.ErrorLocationInfo;
import org.eclipse.gmf.internal.xpand.expression.parser.ExpressionFactory;
import org.eclipse.gmf.internal.xpand.ast.*;
import org.eclipse.gmf.internal.xpand.expression.ast.*;
import java.util.Collections;
public class XpandParser extends PrsStream implements RuleAction {
private static ParseTable prs = new XpandParserprs();
private DeterministicParser dtParser;
public DeterministicParser getParser() { return dtParser; }
private void setResult(Object object) { dtParser.setSym1(object); }
public Object getRhsSym(int i) { return dtParser.getSym(i); }
public int getRhsTokenIndex(int i) { return dtParser.getToken(i); }
public IToken getRhsIToken(int i) { return super.getIToken(getRhsTokenIndex(i)); }
public int getRhsFirstTokenIndex(int i) { return dtParser.getFirstToken(i); }
public IToken getRhsFirstIToken(int i) { return super.getIToken(getRhsFirstTokenIndex(i)); }
public int getRhsLastTokenIndex(int i) { return dtParser.getLastToken(i); }
public IToken getRhsLastIToken(int i) { return super.getIToken(getRhsLastTokenIndex(i)); }
public int getLeftSpan() { return dtParser.getFirstToken(); }
public IToken getLeftIToken() { return super.getIToken(getLeftSpan()); }
public int getRightSpan() { return dtParser.getLastToken(); }
public IToken getRightIToken() { return super.getIToken(getRightSpan()); }
public int getRhsErrorTokenIndex(int i) {
int index = dtParser.getToken(i);
IToken err = super.getIToken(index);
return (err instanceof ErrorToken ? index : 0);
}
public ErrorToken getRhsErrorIToken(int i) {
int index = dtParser.getToken(i);
IToken err = super.getIToken(index);
return (ErrorToken) (err instanceof ErrorToken ? err : null);
}
public XpandParser(LexStream lexStream) {
super(lexStream);
xpandFactory = new XpandFactory(lexStream.getFileName());
factory = new ExpressionFactory(lexStream.getFileName());
try {
super.remapTerminalSymbols(orderedTerminalSymbols(), XpandParserprs.EOFT_SYMBOL);
}
catch(NullExportedSymbolsException e) {
}
catch(NullTerminalSymbolsException e) {
}
catch(UnimplementedTerminalsException e) {
java.util.ArrayList unimplemented_symbols = e.getSymbols();
System.out.println("The Lexer will not scan the following token(s):");
for (int i = 0; i < unimplemented_symbols.size(); i++)
{
Integer id = (Integer) unimplemented_symbols.get(i);
System.out.println(" " + XpandParsersym.orderedTerminalSymbols[id.intValue()]);
}
System.out.println();
}
catch(UndefinedEofSymbolException e) {
throw new Error(new UndefinedEofSymbolException
("The Lexer does not implement the Eof symbol " +
XpandParsersym.orderedTerminalSymbols[XpandParserprs.EOFT_SYMBOL]));
}
}
public String[] orderedTerminalSymbols() { return XpandParsersym.orderedTerminalSymbols; }
public String getTokenKindName(int kind) { return XpandParsersym.orderedTerminalSymbols[kind]; }
public int getEOFTokenKind() { return XpandParserprs.EOFT_SYMBOL; }
public PrsStream getParseStream() { return (PrsStream) this; }
public Template parser() {
return parser(null, 0);
}
public Template parser(Monitor monitor) {
return parser(monitor, 0);
}
public Template parser(int error_repair_count) {
return parser(null, error_repair_count);
}
public Template parser(Monitor monitor, int error_repair_count) {
try {
resetErrors();
dtParser = new DeterministicParser(monitor, (TokenStream)this, prs, (RuleAction)this);
}
catch (NotDeterministicParseTableException e) {
throw new Error(new NotDeterministicParseTableException
("Regenerate XpandParserprs.java with -NOBACKTRACK option"));
}
catch (BadParseSymFileException e) {
throw new Error(new BadParseSymFileException("Bad Parser Symbol File -- XpandParsersym.java. Regenerate XpandParserprs.java"));
}
try {
return (Template) dtParser.parse();
}
catch (BadParseException e) {
reset(e.error_token); // point to error token
DiagnoseParser diagnoseParser = new DiagnoseParser(this, prs);
diagnoseParser.diagnose(e.error_token);
}
return null;
}
public ErrorLocationInfo[] getErrors() {
return errors.toArray(new ErrorLocationInfo[errors.size()]);
}
private void resetErrors() {
errors.clear();
}
private final List<ErrorLocationInfo> errors = new LinkedList<ErrorLocationInfo>();
@Override
public void reportError(int errorCode, String locationInfo, int leftToken, int rightToken, String tokenText) {
final int leftTokenLine = getLine(leftToken);
final int leftTokenColumn = getColumn(leftToken);
final int rightTokenLine = getEndLine(rightToken);
final int rightTokenColumn = getEndColumn(rightToken);
final String msg = tokenText + errorMsgText[errorCode];
errors.add(new ErrorLocationInfo(msg, leftTokenLine, leftTokenColumn, rightTokenLine, rightTokenColumn));
}
/*
@Override
public void reportError(int leftToken, int rightToken) {
int errorCode = (rightToken >= getStreamLength() ? EOF_CODE : leftToken == rightToken ? LEX_ERROR_CODE : INVALID_TOKEN_CODE);
int endToken = (leftToken == rightToken ? rightToken : rightToken - 1);
String msg = (errorCode == EOF_CODE ? "End-of-file " : errorCode == INVALID_TOKEN_CODE
? "\"" + new String(getInputChars(), leftToken, rightToken - leftToken) + "\" "
: "\"" + getCharValue(leftToken) + "\" ");
final int leftTokenLine = getLine(leftToken);
final int leftTokenColumn = getColumn(leftToken);
final int rightTokenLine = getEndLine(endToken);
final int rightTokenColumn = getEndColumn(endToken);
errors.add(new ErrorLocationInfo(msg, leftTokenLine, leftTokenColumn, rightTokenLine, rightTokenColumn));
}
*/
@Override
public void reportError(int errorCode, String locationInfo, String tokenText) {
try {
Matcher m = Pattern.compile("(?:[^:]+::)*[^:]+:(\\d+):(\\d+):(\\d+):(\\d+):.*").matcher(locationInfo);
boolean t = m.matches(); // ignore return value, rely on exception if anything wrong
assert t;
final int leftTokenLine = getLine(Integer.parseInt(m.group(1)));
final int leftTokenColumn = getColumn(Integer.parseInt(m.group(2)));
final int rightTokenLine = getEndLine(Integer.parseInt(m.group(3)));
final int rightTokenColumn = getEndColumn(Integer.parseInt(m.group(4)));
final String msg = tokenText + errorMsgText[errorCode];
errors.add(new ErrorLocationInfo(msg, leftTokenLine, leftTokenColumn, rightTokenLine, rightTokenColumn));
} catch (Throwable ex) {
// ignore
errors.add(new ErrorLocationInfo(tokenText + errorMsgText[errorCode]));
}
}
private final XpandFactory xpandFactory;
private final ExpressionFactory factory;
public void ruleAction(int ruleNumber) {
switch (ruleNumber) {
//
// Rule 2: letExpression ::= let IDENT ASSIGN castedExpression COLON castedExpression
//
case 2: {
setResult(factory.createLetExpression(getLeftIToken(),getRhsIToken(2),(Expression) getRhsSym(4), (Expression) getRhsSym(6)));
break;
}
//
// Rule 4: castedExpression ::= LPAREN type RPAREN infixExpression
//
case 4: {
setResult(factory.createCast(getLeftIToken(), (Identifier) getRhsSym(2),(Expression) getRhsSym(4)));
break;
}
//
// Rule 7: chainExpression ::= ifExpression ARROW chainExpression
//
case 7: {
Expression e = (Expression) getRhsSym(1);
Expression right = (Expression) getRhsSym(3);
if (right instanceof ChainExpression) {
ChainExpression rchain = (ChainExpression) right;
Expression newFirst = factory.createChainExpression(e, rchain.getFirst());
setResult(factory.createChainExpression(newFirst, rchain.getNext()));
} else {
setResult(factory.createChainExpression(e, right));
}
break;
}
//
// Rule 9: ifExpression ::= switchExpression QUESTION_MARK switchExpression COLON switchExpression
//
case 9: {
setResult(factory.createIf((Expression) getRhsSym(1),(Expression) getRhsSym(3), (Expression) getRhsSym(5)));
break;
}
//
// Rule 10: switchExpression ::= switch LPAREN expression RPAREN LCURLY switchCases default COLON orExpression RCURLY
//
case 10: {
setResult(factory.createSwitchExpression(getLeftIToken(),getRightIToken(), (Expression) getRhsSym(3), (List) getRhsSym(6), (Expression) getRhsSym(9)));
break;
}
//
// Rule 12: switchCases ::= $Empty
//
case 12: {
setResult(Collections.emptyList());
break;
}
//
// Rule 13: switchCases ::= case orExpression COLON orExpression switchCases
//
case 13: {
LinkedList r = new LinkedList();
r.add(factory.createCase(getLeftIToken(), (Expression) getRhsSym(2), (Expression) getRhsSym(4)));
r.addAll((List) getRhsSym(5));
setResult(r);
break;
}
//
// Rule 15: orExpression ::= andExpression OR orExpression
//
case 15: {
Expression e = (Expression) getRhsSym(1);
Expression r = (Expression) getRhsSym(3);
setResult(factory.createBooleanOperation(e.getStart(),r.getEnd(),e.getLine(),e.getStartOffset(),r.getEndOffset(),getRhsIToken(2),e,r));
break;
}
//
// Rule 17: andExpression ::= impliesExpression AND andExpression
//
case 17: {
Expression e = (Expression) getRhsSym(1);
Expression r = (Expression) getRhsSym(3);
setResult(factory.createBooleanOperation(e.getStart(),r.getEnd(),e.getLine(),e.getStartOffset(),r.getEndOffset(),getRhsIToken(2),e,r));
break;
}
//
// Rule 19: impliesExpression ::= relationalExpression implies relationalExpression
//
case 19: {
Expression e = (Expression) getRhsSym(1);
Expression r = (Expression) getRhsSym(3);
setResult(factory.createBooleanOperation(e.getStart(),r.getEnd(),e.getLine(),e.getStartOffset(),e.getEndOffset(),getRhsIToken(2),e,r));
break;
}
//
// Rule 21: relationalExpression ::= additiveExpression relationalOperator additiveExpression
//
case 21: {
Expression e = (Expression) getRhsSym(1);
IToken t = (IToken) getRhsSym(2);
Expression r = (Expression) getRhsSym(3);
setResult(factory.createOperationCall(e.getStart(),r.getEnd(),e.getLine(),e.getStartOffset(),r.getEndOffset(),t,e,Collections.singletonList(r)));
break;
}
//
// Rule 22: relationalOperator ::= EQ
//
case 22: {
setResult(getLeftIToken());
break;
}
//
// Rule 23: relationalOperator ::= NE
//
case 23: {
setResult(getLeftIToken());
break;
}
//
// Rule 24: relationalOperator ::= GE
//
case 24: {
setResult(getLeftIToken());
break;
}
//
// Rule 25: relationalOperator ::= LE
//
case 25: {
setResult(getLeftIToken());
break;
}
//
// Rule 26: relationalOperator ::= GT
//
case 26: {
setResult(getLeftIToken());
break;
}
//
// Rule 27: relationalOperator ::= LT
//
case 27: {
setResult(getLeftIToken());
break;
}
//
// Rule 29: additiveExpression ::= additiveExpression additiveOperator multiplicativeExpression
//
case 29: {
Expression e = (Expression) getRhsSym(1);
IToken t = (IToken) getRhsSym(2);
Expression r = (Expression) getRhsSym(3);
setResult(factory.createOperationCall(e.getStart(),r.getEnd(),e.getLine(),e.getStartOffset(),r.getEndOffset(),t,e,Collections.singletonList(r)));
break;
}
//
// Rule 30: additiveOperator ::= PLUS
//
case 30: {
setResult(getLeftIToken());
break;
}
//
// Rule 31: additiveOperator ::= MINUS
//
case 31: {
setResult(getLeftIToken());
break;
}
//
// Rule 33: multiplicativeExpression ::= unaryExpression multiplicativeOperator multiplicativeExpression
//
case 33: {
Expression e = (Expression) getRhsSym(1);
IToken t = (IToken) getRhsSym(2);
Expression r = (Expression) getRhsSym(3);
setResult(factory.createOperationCall(e.getStart(),r.getEnd(),e.getLine(),e.getStartOffset(),r.getEndOffset(),t,e,Collections.singletonList(r)));
break;
}
//
// Rule 34: multiplicativeOperator ::= MULTI
//
case 34: {
setResult(getLeftIToken());
break;
}
//
// Rule 35: multiplicativeOperator ::= DIV
//
case 35: {
setResult(getLeftIToken());
break;
}
//
// Rule 37: unaryExpression ::= NOT infixExpression
//
case 37: {
Expression e = (Expression) getRhsSym(2);
setResult(factory.createOperationCall(getLeftIToken().getColumn(),e.getEnd(),getLeftIToken().getLine(),getLeftIToken().getStartOffset(),e.getEndOffset(),getLeftIToken(),e,Collections.EMPTY_LIST));
break;
}
//
// Rule 38: unaryExpression ::= MINUS infixExpression
//
case 38: {
Expression e = (Expression) getRhsSym(2);
setResult(factory.createOperationCall(getLeftIToken().getColumn(),e.getEnd(),getLeftIToken().getLine(),getLeftIToken().getStartOffset(),e.getEndOffset(),getLeftIToken(),e,Collections.EMPTY_LIST));
break;
}
//
// Rule 39: infixExpressionSuffix ::= DOT featureCall
//
case 39: {
setResult(getRhsSym(2));
break;
}
//
// Rule 40: infixExpressionSuffix ::= DOT featureCall infixExpressionSuffix
//
case 40: {
final FeatureCall op = (FeatureCall) getRhsSym(3);
FeatureCall fc = op;
while (fc.getTarget() != null) {
fc = (FeatureCall) fc.getTarget();
}
fc.setTarget((FeatureCall) getRhsSym(2));
setResult(op);
break;
}
//
// Rule 42: infixExpression ::= primaryExpression infixExpressionSuffix
//
case 42: {
final FeatureCall op = (FeatureCall) getRhsSym(2);
FeatureCall fc = op;
while (fc.getTarget() != null) {
fc = (FeatureCall) fc.getTarget();
}
fc.setTarget((Expression) getRhsSym(1));
setResult(op);
break;
}
//
// Rule 43: primaryExpression ::= STRING
//
case 43: {
setResult(factory.createStringLiteral(getLeftIToken()));
break;
}
//
// Rule 51: primaryExpression ::= LPAREN expression RPAREN
//
case 51: {
Expression expr = (Expression) getRhsSym(2);
expr.setStartOffset(getLeftIToken().getStartOffset());
expr.setEndOffset(getRightIToken().getEndOffset());
setResult(expr);
break;
}
//
// Rule 52: featureCall ::= IDENT LPAREN parameterList RPAREN
//
case 52: {
setResult(factory.createOperationCall(getRightIToken(),getLeftIToken(),null, (List<Expression>) getRhsSym(3)));
break;
}
//
// Rule 53: featureCall ::= IDENT LPAREN RPAREN
//
case 53: {
setResult(factory.createOperationCall(getRightIToken(), getLeftIToken(), null, Collections.EMPTY_LIST));
break;
}
//
// Rule 54: featureCall ::= type
//
case 54: {
setResult(factory.createFeatureCall((Identifier) getRhsSym(1),null));
break;
}
//
// Rule 56: listLiteral ::= LCURLY parameterList RCURLY
//
case 56: {
setResult(factory.createListLiteral(getLeftIToken(),getRightIToken(), (List<Expression>) getRhsSym(2)));
break;
}
//
// Rule 57: listLiteral ::= LCURLY RCURLY
//
case 57: {
setResult(factory.createListLiteral(getLeftIToken(), getRightIToken(), Collections.EMPTY_LIST));
break;
}
//
// Rule 58: constructorCall ::= new simpleType
//
case 58: {
setResult(factory.createConstructorCall(getLeftIToken(), (Identifier) getRhsSym(2)));
break;
}
//
// Rule 59: booleanLiteral ::= false
//
case 59: {
setResult(factory.createBooleanLiteral(getRhsIToken(1)));
break;
}
//
// Rule 60: booleanLiteral ::= true
//
case 60: {
setResult(factory.createBooleanLiteral(getRhsIToken(1)));
break;
}
//
// Rule 61: nullLiteral ::= null
//
case 61: {
setResult(factory.createNullLiteral(getRhsIToken(1)));
break;
}
//
// Rule 62: intLiteral ::= INT_CONST
//
case 62: {
setResult(factory.createIntegerLiteral(getRhsIToken(1)));
break;
}
//
// Rule 63: realLiteral ::= REAL_CONST
//
case 63: {
setResult(factory.createRealLiteral(getRhsIToken(1)));
break;
}
//
// Rule 64: collectionExpression ::= typeSelect LPAREN type RPAREN
//
case 64: {
setResult(factory.createTypeSelectExpression(getRhsIToken(1), getRightIToken(), (Identifier) getRhsSym(3),null));
break;
}
//
// Rule 65: collectionExpression ::= collectionExpressionName LPAREN IDENT BAR expression RPAREN
//
case 65: {
setResult(factory.createCollectionExpression((IToken) getRhsSym(1), getRightIToken(), getRhsIToken(3), (Expression) getRhsSym(5),null));
break;
}
//
// Rule 66: collectionExpression ::= collectionExpressionName LPAREN expression RPAREN
//
case 66: {
setResult(factory.createCollectionExpression((IToken) getRhsSym(1), getRightIToken(), null, (Expression) getRhsSym(3),null));
break;
}
//
// Rule 67: collectionExpressionName ::= collect
//
case 67: {
setResult(getLeftIToken());
break;
}
//
// Rule 68: collectionExpressionName ::= select
//
case 68: {
setResult(getLeftIToken());
break;
}
//
// Rule 69: collectionExpressionName ::= reject
//
case 69: {
setResult(getLeftIToken());
break;
}
//
// Rule 70: collectionExpressionName ::= exists
//
case 70: {
setResult(getLeftIToken());
break;
}
//
// Rule 71: collectionExpressionName ::= notExists
//
case 71: {
setResult(getLeftIToken());
break;
}
//
// Rule 72: collectionExpressionName ::= forAll
//
case 72: {
setResult(getLeftIToken());
break;
}
//
// Rule 73: declaredParameterListOpt ::= $Empty
//
case 73: {
setResult(Collections.EMPTY_LIST);
break;
}
//
// Rule 75: declaredParameterList ::= type IDENT
//
case 75: {
Identifier id = factory.createIdentifier(getRightIToken());
DeclaredParameter p = factory.createDeclaredParameter((Identifier) getRhsSym(1), id);
setResult(Collections.singletonList(p));
break;
}
//
// Rule 76: declaredParameterList ::= type IDENT COMMA declaredParameterList
//
case 76: {
LinkedList r = new LinkedList();
Identifier id = factory.createIdentifier(getRhsIToken(2));
DeclaredParameter p = factory.createDeclaredParameter((Identifier) getRhsSym(1), id);
r.add(p);
r.addAll((List) getRhsSym(4));
setResult(r);
break;
}
//
// Rule 77: parameterList ::= expression
//
case 77: {
setResult(Collections.singletonList((Expression) getRhsSym(1)));
break;
}
//
// Rule 78: parameterList ::= expression COMMA parameterList
//
case 78: {
LinkedList r = new LinkedList();
r.add(getRhsSym(1));
r.addAll((List) getRhsSym(3));
setResult(r);
break;
}
//
// Rule 81: collectionType ::= collectionTypeName LSQUARE simpleType RSQUARE
//
case 81: {
Identifier id = (Identifier) getRhsSym(1);
id = id.append(factory.createIdentifier(getRhsIToken(2)));
id = id.append((Identifier) getRhsSym(3));
id = id.append(factory.createIdentifier(getRhsIToken(4)));
setResult(id);
break;
}
//
// Rule 82: collectionTypeName ::= Collection
//
case 82: {
setResult(factory.createIdentifier(getRhsIToken(1)));
break;
}
//
// Rule 83: collectionTypeName ::= List
//
case 83: {
setResult(factory.createIdentifier(getRhsIToken(1)));
break;
}
//
// Rule 84: collectionTypeName ::= Set
//
case 84: {
setResult(factory.createIdentifier(getRhsIToken(1)));
break;
}
//
// Rule 85: simpleType ::= IDENT NOT qualifiedType
//
case 85: {
Identifier id = factory.createIdentifier(getLeftIToken());
id = id.append(factory.createIdentifier(getRhsIToken(2)));
id = id.append((Identifier) getRhsSym(3));
setResult(id);
break;
}
//
// Rule 87: qualifiedType ::= IDENT
//
case 87: {
setResult(factory.createIdentifier(getLeftIToken()));
break;
}
//
// Rule 88: qualifiedType ::= IDENT DCOLON qualifiedType
//
case 88: {
Identifier id = factory.createIdentifier(getLeftIToken());
id = id.append(factory.createIdentifier(getRhsIToken(2)));
id = id.append((Identifier) getRhsSym(3));
setResult(id);
break;
}
//
// Rule 89: template ::= emptyTemplate
//
case 89: {
setResult(xpandFactory.createTemplate(Collections.EMPTY_LIST, Collections.EMPTY_LIST, Collections.EMPTY_LIST, Collections.EMPTY_LIST, getRightIToken()));
break;
}
//
// Rule 92: template ::= LG commentTextPairAny imports extensionImports defineOrAroundSeq
//
case 92: {
List imports = (List) getRhsSym(3);
List extensionImports = (List) getRhsSym(4);
List defineOrAround = (List) getRhsSym(5);
List<Advice> advices = new LinkedList<Advice>();
List<Definition> defines = new LinkedList<Definition>();
for (Object o : defineOrAround) {
if (o instanceof Definition) {
defines.add((Definition) o);
} else if (o instanceof Advice) {
advices.add((Advice) o);
} else {
throw new IllegalStateException();// assert false?
}
}
setResult(xpandFactory.createTemplate(imports, extensionImports, defines, advices, getRightIToken()));
break;
}
//
// Rule 93: defineOrAroundSeq ::= define TEXT commentTextPairAny defineOrAroundSuffix
//
case 93: {
List result = new LinkedList();
result.add(getRhsSym(1));
result.addAll((List) getRhsSym(4));
setResult(result);
break;
}
//
// Rule 94: defineOrAroundSeq ::= around TEXT commentTextPairAny defineOrAroundSuffix
//
case 94: {
List result = new LinkedList();
result.add(getRhsSym(1));
result.addAll((List) getRhsSym(4));
setResult(result);
break;
}
//
// Rule 95: defineOrAroundSuffix ::= $Empty
//
case 95: {
setResult(Collections.EMPTY_LIST);
break;
}
//
// Rule 101: imports ::= $Empty
//
case 101: {
setResult(Collections.EMPTY_LIST);
break;
}
//
// Rule 102: imports ::= anImport imports
//
case 102: {
List res = new LinkedList();
res.add(getRhsSym(1));
res.addAll((List) getRhsSym(2));
setResult(res);
break;
}
//
// Rule 103: anImport ::= IMPORT STRING TEXT commentTextPairAny
//
case 103: {
setResult(xpandFactory.createNamespaceImport(getLeftIToken(),xpandFactory.createStringLiteral(getRhsIToken(2))));
break;
}
//
// Rule 104: extensionImports ::= $Empty
//
case 104: {
setResult(Collections.EMPTY_LIST);
break;
}
//
// Rule 105: extensionImports ::= anExtensionImport extensionImports
//
case 105: {
List res = new LinkedList();
res.add(getRhsSym(1));
res.addAll((List) getRhsSym(2));
setResult(res);
break;
}
//
// Rule 106: anExtensionImport ::= EXTENSION simpleType TEXT commentTextPairAny
//
case 106: {
setResult(xpandFactory.createImportDeclaration(getLeftIToken(), (Identifier) getRhsSym(2)));
break;
}
//
// Rule 107: around ::= AROUND pointcut FOR type sequence ENDAROUND
//
case 107: {
setResult(xpandFactory.createAround(getLeftIToken(), getRightIToken(), (Identifier) getRhsSym(2), Collections.EMPTY_LIST, false, (Identifier) getRhsSym(4), (List) getRhsSym(5)));
break;
}
//
// Rule 108: around ::= AROUND pointcut LPAREN declaredParameterList RPAREN FOR type sequence ENDAROUND
//
case 108: {
setResult(xpandFactory.createAround(getLeftIToken(), getRightIToken(), (Identifier) getRhsSym(2), (List) getRhsSym(4), false, (Identifier) getRhsSym(7), (List) getRhsSym(8)));
break;
}
//
// Rule 109: around ::= AROUND pointcut LPAREN declaredParameterList COMMA MULTI RPAREN FOR type sequence ENDAROUND
//
case 109: {
setResult(xpandFactory.createAround(getLeftIToken(), getRightIToken(), (Identifier) getRhsSym(2), (List) getRhsSym(4), true, (Identifier) getRhsSym(9), (List) getRhsSym(10)));
break;
}
//
// Rule 110: around ::= AROUND pointcut LPAREN MULTI RPAREN FOR type sequence ENDAROUND
//
case 110: {
setResult(xpandFactory.createAround(getLeftIToken(), getRightIToken(), (Identifier) getRhsSym(2), Collections.EMPTY_LIST, true, (Identifier) getRhsSym(7), (List) getRhsSym(8)));
break;
}
//
// Rule 111: pointcut ::= MULTI pointcutSuffix
//
case 111: {
Identifier res = xpandFactory.createIdentifier(getLeftIToken());
if (getRhsSym(2) != null) {
res = res.append((Identifier) getRhsSym(2));
}
setResult(res);
break;
}
//
// Rule 112: pointcut ::= IDENT pointcutSuffix
//
case 112: {
Identifier res = xpandFactory.createIdentifier(getLeftIToken());
if (getRhsSym(2) != null) {
res = res.append((Identifier) getRhsSym(2));
}
setResult(res);
break;
}
//
// Rule 113: pointcutSuffix ::= $Empty
//
case 113: {
setResult(null);
break;
}
//
// Rule 115: pointcutSuffix ::= DCOLON pointcutSuffix
//
case 115: {
Identifier res = xpandFactory.createIdentifier(getLeftIToken());
if (getRhsSym(2) != null) {
res = res.append((Identifier) getRhsSym(2));
}
setResult(res);
break;
}
//
// Rule 116: define ::= DEFINE IDENT FOR type sequence ENDDEFINE
//
case 116: {
setResult(xpandFactory.createDefinition(getLeftIToken(), getRightIToken(), getRhsIToken(2), Collections.EMPTY_LIST, (Identifier) getRhsSym(4), (List) getRhsSym(5)));
break;
}
//
// Rule 117: define ::= DEFINE IDENT LPAREN declaredParameterList RPAREN FOR type sequence ENDDEFINE
//
case 117: {
setResult(xpandFactory.createDefinition(getLeftIToken(), getRightIToken(), getRhsIToken(2), (List) getRhsSym(4), (Identifier) getRhsSym(7), (List) getRhsSym(8)));
break;
}
//
// Rule 118: sequence ::= text sequenceSuffix
//
case 118: {
List res = new LinkedList();
res.addAll((List) getRhsSym(1));
res.addAll((List) getRhsSym(2));
setResult(res);
break;
}
//
// Rule 119: sequenceSuffix ::= $Empty
//
case 119: {
setResult(Collections.EMPTY_LIST);
break;
}
//
// Rule 120: sequenceSuffix ::= statement text sequenceSuffix
//
case 120: {
List res = new LinkedList();
res.add(getRhsSym(1));
res.addAll((List) getRhsSym(2));
res.addAll((List) getRhsSym(3));
setResult(res);
break;
}
//
// Rule 127: text ::= minusOpt TEXT textSuffix
//
case 127: {
List res = new LinkedList();
res.add(xpandFactory.createTextStatement(getRhsIToken(2), (IToken) getRhsSym(1)));
res.addAll((List) getRhsSym(3));
setResult(res);
break;
}
//
// Rule 128: textSuffix ::= $Empty
//
case 128: {
setResult(Collections.EMPTY_LIST);
break;
}
//
// Rule 129: textSuffix ::= minusOpt TEXT textSuffix
//
case 129: {
List res = new LinkedList();
res.add(xpandFactory.createTextStatement(getRhsIToken(2), (IToken) getRhsSym(1)));
res.addAll((List) getRhsSym(3));
setResult(res);
break;
}
//
// Rule 130: minusOpt ::= $Empty
//
case 130: {
setResult(null);
break;
}
//
// Rule 131: minusOpt ::= MINUS
//
case 131: {
setResult(getLeftIToken());
break;
}
//
// Rule 135: errorStatement ::= ERROR expression
//
case 135: {
setResult(xpandFactory.createErrorStatement(getLeftIToken(), (Expression) getRhsSym(2)));
break;
}
//
// Rule 136: expandStatement ::= EXPAND definitionName parameterListOpt
//
case 136: {
setResult(xpandFactory.createExpandStatement(getLeftIToken(), (Identifier) getRhsSym(2), (List) getRhsSym(3), null, false, null));
break;
}
//
// Rule 137: expandStatement ::= EXPAND definitionName parameterListOpt FOR expression
//
case 137: {
setResult(xpandFactory.createExpandStatement(getLeftIToken(), (Identifier) getRhsSym(2), (List) getRhsSym(3), (Expression) getRhsSym(5), false, null));
break;
}
//
// Rule 138: expandStatement ::= EXPAND definitionName parameterListOpt FOREACH expression separatorOpt
//
case 138: {
setResult(xpandFactory.createExpandStatement(getLeftIToken(), (Identifier) getRhsSym(2), (List) getRhsSym(3), (Expression) getRhsSym(5), true, (Expression) getRhsSym(6)));
break;
}
//
// Rule 139: parameterListOpt ::= $Empty
//
case 139: {
setResult(Collections.EMPTY_LIST);
break;
}
//
// Rule 140: parameterListOpt ::= LPAREN parameterList RPAREN
//
case 140: {
setResult(getRhsSym(2));
break;
}
//
// Rule 142: expressionStmt ::= expression
//
case 142: {
setResult(xpandFactory.createExpressionStatement((Expression) getRhsSym(1)));
break;
}
//
// Rule 143: fileStatement ::= FILE expression identOpt sequence ENDFILE
//
case 143: {
setResult(xpandFactory.createFileStatement(getLeftIToken(), getRightIToken(), (Expression) getRhsSym(2), (Identifier) getRhsSym(3), (List) getRhsSym(4)));
break;
}
//
// Rule 144: identOpt ::= $Empty
//
case 144: {
setResult(null);
break;
}
//
// Rule 145: identOpt ::= IDENT
//
case 145: {
setResult(xpandFactory.createIdentifier(getLeftIToken()));
break;
}
//
// Rule 146: foreachStatement ::= FOREACH expression AS IDENT iteratorOpt separatorOpt sequence ENDFOREACH
//
case 146: {
setResult(xpandFactory.createForEachStatement(getLeftIToken(), getRightIToken(), (Expression) getRhsSym(2), getRhsIToken(4), (Expression) getRhsSym(6), (IToken) getRhsSym(5), (List) getRhsSym(7)));
break;
}
//
// Rule 147: iteratorOpt ::= $Empty
//
case 147: {
setResult(null);
break;
}
//
// Rule 148: iteratorOpt ::= ITERATOR IDENT
//
case 148: {
setResult(getRightIToken());
break;
}
//
// Rule 149: separatorOpt ::= $Empty
//
case 149: {
setResult(null);
break;
}
//
// Rule 150: separatorOpt ::= SEPARATOR expression
//
case 150: {
setResult(getRhsSym(2));
break;
}
//
// Rule 151: ifStatement ::= IF expression sequence elseifAny elseOpt ENDIF
//
case 151: {
IfStatement i = xpandFactory.createIfStatement(getLeftIToken(), (Expression) getRhsSym(2), (List) getRhsSym(3), null);
IfStatement elseIf = (IfStatement) getRhsSym(4);
IfStatement elseStmt = (IfStatement) getRhsSym(5);
if (elseIf != null) {
i.setElseIf(elseIf);
IfStatement curElseIf = elseIf;
// get the latest one in the chain
while (curElseIf.getElseIf() != null) {
curElseIf = curElseIf.getElseIf();
}
curElseIf.setElseIf(elseStmt);
} else {
i.setElseIf(elseStmt);
}
setResult(i);
break;
}
//
// Rule 152: elseifAny ::= $Empty
//
case 152: {
setResult(null);
break;
}
//
// Rule 153: elseifAny ::= ELSEIF expression sequence elseifAny
//
case 153: {
IfStatement elseIf = xpandFactory.createIfStatement(getLeftIToken(), (Expression) getRhsSym(2), (List) getRhsSym(3), null);
IfStatement restElseIf = (IfStatement) getRhsSym(4);
elseIf.setElseIf(restElseIf);
setResult(elseIf);
break;
}
//
// Rule 154: elseOpt ::= $Empty
//
case 154: {
setResult(null);
break;
}
//
// Rule 155: elseOpt ::= ELSE sequence
//
case 155: {
setResult(xpandFactory.createIfStatement(getLeftIToken(), null, (List) getRhsSym(2), null));
break;
}
//
// Rule 156: letStatement ::= LET expression AS IDENT sequence ENDLET
//
case 156: {
setResult(xpandFactory.createLetStatement(getLeftIToken(), getRightIToken(), (Expression) getRhsSym(2), getRhsIToken(4), (List) getRhsSym(5)));
break;
}
//
// Rule 157: protectStatement ::= PROTECT CSTART expression CEND expression ID expression disabledOpt sequence ENDPROTECT
//
case 157: {
setResult(xpandFactory.createProtectStatement(getLeftIToken(), getRightIToken(), (Expression) getRhsSym(3), (Expression) getRhsSym(5), (Expression) getRhsSym(7), (IToken) getRhsSym(8), (List) getRhsSym(9)));
break;
}
//
// Rule 158: disabledOpt ::= $Empty
//
case 158: {
setResult(null);
break;
}
//
// Rule 159: disabledOpt ::= DISABLE
//
case 159: {
setResult(getLeftIToken());
break;
}
default:
break;
}
return;
}
}
