| /******************************************************************************* |
| * 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.xtend.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.xtend.ast.*; |
| |
| import org.eclipse.gmf.internal.xpand.expression.ast.*; |
| |
| import java.util.Collections; |
| |
| public class XtendParser extends PrsStream implements RuleAction { |
| private static ParseTable prs = new XtendParserprs(); |
| 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 XtendParser(LexStream lexStream) { |
| super(lexStream); |
| xtendFactory = new ExtensionFactory(lexStream.getFileName()); |
| factory = new ExpressionFactory(lexStream.getFileName()); |
| |
| try { |
| super.remapTerminalSymbols(orderedTerminalSymbols(), XtendParserprs.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(" " + XtendParsersym.orderedTerminalSymbols[id.intValue()]); |
| } |
| System.out.println(); |
| } |
| catch(UndefinedEofSymbolException e) { |
| throw new Error(new UndefinedEofSymbolException |
| ("The Lexer does not implement the Eof symbol " + |
| XtendParsersym.orderedTerminalSymbols[XtendParserprs.EOFT_SYMBOL])); |
| } |
| } |
| |
| public String[] orderedTerminalSymbols() { return XtendParsersym.orderedTerminalSymbols; } |
| public String getTokenKindName(int kind) { return XtendParsersym.orderedTerminalSymbols[kind]; } |
| public int getEOFTokenKind() { return XtendParserprs.EOFT_SYMBOL; } |
| public PrsStream getParseStream() { return (PrsStream) this; } |
| |
| public ExtensionFile parser() { |
| return parser(null, 0); |
| } |
| |
| public ExtensionFile parser(Monitor monitor) { |
| return parser(monitor, 0); |
| } |
| |
| public ExtensionFile parser(int error_repair_count) { |
| return parser(null, error_repair_count); |
| } |
| |
| public ExtensionFile 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 XtendParserprs.java with -NOBACKTRACK option")); |
| } |
| catch (BadParseSymFileException e) { |
| throw new Error(new BadParseSymFileException("Bad Parser Symbol File -- XtendParsersym.java. Regenerate XtendParserprs.java")); |
| } |
| |
| try { |
| return (ExtensionFile) 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 ExtensionFactory xtendFactory; |
| |
| 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: extensionFile ::= nsImportsList extImportsList extensions |
| // |
| case 89: { |
| |
| setResult(xtendFactory.createExtensionFile((List) getRhsSym(1) , (List) getRhsSym(2), (List) getRhsSym(3))); |
| break; |
| } |
| // |
| // Rule 90: nsImportsList ::= $Empty |
| // |
| case 90: { |
| |
| setResult(Collections.EMPTY_LIST); |
| break; |
| } |
| // |
| // Rule 91: nsImportsList ::= nsImport nsImportsList |
| // |
| case 91: { |
| |
| List res = new LinkedList(); |
| res.add(getRhsSym(1)); |
| res.addAll((List) getRhsSym(2)); |
| setResult(res); |
| break; |
| } |
| // |
| // Rule 92: nsImport ::= import STRING SEMI |
| // |
| case 92: { |
| |
| StringLiteral st = xtendFactory.createStringLiteral(getRhsIToken(2)); |
| setResult(xtendFactory.createNsImport(getLeftIToken(), getRightIToken(), st)); |
| break; |
| } |
| // |
| // Rule 93: extImportsList ::= $Empty |
| // |
| case 93: { |
| |
| setResult(Collections.EMPTY_LIST); |
| break; |
| } |
| // |
| // Rule 94: extImportsList ::= extImport extImportsList |
| // |
| case 94: { |
| |
| List res = new LinkedList(); |
| res.add(getRhsSym(1)); |
| res.addAll((List) getRhsSym(2)); |
| setResult(res); |
| break; |
| } |
| // |
| // Rule 95: extImport ::= extension type SEMI |
| // |
| case 95: { |
| |
| setResult(xtendFactory.createExtensionFileImport(getLeftIToken(), getRightIToken(), (Identifier) getRhsSym(2), null)); |
| break; |
| } |
| // |
| // Rule 96: extImport ::= extension type reexport SEMI |
| // |
| case 96: { |
| |
| setResult(xtendFactory.createExtensionFileImport(getLeftIToken(), getRightIToken(), (Identifier) getRhsSym(2), getRhsIToken(3))); |
| break; |
| } |
| // |
| // Rule 97: extensions ::= $Empty |
| // |
| case 97: { |
| |
| setResult(Collections.EMPTY_LIST); |
| break; |
| } |
| // |
| // Rule 98: extensions ::= extensionDef extensions |
| // |
| case 98: { |
| |
| List res = new LinkedList(); |
| res.add(getRhsSym(1)); |
| res.addAll((List) getRhsSym(2)); |
| setResult(res); |
| break; |
| } |
| // |
| // Rule 101: regularExtension ::= visibilityOpt cachedOpt typeOpt IDENT LPAREN declaredParameterListOpt RPAREN COLON JAVA instanceSlotOpt javaType LPAREN javaParamsOpt RPAREN SEMI |
| // |
| case 101: { |
| |
| setResult(xtendFactory.createJavaExtension(getRhsIToken(4), getRightIToken(), (Identifier) getRhsSym(3), (List) getRhsSym(6), (Identifier) getRhsSym(11), (List) getRhsSym(13), (IToken) getRhsSym(2), (IToken) getRhsSym(1), (Identifier) getRhsSym(10))); |
| break; |
| } |
| // |
| // Rule 102: regularExtension ::= visibilityOpt cachedOpt typeOpt IDENT LPAREN declaredParameterListOpt RPAREN COLON GLOBALVAR slot SEMI |
| // |
| case 102: { |
| |
| setResult(xtendFactory.createWorkflowSlotExtension(getRhsIToken(4), getRightIToken(), (Identifier) getRhsSym(3), (List) getRhsSym(6), (Identifier) getRhsSym(10), (IToken) getRhsSym(2), (IToken) getRhsSym(1))); |
| break; |
| } |
| // |
| // Rule 103: regularExtension ::= visibilityOpt cachedOpt typeOpt IDENT LPAREN declaredParameterListOpt RPAREN COLON expression SEMI |
| // |
| case 103: { |
| |
| setResult(xtendFactory.createExpressionExtension(getRhsIToken(4), getRightIToken(), (Identifier) getRhsSym(3), (List) getRhsSym(6), (Expression) getRhsSym(9), (IToken) getRhsSym(2), (IToken) getRhsSym(1))); |
| break; |
| } |
| // |
| // Rule 104: createExtension ::= visibilityOpt create type identOpt IDENT LPAREN declaredParameterListOpt RPAREN COLON expression SEMI |
| // |
| case 104: { |
| |
| setResult(xtendFactory.createCreateExtension(getRhsIToken(2), getRightIToken(), (Identifier) getRhsSym(3), (IToken) getRhsSym(4), getRhsIToken(5), (List) getRhsSym(7), (Expression) getRhsSym(10), (IToken) getRhsSym(1))); |
| break; |
| } |
| // |
| // Rule 105: visibilityOpt ::= $Empty |
| // |
| case 105: { |
| |
| setResult(null); |
| break; |
| } |
| // |
| // Rule 106: visibilityOpt ::= private |
| // |
| case 106: { |
| |
| setResult(getLeftIToken()); |
| break; |
| } |
| // |
| // Rule 107: cachedOpt ::= $Empty |
| // |
| case 107: { |
| |
| setResult(null); |
| break; |
| } |
| // |
| // Rule 108: cachedOpt ::= cached |
| // |
| case 108: { |
| |
| setResult(getLeftIToken()); |
| break; |
| } |
| // |
| // Rule 109: typeOpt ::= $Empty |
| // |
| case 109: { |
| |
| setResult(null); |
| break; |
| } |
| // |
| // Rule 111: identOpt ::= $Empty |
| // |
| case 111: { |
| |
| setResult(null); |
| break; |
| } |
| // |
| // Rule 112: identOpt ::= IDENT |
| // |
| case 112: { |
| |
| setResult(getLeftIToken()); |
| break; |
| } |
| // |
| // Rule 113: instanceSlotOpt ::= $Empty |
| // |
| case 113: { |
| |
| setResult(null); |
| break; |
| } |
| // |
| // Rule 114: instanceSlotOpt ::= [ slot ] |
| // |
| case 114: { |
| |
| setResult(getRhsSym(2)); |
| break; |
| } |
| // |
| // Rule 115: javaType ::= IDENT javaTypeSuffix |
| // |
| case 115: { |
| |
| Identifier res = xtendFactory.createIdentifier(getRhsIToken(1)); |
| for (Object o : (List) getRhsSym(2)) { |
| res = res.append(factory.createIdentifier((IToken) o)); |
| } |
| setResult(res); |
| break; |
| } |
| // |
| // Rule 116: javaTypeSuffix ::= $Empty |
| // |
| case 116: { |
| |
| setResult(Collections.EMPTY_LIST); |
| break; |
| } |
| // |
| // Rule 117: javaTypeSuffix ::= DOT IDENT javaTypeSuffix |
| // |
| case 117: { |
| |
| List res = new LinkedList(); |
| res.add(getRhsIToken(1)); |
| res.add(getRhsIToken(2)); |
| res.addAll((List) getRhsSym(3)); |
| setResult(res); |
| break; |
| } |
| // |
| // Rule 118: javaTypeSuffix ::= DOT Collection javaTypeSuffix |
| // |
| case 118: { |
| |
| List res = new LinkedList(); |
| res.add(getRhsIToken(1)); |
| res.add(getRhsIToken(2)); |
| res.addAll((List) getRhsSym(3)); |
| setResult(res); |
| break; |
| } |
| // |
| // Rule 119: javaTypeSuffix ::= DOT List javaTypeSuffix |
| // |
| case 119: { |
| |
| List res = new LinkedList(); |
| res.add(getRhsIToken(1)); |
| res.add(getRhsIToken(2)); |
| res.addAll((List) getRhsSym(3)); |
| setResult(res); |
| break; |
| } |
| // |
| // Rule 120: javaTypeSuffix ::= DOT Set javaTypeSuffix |
| // |
| case 120: { |
| |
| List res = new LinkedList(); |
| res.add(getRhsIToken(1)); |
| res.add(getRhsIToken(2)); |
| res.addAll((List) getRhsSym(3)); |
| setResult(res); |
| break; |
| } |
| // |
| // Rule 121: javaParamsOpt ::= $Empty |
| // |
| case 121: { |
| |
| setResult(Collections.EMPTY_LIST); |
| break; |
| } |
| // |
| // Rule 123: javaParams ::= javaType |
| // |
| case 123: { |
| |
| setResult(Collections.singletonList(getRhsSym(1))); |
| break; |
| } |
| // |
| // Rule 124: javaParams ::= javaType COMMA javaParams |
| // |
| case 124: { |
| |
| List res = new LinkedList(); |
| res.add(getRhsSym(1)); |
| res.addAll((List) getRhsSym(3)); |
| setResult(res); |
| break; |
| } |
| // |
| // Rule 125: slot ::= IDENT |
| // |
| case 125: { |
| |
| setResult(xtendFactory.createIdentifier(getLeftIToken())); |
| break; |
| } |
| |
| default: |
| break; |
| } |
| return; |
| } |
| } |
| |
