diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/AbstractGNUSourceCodeParser.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/AbstractGNUSourceCodeParser.java index 98faa0859b8..5ea9a5c7bf1 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/AbstractGNUSourceCodeParser.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/AbstractGNUSourceCodeParser.java @@ -21,8 +21,10 @@ import org.eclipse.cdt.core.dom.ast.IASTCastExpression; import org.eclipse.cdt.core.dom.ast.IASTCompoundStatement; import org.eclipse.cdt.core.dom.ast.IASTConditionalExpression; import org.eclipse.cdt.core.dom.ast.IASTContinueStatement; +import org.eclipse.cdt.core.dom.ast.IASTDeclSpecifier; import org.eclipse.cdt.core.dom.ast.IASTDeclaration; import org.eclipse.cdt.core.dom.ast.IASTDeclarationStatement; +import org.eclipse.cdt.core.dom.ast.IASTDeclarator; import org.eclipse.cdt.core.dom.ast.IASTDefaultStatement; import org.eclipse.cdt.core.dom.ast.IASTDoStatement; import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier; @@ -100,8 +102,6 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { } protected IToken currToken; - protected IToken lastToken; - protected IToken prevLastToken; /** * Look Ahead in the token list to see what is coming. @@ -144,12 +144,11 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { return LA(i).getType(); } - protected int calculateEndOffset( IASTNode n ) - { + protected int calculateEndOffset(IASTNode n) { ASTNode node = (ASTNode) n; return node.getOffset() + node.getLength(); } - + /** * Consume the next token available, regardless of the type. * @@ -161,10 +160,9 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { if (currToken == null) currToken = fetchToken(); - if (currToken != null) { - prevLastToken = lastToken; + IToken lastToken = null; + if (currToken != null) lastToken = currToken; - } currToken = currToken.getNext(); return lastToken; } @@ -242,7 +240,6 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { */ protected void backup(IToken mark) { currToken = mark; - lastToken = prevLastToken; } /** @@ -367,15 +364,6 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { private static final int DEFAULT_COMPOUNDSTATEMENT_LIST_SIZE = 8; - /** - * - */ - protected void cleanupLastToken() { - if (lastToken != null) - lastToken.setNext(null); - simpleDeclarationMark = null; - } - public IASTTranslationUnit parse() { long startTime = System.currentTimeMillis(); translationUnit(); @@ -396,14 +384,16 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { */ protected abstract void nullifyTranslationUnit(); - protected void skipOverCompoundStatement() throws BacktrackException, + protected IToken skipOverCompoundStatement() throws BacktrackException, EndOfFileException { // speed up the parser by skiping the body // simply look for matching brace and return consume(IToken.tLBRACE); + IToken result = null; int depth = 1; while (depth > 0) { - switch (consume().getType()) { + result = consume(); + switch (result.getType()) { case IToken.tRBRACE: --depth; break; @@ -412,6 +402,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { break; } } + return result; } /** @@ -582,7 +573,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { secondExpression.setParent(expressionList); secondExpression .setPropertyInParent(IASTExpressionList.NESTED_EXPRESSION); - lastOffset = lastToken.getEndOffset(); + lastOffset = calculateEndOffset(secondExpression); } ((ASTNode) expressionList).setLength(lastOffset - startingOffset); return expressionList; @@ -622,7 +613,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { IASTExpression lhs) throws EndOfFileException, BacktrackException { consume(); IASTExpression rhs = assignmentExpression(); - return buildBinaryExpression(kind, lhs, rhs, lastToken.getEndOffset()); + return buildBinaryExpression(kind, lhs, rhs, calculateEndOffset(rhs)); } /** @@ -646,7 +637,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { IASTExpression secondExpression = logicalAndExpression(); firstExpression = buildBinaryExpression( IASTBinaryExpression.op_logicalOr, firstExpression, - secondExpression, lastToken.getEndOffset()); + secondExpression, calculateEndOffset(secondExpression)); } return firstExpression; } @@ -663,7 +654,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { IASTExpression secondExpression = inclusiveOrExpression(); firstExpression = buildBinaryExpression( IASTBinaryExpression.op_logicalAnd, firstExpression, - secondExpression, lastToken.getEndOffset()); + secondExpression, calculateEndOffset(secondExpression)); } return firstExpression; } @@ -680,7 +671,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { IASTExpression secondExpression = exclusiveOrExpression(); firstExpression = buildBinaryExpression( IASTBinaryExpression.op_binaryOr, firstExpression, - secondExpression, lastToken.getEndOffset()); + secondExpression, calculateEndOffset(secondExpression)); } return firstExpression; } @@ -697,7 +688,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { IASTExpression secondExpression = andExpression(); firstExpression = buildBinaryExpression( IASTBinaryExpression.op_binaryXor, firstExpression, - secondExpression, lastToken.getEndOffset()); + secondExpression, calculateEndOffset(secondExpression)); } return firstExpression; } @@ -715,7 +706,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { IASTExpression secondExpression = equalityExpression(); firstExpression = buildBinaryExpression( IASTBinaryExpression.op_binaryAnd, firstExpression, - secondExpression, lastToken.getEndOffset()); + secondExpression, calculateEndOffset(secondExpression)); } return firstExpression; } @@ -736,8 +727,8 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { : IASTBinaryExpression.op_notequals); IASTExpression secondExpression = relationalExpression(); firstExpression = buildBinaryExpression(operator, - firstExpression, secondExpression, lastToken - .getEndOffset()); + firstExpression, secondExpression, + calculateEndOffset(secondExpression)); break; default: return firstExpression; @@ -782,8 +773,8 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { : IASTBinaryExpression.op_shiftRight; IASTExpression secondExpression = additiveExpression(); firstExpression = buildBinaryExpression(operator, - firstExpression, secondExpression, lastToken - .getEndOffset()); + firstExpression, secondExpression, + calculateEndOffset(secondExpression)); break; default: return firstExpression; @@ -807,8 +798,8 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { : IASTBinaryExpression.op_minus; IASTExpression secondExpression = multiplicativeExpression(); firstExpression = buildBinaryExpression(operator, - firstExpression, secondExpression, lastToken - .getEndOffset()); + firstExpression, secondExpression, + calculateEndOffset(secondExpression)); break; default: return firstExpression; @@ -856,8 +847,8 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { throws EndOfFileException, BacktrackException { int offset = consume().getOffset(); IASTExpression castExpression = castExpression(); - return buildUnaryExpression(operator, castExpression, offset, lastToken - .getEndOffset()); + return buildUnaryExpression(operator, castExpression, offset, + calculateEndOffset(castExpression)); } /** @@ -909,10 +900,11 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { backup(m); d = null; unaryExpression = unaryExpression(); - lastOffset = lastToken.getEndOffset(); + lastOffset = calculateEndOffset(unaryExpression); } } else { unaryExpression = unaryExpression(); + lastOffset = calculateEndOffset(unaryExpression); } if (d != null & unaryExpression == null) return buildTypeIdExpression(IGNUASTTypeIdExpression.op_alignof, d, @@ -934,7 +926,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { if (LT(1) == IToken.tLPAREN) { if (LT(2) == IToken.tLBRACE) { unaryExpression = compoundStatementExpression(); - lastOffset = lastToken.getEndOffset(); + lastOffset = calculateEndOffset(unaryExpression); } else try { consume(IToken.tLPAREN); @@ -944,10 +936,11 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { backup(m); d = null; unaryExpression = unaryExpression(); - lastOffset = lastToken.getEndOffset(); + lastOffset = calculateEndOffset(unaryExpression); } } else { unaryExpression = unaryExpression(); + lastOffset = calculateEndOffset(unaryExpression); } if (d != null & unaryExpression == null) return buildTypeIdExpression(IGNUASTTypeIdExpression.op_typeof, d, @@ -961,14 +954,24 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { protected IASTStatement handleFunctionBody() throws BacktrackException, EndOfFileException { if (mode == ParserMode.QUICK_PARSE || mode == ParserMode.STRUCTURAL_PARSE) { - skipOverCompoundStatement(); - return null; + IToken curr = LA(1); + IToken last = skipOverCompoundStatement(); + IASTCompoundStatement cs = createCompoundStatement(); + ((ASTNode) cs).setOffsetAndLength(curr.getOffset(), last + .getEndOffset() + - curr.getOffset()); + return cs; } else if (mode == ParserMode.COMPLETION_PARSE || mode == ParserMode.SELECTION_PARSE) { if (scanner.isOnTopContext()) return functionBody(); - skipOverCompoundStatement(); - return null; + IToken curr = LA(1); + IToken last = skipOverCompoundStatement(); + IASTCompoundStatement cs = createCompoundStatement(); + ((ASTNode) cs).setOffsetAndLength(curr.getOffset(), last + .getEndOffset() + - curr.getOffset()); + return cs; } else if (mode == ParserMode.COMPLETE_PARSE) return functionBody(); return null; @@ -1102,12 +1105,15 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { result.setName(name); name.setParent(result); name.setPropertyInParent(IASTEnumerationSpecifier.ENUMERATION_NAME); - cleanupLastToken(); + consume(IToken.tLBRACE); while (LT(1) != IToken.tRBRACE) { IASTName enumeratorName = null; + + int lastOffset = 0; if (LT(1) == IToken.tIDENTIFIER) { enumeratorName = createName(identifier()); + lastOffset = calculateEndOffset(enumeratorName); } else { IToken la = LA(1); throwBacktrack(la.getOffset(), la.getLength()); @@ -1116,14 +1122,14 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { if (LT(1) == IToken.tASSIGN) { consume(IToken.tASSIGN); initialValue = constantExpression(); + lastOffset = calculateEndOffset(initialValue); } IASTEnumerationSpecifier.IASTEnumerator enumerator = null; if (LT(1) == IToken.tRBRACE) { enumerator = createEnumerator(); enumerator.setName(enumeratorName); ((ASTNode) enumerator).setOffsetAndLength( - ((ASTNode) enumeratorName).getOffset(), lastToken - .getEndOffset() + ((ASTNode) enumeratorName).getOffset(), lastOffset - ((ASTNode) enumeratorName).getOffset()); enumeratorName.setParent(enumerator); enumeratorName @@ -1138,7 +1144,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { enumerator.setParent(result); enumerator .setPropertyInParent(IASTEnumerationSpecifier.ENUMERATOR); - cleanupLastToken(); + break; } if (LT(1) != IToken.tCOMMA) { @@ -1148,8 +1154,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { enumerator = createEnumerator(); enumerator.setName(enumeratorName); ((ASTNode) enumerator).setOffsetAndLength( - ((ASTNode) enumeratorName).getOffset(), lastToken - .getEndOffset() + ((ASTNode) enumeratorName).getOffset(), lastOffset - ((ASTNode) enumeratorName).getOffset()); enumeratorName.setParent(enumerator); enumeratorName @@ -1163,7 +1168,6 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { result.addEnumerator(enumerator); enumerator.setParent(result); enumerator.setPropertyInParent(IASTEnumerationSpecifier.ENUMERATOR); - cleanupLastToken(); consume(IToken.tCOMMA); } @@ -1207,7 +1211,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { protected IASTExpression condition() throws BacktrackException, EndOfFileException { IASTExpression cond = expression(); - cleanupLastToken(); + return cond; } @@ -1313,7 +1317,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { String assembly = consume(IToken.tSTRING).getImage(); consume(IToken.tRPAREN); int lastOffset = consume(IToken.tSEMI).getEndOffset(); - cleanupLastToken(); + return buildASMDirective(first.getOffset(), assembly, lastOffset); } @@ -1411,7 +1415,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { } if (expressionStatement == null && ds != null) { - cleanupLastToken(); + return ds; } if (expressionStatement != null && ds == null) { @@ -1419,7 +1423,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { if (consume() == lastTokenOfExpression) break; } - cleanupLastToken(); + return expressionStatement; } @@ -1435,12 +1439,12 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { IASTExpression lhs = exp.getOperand1(); if (lhs instanceof IASTBinaryExpression && ((IASTBinaryExpression) lhs).getOperator() == IASTBinaryExpression.op_multiply) { - cleanupLastToken(); + return ds; } if (lhs instanceof IASTBinaryExpression && ((IASTBinaryExpression) lhs).getOperator() == IASTBinaryExpression.op_binaryAnd) { - cleanupLastToken(); + return ds; } } @@ -1458,7 +1462,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { if (consume() == lastTokenOfExpression) break; } - cleanupLastToken(); + return expressionStatement; } backup(mark); @@ -1466,7 +1470,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { if (consume() == lastTokenOfExpression) break; } - cleanupLastToken(); + return expressionStatement; } @@ -1497,7 +1501,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { protected IASTStatement parseNullStatement() throws EndOfFileException, BacktrackException { IToken t = consume(IToken.tSEMI); - cleanupLastToken(); + IASTNullStatement null_statement = createNullStatement(); ((ASTNode) null_statement).setOffsetAndLength(t.getOffset(), t .getEndOffset() @@ -1515,7 +1519,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { int startOffset = consume(IToken.t_goto).getOffset(); IToken identifier = consume(IToken.tIDENTIFIER); int lastOffset = consume(IToken.tSEMI).getEndOffset(); - cleanupLastToken(); + IASTName goto_label_name = createName(identifier); IASTGotoStatement goto_statement = createGoToStatement(); ((ASTNode) goto_statement).setOffsetAndLength(startOffset, lastOffset @@ -1535,7 +1539,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { BacktrackException { int startOffset = consume(IToken.t_break).getOffset(); int lastOffset = consume(IToken.tSEMI).getEndOffset(); - cleanupLastToken(); + IASTBreakStatement break_statement = createBreakStatement(); ((ASTNode) break_statement).setOffsetAndLength(startOffset, lastOffset - startOffset); @@ -1551,7 +1555,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { BacktrackException { int startOffset = consume(IToken.t_continue).getOffset(); int lastOffset = consume(IToken.tSEMI).getEndOffset(); - cleanupLastToken(); + IASTContinueStatement continue_statement = createContinueStatement(); ((ASTNode) continue_statement).setOffsetAndLength(startOffset, lastOffset - startOffset); @@ -1570,10 +1574,10 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { IASTExpression result = null; if (LT(1) != IToken.tSEMI) { result = expression(); - cleanupLastToken(); + } int lastOffset = consume(IToken.tSEMI).getEndOffset(); - cleanupLastToken(); + IASTReturnStatement return_statement = createReturnStatement(); ((ASTNode) return_statement).setOffsetAndLength(startOffset, lastOffset - startOffset); @@ -1603,15 +1607,14 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { IASTExpression iterationExpression = null; if (LT(1) != IToken.tRPAREN) { iterationExpression = expression(); - cleanupLastToken(); + } consume(IToken.tRPAREN); IASTStatement for_body = statement(); IASTForStatement for_statement = createForStatement(); - ((ASTNode) for_statement).setOffsetAndLength(startOffset, lastToken - .getEndOffset() - - startOffset); - cleanupLastToken(); + ((ASTNode) for_statement).setOffsetAndLength(startOffset, + calculateEndOffset(for_body) - startOffset); + if (init instanceof IASTDeclaration) { for_statement.setInit((IASTDeclaration) init); ((IASTDeclaration) init).setParent(for_statement); @@ -1653,7 +1656,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { consume(IToken.tLPAREN); IASTExpression do_condition = condition(); int lastOffset = consume(IToken.tRPAREN).getEndOffset(); - cleanupLastToken(); + IASTDoStatement do_statement = createDoStatement(); ((ASTNode) do_statement).setOffsetAndLength(startOffset, lastOffset - startOffset); @@ -1679,11 +1682,10 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { IASTExpression while_condition = condition(); consume(IToken.tRPAREN); IASTStatement while_body = statement(); - cleanupLastToken(); + IASTWhileStatement while_statement = createWhileStatement(); - ((ASTNode) while_statement).setOffsetAndLength(startOffset, lastToken - .getEndOffset() - - startOffset); + ((ASTNode) while_statement).setOffsetAndLength(startOffset, + calculateEndOffset(while_body) - startOffset); while_statement.setCondition(while_condition); while_condition.setParent(while_statement); while_condition.setPropertyInParent(IASTWhileStatement.CONDITION); @@ -1707,11 +1709,10 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { IASTExpression switch_condition = condition(); consume(IToken.tRPAREN); IASTStatement switch_body = statement(); - cleanupLastToken(); + IASTSwitchStatement switch_statement = createSwitchStatement(); - ((ASTNode) switch_statement).setOffsetAndLength(startOffset, lastToken - .getEndOffset() - - startOffset); + ((ASTNode) switch_statement).setOffsetAndLength(startOffset, + calculateEndOffset(switch_body) - startOffset); switch_statement.setController(switch_condition); switch_condition.setParent(switch_statement); switch_condition.setPropertyInParent(IASTSwitchStatement.CONTROLLER); @@ -1770,7 +1771,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { consume(IToken.t_else); if (LT(1) == IToken.t_if) { //an else if, don't recurse, just loop and do another if - cleanupLastToken(); + if (if_statement != null) { if_statement.setElseClause(new_if_statement); new_if_statement.setParent(if_statement); @@ -1787,14 +1788,21 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { if_statement.setElseClause(new_if_statement); new_if_statement.setParent(if_statement); new_if_statement.setPropertyInParent(IASTIfStatement.ELSE); - } else + ((ASTNode) new_if_statement) + .setLength(calculateEndOffset(new_if_statement) - start); + } else { + ((ASTNode) new_if_statement) + .setLength(calculateEndOffset(new_if_statement) - start); if_statement = new_if_statement; - } else + } + } else { + ((ASTNode) new_if_statement) + .setLength(calculateEndOffset(new_if_statement) - start); if_statement = new_if_statement; + } break if_loop; } - cleanupLastToken(); - ((ASTNode) if_statement).setLength(lastToken.getEndOffset() - start); + return if_statement; } @@ -1811,7 +1819,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { protected IASTStatement parseCompoundStatement() throws EndOfFileException, BacktrackException { IASTCompoundStatement compound = compoundStatement(); - cleanupLastToken(); + return compound; } @@ -1824,7 +1832,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { BacktrackException { int startOffset = consume(IToken.t_default).getOffset(); int lastOffset = consume(IToken.tCOLON).getEndOffset(); - cleanupLastToken(); + IASTDefaultStatement df = createDefaultStatement(); ((ASTNode) df).setOffsetAndLength(startOffset, lastOffset - startOffset); return df; @@ -1840,7 +1848,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { int startOffset = consume(IToken.t_case).getOffset(); IASTExpression case_exp = constantExpression(); int lastOffset = consume(IToken.tCOLON).getEndOffset(); - cleanupLastToken(); + IASTCaseStatement cs = createCaseStatement(); ((ASTNode) cs).setOffsetAndLength(startOffset, lastOffset - startOffset); cs.setExpression(case_exp); @@ -1849,4 +1857,28 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { return cs; } + /** + * @param declSpec + * @param declarators + * @return + */ + protected int figureEndOffset(IASTDeclSpecifier declSpec, List declarators) { + if (declarators.isEmpty()) + return calculateEndOffset(declSpec); + return calculateEndOffset((IASTDeclarator) declarators.get(declarators + .size() - 1)); + } + + /** + * @param declSpecifier + * @param declarator + * @return + */ + protected int figureEndOffset(IASTDeclSpecifier declSpecifier, + IASTDeclarator declarator) { + if (declarator == null) + return calculateEndOffset(declSpecifier); + return calculateEndOffset(declarator); + } + } \ No newline at end of file diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/c/GNUCSourceParser.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/c/GNUCSourceParser.java index 08829acba87..e0959fd225a 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/c/GNUCSourceParser.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/c/GNUCSourceParser.java @@ -221,10 +221,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { .setPropertyInParent(IASTInitializerExpression.INITIALIZER_EXPRESSION); return result; } catch (BacktrackException b) { - // do nothing + throwBacktrack(b); } - int endOffset = (lastToken != null) ? lastToken.getEndOffset() : 0; - throwBacktrack(startingOffset, endOffset - startingOffset); return null; } @@ -401,7 +399,6 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { return asmDeclaration(); default: IASTDeclaration d = simpleDeclaration(); - cleanupLastToken(); return d; } @@ -481,15 +478,15 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { s.setParent(funcDefinition); s.setPropertyInParent(IASTFunctionDefinition.FUNCTION_BODY); } - ((ASTNode) funcDefinition).setLength(lastToken.getEndOffset() + ((ASTNode) funcDefinition).setLength(calculateEndOffset(s) - firstOffset); return funcDefinition; } IASTSimpleDeclaration simpleDeclaration = createSimpleDeclaration(); - ((ASTNode) simpleDeclaration).setOffsetAndLength(firstOffset, lastToken - .getEndOffset() - - firstOffset); + + ((ASTNode) simpleDeclaration).setOffsetAndLength(firstOffset, + figureEndOffset(declSpec, declarators) - firstOffset); simpleDeclaration.setDeclSpecifier(declSpec); declSpec.setParent(simpleDeclaration); declSpec.setPropertyInParent(IASTSimpleDeclaration.DECL_SPECIFIER); @@ -558,13 +555,13 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { failParseWithErrorHandling(); } catch (EndOfFileException e) { // As expected - if( translationUnit.getDeclarations().length != 0 ) - { - CASTNode d = (CASTNode) translationUnit.getDeclarations()[ translationUnit.getDeclarations().length - 1 ]; - ((CASTNode) translationUnit).setLength( d.getOffset() + d.getLength() ); - } - else - ((CASTNode)translationUnit).setLength( 0 ); + if (translationUnit.getDeclarations().length != 0) { + CASTNode d = (CASTNode) translationUnit.getDeclarations()[translationUnit + .getDeclarations().length - 1]; + ((CASTNode) translationUnit).setLength(d.getOffset() + + d.getLength()); + } else + ((CASTNode) translationUnit).setLength(0); break; } catch (BacktrackException b) { try { @@ -708,7 +705,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { break; } firstExpression = buildBinaryExpression(operator, - firstExpression, secondExpression, lastToken.getEndOffset()); + firstExpression, secondExpression, + calculateEndOffset(secondExpression)); break; default: return firstExpression; @@ -743,7 +741,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { break; } firstExpression = buildBinaryExpression(operator, - firstExpression, secondExpression, lastToken.getEndOffset()); + firstExpression, secondExpression, + calculateEndOffset(secondExpression)); break; default: return firstExpression; @@ -775,7 +774,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } return buildTypeIdUnaryExpression(IASTCastExpression.op_cast, - typeId, castExpression, startingOffset, calculateEndOffset(castExpression)); + typeId, castExpression, startingOffset, + calculateEndOffset(castExpression)); } catch (BacktrackException b) { } } @@ -821,15 +821,16 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { backup(mark); typeId = null; unaryExpression = unaryExpression(); + lastOffset = calculateEndOffset(unaryExpression); } } else { unaryExpression = unaryExpression(); - lastOffset = lastToken.getEndOffset(); + lastOffset = calculateEndOffset(unaryExpression); } mark = null; if (typeId == null && unaryExpression != null) return buildUnaryExpression(IASTUnaryExpression.op_sizeof, - unaryExpression, startingOffset, lastToken.getEndOffset()); + unaryExpression, startingOffset, lastOffset); return buildTypeIdExpression(IASTTypeIdExpression.op_sizeof, typeId, startingOffset, lastOffset); @@ -858,7 +859,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { int startingOffset, int endingOffset) { IASTTypeIdExpression result = createTypeIdExpression(); result.setOperator(op); - ((ASTNode) result).setOffsetAndLength(startingOffset, endingOffset - startingOffset); + ((ASTNode) result).setOffsetAndLength(startingOffset, endingOffset + - startingOffset); ((ASTNode) result).setLength(endingOffset - startingOffset); result.setTypeId(typeId); typeId.setParent(result); @@ -891,7 +893,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { IASTTypeId t = typeId(false); int lastOffset = consume(IToken.tRPAREN).getEndOffset(); IASTInitializer i = cInitializerClause(Collections.EMPTY_LIST); - firstExpression = buildTypeIdInitializerExpression(t, i, offset, lastOffset); + firstExpression = buildTypeIdInitializerExpression(t, i, offset, + lastOffset); break; } catch (BacktrackException bt) { backup(m); @@ -911,8 +914,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { int last = consume(IToken.tRBRACKET).getEndOffset(); IASTArraySubscriptExpression s = createArraySubscriptExpression(); ((ASTNode) s).setOffsetAndLength(((ASTNode) firstExpression) - .getOffset(), last - ((ASTNode) firstExpression) - .getOffset()); + .getOffset(), last + - ((ASTNode) firstExpression).getOffset()); s.setArrayExpression(firstExpression); firstExpression.setParent(s); firstExpression @@ -931,8 +934,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { last = consume(IToken.tRPAREN).getEndOffset(); IASTFunctionCallExpression f = createFunctionCallExpression(); ((ASTNode) f).setOffsetAndLength(((ASTNode) firstExpression) - .getOffset(), last - ((ASTNode) firstExpression) - .getOffset()); + .getOffset(), last + - ((ASTNode) firstExpression).getOffset()); f.setFunctionNameExpression(firstExpression); firstExpression.setParent(f); firstExpression @@ -950,13 +953,13 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { int offset = consume(IToken.tINCR).getEndOffset(); firstExpression = buildUnaryExpression( IASTUnaryExpression.op_postFixIncr, firstExpression, - ((CASTNode)firstExpression).getOffset(), offset); + ((CASTNode) firstExpression).getOffset(), offset); break; case IToken.tDECR: offset = consume().getEndOffset(); firstExpression = buildUnaryExpression( IASTUnaryExpression.op_postFixDecr, firstExpression, - ((CASTNode)firstExpression).getOffset(), offset); + ((CASTNode) firstExpression).getOffset(), offset); break; case IToken.tDOT: // member access @@ -964,7 +967,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { IASTName name = createName(identifier()); IASTFieldReference result = createFieldReference(); ((ASTNode) result).setOffsetAndLength( - ((ASTNode) firstExpression).getOffset(), lastToken.getEndOffset() - ((ASTNode) firstExpression).getOffset()); + ((ASTNode) firstExpression).getOffset(), + calculateEndOffset(name) + - ((ASTNode) firstExpression).getOffset()); result.setFieldOwner(firstExpression); result.setIsPointerDereference(false); firstExpression.setParent(result); @@ -981,7 +986,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { name = createName(identifier()); result = createFieldReference(); ((ASTNode) result).setOffsetAndLength( - ((ASTNode) firstExpression).getOffset(), lastToken.getEndOffset() - ((ASTNode) firstExpression).getOffset()); + ((ASTNode) firstExpression).getOffset(), + calculateEndOffset(name) + - ((ASTNode) firstExpression).getOffset()); result.setFieldOwner(firstExpression); result.setIsPointerDereference(true); firstExpression.setParent(result); @@ -1016,7 +1023,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { * @param t * @param i * @param offset - * @param lastOffset TODO + * @param lastOffset + * TODO * @return */ protected ICASTTypeIdInitializerExpression buildTypeIdInitializerExpression( @@ -1062,14 +1070,18 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { literalExpression .setKind(IASTLiteralExpression.lk_integer_constant); literalExpression.setValue(t.getImage()); - ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset()); + ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t + .getEndOffset() + - t.getOffset()); return literalExpression; case IToken.tFLOATINGPT: t = consume(); literalExpression = createLiteralExpression(); literalExpression.setKind(IASTLiteralExpression.lk_float_constant); literalExpression.setValue(t.getImage()); - ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset()); + ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t + .getEndOffset() + - t.getOffset()); return literalExpression; case IToken.tSTRING: case IToken.tLSTRING: @@ -1077,7 +1089,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { literalExpression = createLiteralExpression(); literalExpression.setKind(IASTLiteralExpression.lk_string_literal); literalExpression.setValue(t.getImage()); - ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset()); + ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t + .getEndOffset() + - t.getOffset()); return literalExpression; case IToken.tCHAR: case IToken.tLCHAR: @@ -1085,7 +1099,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { literalExpression = createLiteralExpression(); literalExpression.setKind(IASTLiteralExpression.lk_char_constant); literalExpression.setValue(t.getImage()); - ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset()); + ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t + .getEndOffset() + - t.getOffset()); return literalExpression; case IToken.tLPAREN: t = consume(); @@ -1137,20 +1153,20 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { declSpecifier = declSpecifierSeq(false); declarator = declarator(); } catch (BacktrackException bt) { - int endingOffset = lastToken == null ? 0 : lastToken.getEndOffset(); backup(mark); - throwBacktrack(startingOffset, endingOffset - startingOffset); + throwBacktrack(bt); } if (declarator == null || declarator.getName().toString() != null) //$NON-NLS-1$ { - int endingOffset = lastToken == null ? 0 : lastToken.getEndOffset(); backup(mark); - throwBacktrack(startingOffset, endingOffset - startingOffset); + throwBacktrack(startingOffset, figureEndOffset(declSpecifier, + declarator) + - startingOffset); } IASTTypeId result = createTypeId(); - int length = (lastToken != null ) ? lastToken.getEndOffset() - startingOffset : 0; - ((ASTNode) result).setOffsetAndLength(startingOffset, length); + ((ASTNode) result).setOffsetAndLength(startingOffset, figureEndOffset( + declSpecifier, declarator)); result.setDeclSpecifier(declSpecifier); declSpecifier.setParent(result); @@ -1185,6 +1201,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { throws EndOfFileException, BacktrackException { for (;;) { IToken mark = mark(); + IToken last = null; boolean isConst = false, isVolatile = false, isRestrict = false; @@ -1193,21 +1210,21 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { break; } - consume(IToken.tSTAR); + last = consume(IToken.tSTAR); int startOffset = mark.getOffset(); for (;;) { IToken t = LA(1); switch (LT(1)) { case IToken.t_const: - consume(IToken.t_const); + last = consume(IToken.t_const); isConst = true; break; case IToken.t_volatile: - consume(IToken.t_volatile); + last = consume(IToken.t_volatile); isVolatile = true; break; case IToken.t_restrict: - consume(IToken.t_restrict); + last = consume(IToken.t_restrict); isRestrict = true; break; } @@ -1217,7 +1234,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } IASTPointerOperator po = createPointer(); - ((ASTNode) po).setOffsetAndLength(startOffset, lastToken.getEndOffset() - startOffset); + ((ASTNode) po).setOffsetAndLength(startOffset, last.getEndOffset() + - startOffset); ((ICASTPointer) po).setConst(isConst); ((ICASTPointer) po).setVolatile(isVolatile); ((ICASTPointer) po).setRestrict(isRestrict); @@ -1246,77 +1264,79 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { IASTCompositeTypeSpecifier structSpec = null; IASTElaboratedTypeSpecifier elabSpec = null; IASTEnumerationSpecifier enumSpec = null; + IASTExpression typeofExpression = null; boolean isTypedef = false; + IToken last = null; declSpecifiers: for (;;) { switch (LT(1)) { //Storage Class Specifiers case IToken.t_auto: - consume(); + last = consume(); storageClass = IASTDeclSpecifier.sc_auto; break; case IToken.t_register: storageClass = IASTDeclSpecifier.sc_register; - consume(); + last = consume(); break; case IToken.t_static: storageClass = IASTDeclSpecifier.sc_static; - consume(); + last = consume(); break; case IToken.t_extern: storageClass = IASTDeclSpecifier.sc_extern; - consume(); + last = consume(); break; case IToken.t_typedef: isTypedef = true; storageClass = IASTDeclSpecifier.sc_typedef; - consume(); + last = consume(); break; //Function Specifier case IToken.t_inline: isInline = true; - consume(); + last = consume(); break; //Type Qualifiers case IToken.t_const: isConst = true; - consume(); + last = consume(); break; case IToken.t_volatile: isVolatile = true; - consume(); + last = consume(); break; case IToken.t_restrict: isRestrict = true; - consume(); + last = consume(); break; //Type Specifiers case IToken.t_void: flags.setEncounteredRawType(true); - consume(); + last = consume(); simpleType = IASTSimpleDeclSpecifier.t_void; break; case IToken.t_char: flags.setEncounteredRawType(true); - consume(); + last = consume(); simpleType = IASTSimpleDeclSpecifier.t_char; break; case IToken.t_short: flags.setEncounteredRawType(true); - consume(); + last = consume(); isShort = true; break; case IToken.t_int: flags.setEncounteredRawType(true); - consume(); + last = consume(); simpleType = IASTSimpleDeclSpecifier.t_int; break; case IToken.t_long: flags.setEncounteredRawType(true); - consume(); + last = consume(); if (isLong) { isLongLong = true; isLong = false; @@ -1325,35 +1345,35 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { break; case IToken.t_float: flags.setEncounteredRawType(true); - consume(); + last = consume(); simpleType = IASTSimpleDeclSpecifier.t_float; break; case IToken.t_double: flags.setEncounteredRawType(true); - consume(); + last = consume(); simpleType = IASTSimpleDeclSpecifier.t_double; break; case IToken.t_signed: flags.setEncounteredRawType(true); - consume(); + last = consume(); isSigned = true; break; case IToken.t_unsigned: flags.setEncounteredRawType(true); - consume(); + last = consume(); isUnsigned = true; break; case IToken.t__Bool: flags.setEncounteredRawType(true); - consume(); + last = consume(); simpleType = ICASTSimpleDeclSpecifier.t_Bool; break; case IToken.t__Complex: - consume(IToken.t__Complex); + last = consume(IToken.t__Complex); simpleType = ICASTSimpleDeclSpecifier.t_Complex; break; case IToken.t__Imaginary: - consume(IToken.t__Imaginary); + last = consume(IToken.t__Imaginary); simpleType = ICASTSimpleDeclSpecifier.t_Imaginary; break; @@ -1379,6 +1399,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } identifier = identifier(); + last = identifier; isIdentifier = true; flags.setEncounteredTypename(true); break; @@ -1406,8 +1427,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } default: if (supportTypeOfUnaries && LT(1) == IGCCToken.t_typeof) { - Object expression = unaryTypeofExpression(); - if (expression != null) { + typeofExpression = unaryTypeofExpression(); + if (typeofExpression != null) { flags.setEncounteredTypename(true); } } @@ -1416,7 +1437,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } if (structSpec != null) { - ((ASTNode) structSpec).setOffsetAndLength(startingOffset, lastToken.getEndOffset() - startingOffset); + ((ASTNode) structSpec).setOffsetAndLength(startingOffset, + calculateEndOffset(structSpec) - startingOffset); structSpec.setConst(isConst); ((ICASTCompositeTypeSpecifier) structSpec).setRestrict(isRestrict); structSpec.setVolatile(isVolatile); @@ -1427,7 +1449,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } if (enumSpec != null) { - ((ASTNode) enumSpec).setOffsetAndLength(startingOffset, lastToken.getEndOffset() - startingOffset); + ((ASTNode) enumSpec).setOffsetAndLength(startingOffset, + calculateEndOffset(enumSpec) - startingOffset); enumSpec.setConst(isConst); ((CASTEnumerationSpecifier) enumSpec).setRestrict(isRestrict); enumSpec.setVolatile(isVolatile); @@ -1437,7 +1460,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } if (elabSpec != null) { - ((ASTNode) elabSpec).setOffsetAndLength(startingOffset, lastToken.getEndOffset() - startingOffset); + ((ASTNode) elabSpec).setOffsetAndLength(startingOffset, + calculateEndOffset(elabSpec) - startingOffset); elabSpec.setConst(isConst); ((CASTElaboratedTypeSpecifier) elabSpec).setRestrict(isRestrict); elabSpec.setVolatile(isVolatile); @@ -1454,7 +1478,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { declSpec.setInline(isInline); declSpec.setStorageClass(storageClass); - ((ASTNode) declSpec).setOffsetAndLength(startingOffset, lastToken.getEndOffset() - startingOffset); + ((ASTNode) declSpec).setOffsetAndLength(startingOffset, last + .getEndOffset() + - startingOffset); IASTName name = createName(identifier); declSpec.setName(name); name.setParent(declSpec); @@ -1474,8 +1500,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { declSpec.setUnsigned(isUnsigned); declSpec.setSigned(isSigned); declSpec.setShort(isShort); - int length = ( lastToken != null ) ? lastToken.getEndOffset() - startingOffset : 0 ; - ((ASTNode) declSpec).setOffsetAndLength(startingOffset, length ); + ((ASTNode) declSpec).setOffsetAndLength(startingOffset, + (last != null) ? last.getEndOffset() - startingOffset : 0); return declSpec; } @@ -1541,7 +1567,6 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } consume(IToken.tLBRACE); - cleanupLastToken(); IASTName name = null; if (nameToken != null) @@ -1583,7 +1608,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } // consume the } int endOffset = consume(IToken.tRBRACE).getEndOffset(); - ((CASTNode)result).setLength( endOffset - classKey.getOffset() ); + ((CASTNode) result).setLength(endOffset - classKey.getOffset()); return result; } @@ -1690,27 +1715,26 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { // parameterDeclarationClause // d.setIsFunction(true); // TODO need to create a temporary scope object here - consume(IToken.tLPAREN); + IToken last = consume(IToken.tLPAREN); isFunction = true; boolean seenParameter = false; parameterDeclarationLoop: for (;;) { switch (LT(1)) { case IToken.tRPAREN: - consume(); + last = consume(); break parameterDeclarationLoop; case IToken.tELLIPSIS: - consume(); + last = consume(); encounteredVarArgs = true; break; case IToken.tCOMMA: - consume(); + last = consume(); seenParameter = false; break; default: - int endOffset = (lastToken != null) ? lastToken - .getEndOffset() : 0; if (seenParameter) - throwBacktrack(startingOffset, endOffset + throwBacktrack(startingOffset, last + .getEndOffset() - startingOffset); IASTParameterDeclaration pd = parameterDeclaration(); if (parameters == Collections.EMPTY_LIST) @@ -1811,7 +1835,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { */ protected IASTName createName(IToken t) { IASTName n = new CASTName(t.getCharImage()); - ((ASTNode) n).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset()); + ((ASTNode) n).setOffsetAndLength(t.getOffset(), t.getEndOffset() + - t.getOffset()); return n; } @@ -1870,7 +1895,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { else exp = constantExpression(); } - consume(IToken.tRBRACKET); + int lastOffset = consume(IToken.tRBRACKET).getEndOffset(); IASTArrayModifier arrayMod = null; if (!(isStatic || isRestrict || isConst || isVolatile)) @@ -1884,7 +1909,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { temp.setVariableSized(isVarSized); arrayMod = temp; } - ((ASTNode) arrayMod).setOffsetAndLength(startOffset, lastToken.getEndOffset() - startOffset); + ((ASTNode) arrayMod).setOffsetAndLength(startOffset, lastOffset + - startOffset); if (exp != null) { arrayMod.setConstantExpression(exp); exp.setParent(arrayMod); @@ -1918,20 +1944,21 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { if (LT(1) != IToken.tSEMI) declarator = initDeclarator(); - if (current == LA(1)) { - int endOffset = (lastToken != null) ? lastToken.getEndOffset() : 0; - throwBacktrack(current.getOffset(), endOffset - current.getOffset()); - } + if (current == LA(1)) + throwBacktrack(current.getOffset(), figureEndOffset(declSpec, + declarator) + - current.getOffset()); IASTParameterDeclaration result = createParameterDeclaration(); - ((ASTNode) result).setOffsetAndLength(startingOffset, lastToken.getEndOffset() - startingOffset); + ((ASTNode) result).setOffsetAndLength(startingOffset, figureEndOffset( + declSpec, declarator) + - startingOffset); result.setDeclSpecifier(declSpec); declSpec.setParent(result); declSpec.setPropertyInParent(IASTParameterDeclaration.DECL_SPECIFIER); result.setDeclarator(declarator); declarator.setParent(result); declarator.setPropertyInParent(IASTParameterDeclaration.DECLARATOR); - return result; } @@ -1951,7 +1978,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { try { IASTExpression e = expression(); consume(IToken.tSEMI); - //TODO is this a problem? Should we wrap this in an expression statement? + //TODO is this a problem? Should we wrap this in an expression + // statement? return e; } catch (BacktrackException bt) { backup(mark); diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java index cc5892ff810..05d5b0be0c0 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java @@ -201,7 +201,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { */ protected IToken consumeTemplateParameters(IToken previousLast) throws EndOfFileException, BacktrackException { - int startingOffset = previousLast == null ? lastToken.getOffset() + int startingOffset = previousLast == null ? LA(1).getOffset() : previousLast.getOffset(); IToken last = previousLast; if (LT(1) == IToken.tLT) { @@ -442,8 +442,14 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { - operatorToken.getOffset() : 0); } else { // must be a conversion function + IToken t = LA(1); typeId(true); - toSend = lastToken; + if (t != LA(1)) { + while (t.getNext() != LA(1)) { + t = t.getNext(); + } + toSend = t; + } } boolean hasTemplateId = (templateArgs != null); @@ -494,35 +500,38 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { collection.add(refOp); return; } + IToken last = null; IToken mark = mark(); ITokenDuple nameDuple = null; boolean isConst = false, isVolatile = false, isRestrict = false; if (LT(1) == IToken.tIDENTIFIER || LT(1) == IToken.tCOLONCOLON) { try { nameDuple = name(); + last = nameDuple.getLastToken(); } catch (BacktrackException bt) { backup(mark); return; } } if (LT(1) == IToken.tSTAR) { - int starOffset = consume(IToken.tSTAR).getOffset(); + last = consume(IToken.tSTAR); + int starOffset = last.getOffset(); for (;;) { IToken t = LA(1); int startingOffset = LA(1).getOffset(); switch (LT(1)) { case IToken.t_const: - consume(IToken.t_const); + last = consume(IToken.t_const); isConst = true; break; case IToken.t_volatile: - consume(IToken.t_volatile); + last = consume(IToken.t_volatile); isVolatile = true; break; case IToken.t_restrict: if (allowCPPRestrict) { - consume(IToken.t_restrict); + last = consume(IToken.t_restrict); isRestrict = true; break; } @@ -556,7 +565,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } else { po = createPointer(isRestrict); - ((ASTNode) po).setOffsetAndLength(starOffset, lastToken + ((ASTNode) po).setOffsetAndLength(starOffset, last .getEndOffset() - starOffset); ((IASTPointer) po).setConst(isConst); @@ -682,9 +691,10 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { throwExpression = expression(); } catch (BacktrackException bte) { } + int o = throwExpression != null ? calculateEndOffset(throwExpression) + : throwToken.getEndOffset(); return buildUnaryExpression(ICPPASTUnaryExpression.op_throw, - throwExpression, throwToken.getOffset(), lastToken.getEndOffset() - - throwToken.getOffset()); + throwExpression, throwToken.getOffset(), o - throwToken.getOffset()); } /** @@ -731,8 +741,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { break; } firstExpression = buildBinaryExpression(expressionKind, - firstExpression, secondExpression, lastToken - .getEndOffset()); + firstExpression, secondExpression, + calculateEndOffset(secondExpression)); break; default: if (supportMinAndMaxOperators @@ -751,8 +761,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { secondExpression = shiftExpression(); firstExpression = buildBinaryExpression(new_operator, - firstExpression, secondExpression, lastToken - .getEndOffset()); + firstExpression, secondExpression, + calculateEndOffset(secondExpression)); break; } return firstExpression; @@ -787,8 +797,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { break; } firstExpression = buildBinaryExpression(operator, - firstExpression, secondExpression, lastToken - .getEndOffset()); + firstExpression, secondExpression, + calculateEndOffset(secondExpression)); break; default: return firstExpression; @@ -820,8 +830,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { break; } firstExpression = buildBinaryExpression(operator, - firstExpression, secondExpression, lastToken - .getEndOffset()); + firstExpression, secondExpression, + calculateEndOffset(secondExpression)); break; default: return firstExpression; @@ -862,8 +872,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IASTExpression castExpression = castExpression(); mark = null; // clean up mark so that we can garbage collect return buildTypeIdUnaryExpression(IASTCastExpression.op_cast, - typeId, castExpression, startingOffset, lastToken - .getEndOffset()); + typeId, castExpression, startingOffset, + calculateEndOffset(castExpression)); } catch (BacktrackException b) { if (templateIdScopes.size() > 0 && !popped) { templateIdScopes.pop(); @@ -889,22 +899,22 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { declarator = declarator(SimpleDeclarationStrategy.TRY_CONSTRUCTOR, true); } catch (BacktrackException bt) { - int endingOffset = lastToken == null ? 0 : lastToken.getEndOffset(); backup(mark); - throwBacktrack(startingOffset, endingOffset - startingOffset); + throwBacktrack(startingOffset, figureEndOffset(declSpecifier, + declarator) + - startingOffset); } if (declarator == null || declarator.getName().toString() != null) //$NON-NLS-1$ { - int endingOffset = lastToken == null ? 0 : lastToken.getEndOffset(); backup(mark); - throwBacktrack(startingOffset, endingOffset - startingOffset); + throwBacktrack(startingOffset, figureEndOffset(declSpecifier, + declarator) + - startingOffset); } IASTTypeId result = createTypeId(); - int l = lastToken != null ? lastToken.getEndOffset() - startingOffset - : ((ASTNode) declarator).getOffset() - + ((ASTNode) declarator).getLength() - startingOffset; - ((ASTNode) result).setOffsetAndLength(startingOffset, l); + ((ASTNode) result).setOffsetAndLength(startingOffset, figureEndOffset( + declSpecifier, declarator)); result.setDeclSpecifier(declSpecifier); declSpecifier.setParent(result); @@ -950,9 +960,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } IASTExpression castExpression = castExpression(); ICPPASTDeleteExpression deleteExpression = createDeleteExpression(); - ((ASTNode) deleteExpression).setOffsetAndLength(startingOffset, lastToken - .getEndOffset() - - startingOffset); + ((ASTNode) deleteExpression).setOffsetAndLength(startingOffset, + calculateEndOffset(castExpression) - startingOffset); deleteExpression.setIsGlobal(global); deleteExpression.setIsVectored(vectored); deleteExpression.setOperand(castExpression); @@ -987,13 +996,14 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { EndOfFileException { IToken la = LA(1); int startingOffset = la.getOffset(); + int lastOffset = 0; boolean isGlobal = false; if (LT(1) == IToken.tCOLONCOLON) { - consume(IToken.tCOLONCOLON); + lastOffset = consume(IToken.tCOLONCOLON).getEndOffset(); isGlobal = true; } - consume(IToken.t_new); + lastOffset = consume(IToken.t_new).getEndOffset(); boolean typeIdInParen = false; boolean placementParseFailure = true; IToken beforeSecondParen = null; @@ -1004,7 +1014,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { boolean isNewTypeId = false; if (LT(1) == IToken.tLPAREN) { - consume(IToken.tLPAREN); + lastOffset = consume(IToken.tLPAREN).getEndOffset(); if (templateIdScopes.size() > 0) { templateIdScopes.push(IToken.tLPAREN); } @@ -1013,7 +1023,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // Note: since expressionList and expression are the same... backtrackMarker = mark(); newPlacementExpressions = expression(); - consume(IToken.tRPAREN); + lastOffset = consume(IToken.tRPAREN).getEndOffset(); if (LT(1) == IToken.tLBRACKET) { backup(backtrackMarker); if (templateIdScopes.size() > 0) { @@ -1026,7 +1036,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { placementParseFailure = false; if (LT(1) == IToken.tLPAREN) { beforeSecondParen = mark(); - consume(IToken.tLPAREN); + lastOffset = consume(IToken.tLPAREN).getEndOffset(); if (templateIdScopes.size() > 0) { templateIdScopes.push(IToken.tLPAREN); } //push 2nd Paren @@ -1040,7 +1050,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // the first expression in () is not a placement // - then it has to be typeId typeId = typeId(true); - consume(IToken.tRPAREN); + lastOffset = consume(IToken.tRPAREN).getEndOffset(); if (templateIdScopes.size() > 0) { templateIdScopes.pop(); } //pop 1st Paren @@ -1062,6 +1072,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { try { backtrackMarker = mark(); typeId = typeId(true); + lastOffset = calculateEndOffset(typeId); } catch (BacktrackException e) { // Hmmm, so it wasn't typeId after all... Then it is // CASE: new (typeid-looking-as-placement) @@ -1078,7 +1089,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // typeid try { typeId = typeId(true); - consume(IToken.tRPAREN); + lastOffset = consume(IToken.tRPAREN).getEndOffset(); if (templateIdScopes.size() > 0) { templateIdScopes.pop(); } //popping the 2nd Paren @@ -1101,7 +1112,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // new-expression ends here. ICPPASTNewExpression result = createNewExpression(); ((ASTNode) result).setOffsetAndLength(startingOffset, - lastToken.getEndOffset() - startingOffset); + lastOffset - startingOffset); result.setIsGlobal(isGlobal); result.setIsNewTypeId(isNewTypeId); result.setTypeId(typeId); @@ -1239,11 +1250,11 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } catch (BacktrackException bt) { backup(mark); unaryExpression = unaryExpression(); - lastOffset = lastToken.getEndOffset(); + lastOffset = calculateEndOffset(unaryExpression); } } else { unaryExpression = unaryExpression(); - lastOffset = lastToken.getEndOffset(); + lastOffset = calculateEndOffset(unaryExpression); } if (typeId == null && unaryExpression != null) @@ -1481,8 +1492,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { ICPPASTFieldReference fieldReference = createFieldReference(); ((ASTNode) fieldReference).setOffsetAndLength( - ((ASTNode) firstExpression).getOffset(), lastToken - .getEndOffset() + ((ASTNode) firstExpression).getOffset(), + calculateEndOffset(name) - ((ASTNode) firstExpression).getOffset()); fieldReference.setIsTemplate(isTemplate); fieldReference.setIsPointerDereference(false); @@ -1509,8 +1520,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { fieldReference = createFieldReference(); ((ASTNode) fieldReference).setOffsetAndLength( - ((ASTNode) firstExpression).getOffset(), lastToken - .getEndOffset() + ((ASTNode) firstExpression).getOffset(), + calculateEndOffset(name) - ((ASTNode) firstExpression).getOffset()); fieldReference.setIsTemplate(isTemplate); fieldReference.setIsPointerDereference(true); @@ -1564,11 +1575,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { consume(); consume(IToken.tLPAREN); IASTExpression operand = expression(); - consume(IToken.tRPAREN); + int l = consume(IToken.tRPAREN).getEndOffset(); ICPPASTSimpleTypeConstructorExpression result = createSimpleTypeConstructorExpression(); - ((ASTNode) result).setOffsetAndLength(startingOffset, lastToken - .getEndOffset() - - startingOffset); + ((ASTNode) result).setOffsetAndLength(startingOffset, l - startingOffset); result.setSimpleType(operator); result.setInitialValue(operand); operand.setParent(result); @@ -1720,7 +1729,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IToken start = consume(); IToken end = null; if (start.getType() == IToken.tIDENTIFIER) - end = consumeTemplateParameters(end); + end = consumeTemplateParameters(null); while (LT(1) == IToken.tCOLONCOLON || LT(1) == IToken.tIDENTIFIER) { end = consume(); if (end.getType() == IToken.tIDENTIFIER) @@ -1750,11 +1759,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { consume(IToken.tGT); consume(IToken.tLPAREN); IASTExpression lhs = expression(); - consume(IToken.tRPAREN); + int l = consume(IToken.tRPAREN).getEndOffset(); IASTCastExpression result = createCastExpression(); - ((ASTNode) result).setOffsetAndLength(startingOffset, lastToken - .getEndOffset() - - startingOffset); + ((ASTNode) result).setOffsetAndLength(startingOffset, l - startingOffset); result.setTypeId(typeID); typeID.setParent(result); typeID.setPropertyInParent(IASTCastExpression.TYPE_ID); @@ -1819,9 +1826,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (LT(1) == IToken.t_namespace) { // using-directive - consume(IToken.t_namespace); - - int endOffset = (lastToken != null) ? lastToken.getEndOffset() : 0; + int endOffset = consume(IToken.t_namespace).getEndOffset(); IASTName name = null; if (LT(1) == IToken.tIDENTIFIER || LT(1) == IToken.tCOLONCOLON) name = createName(name()); @@ -1829,10 +1834,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { throwBacktrack(firstToken.getOffset(), endOffset - firstToken.getOffset()); - consume(IToken.tSEMI); + endOffset = consume(IToken.tSEMI).getEndOffset(); ICPPASTUsingDirective astUD = createUsingDirective(); - ((ASTNode) astUD).setOffsetAndLength(firstToken.getOffset(), lastToken - .getEndOffset() + ((ASTNode) astUD).setOffsetAndLength(firstToken.getOffset(), endOffset - firstToken.getOffset()); astUD.setQualifiedName(name); name.setParent(astUD); @@ -1848,10 +1852,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } IASTName name = createName(name()); - consume(IToken.tSEMI); + int end = consume(IToken.tSEMI).getEndOffset(); ICPPASTUsingDeclaration result = createUsingDeclaration(); - ((ASTNode) result).setOffsetAndLength(firstToken.getOffset(), lastToken - .getEndOffset() + ((ASTNode) result).setOffsetAndLength(firstToken.getOffset(), end - firstToken.getOffset()); result.setIsTypename(typeName); result.setName(name); @@ -2017,7 +2020,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { templateInstantiation = createTemplateInstantiation(); IASTDeclaration d = declaration(); ((ASTNode) templateInstantiation).setOffsetAndLength(firstToken - .getOffset(), lastToken.getEndOffset() - firstToken.getOffset()); + .getOffset(), calculateEndOffset(d) - firstToken.getOffset()); templateInstantiation.setDeclaration(d); d.setParent(templateInstantiation); d @@ -2032,7 +2035,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { ICPPASTTemplateSpecialization templateSpecialization = createTemplateSpecialization(); IASTDeclaration d = declaration(); ((ASTNode) templateSpecialization).setOffsetAndLength(firstToken - .getOffset(), lastToken.getEndOffset() - firstToken.getOffset()); + .getOffset(), calculateEndOffset(d) - firstToken.getOffset()); templateSpecialization.setDeclaration(d); d.setParent(templateSpecialization); d.setPropertyInParent(ICPPASTTemplateSpecialization.OWNED_DECLARATION); @@ -2045,7 +2048,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IASTDeclaration d = declaration(); ICPPASTTemplateDeclaration templateDecl = createTemplateDeclaration(); ((ASTNode) templateDecl).setOffsetAndLength(firstToken.getOffset(), - lastToken.getEndOffset() - firstToken.getOffset()); + calculateEndOffset(d) - firstToken.getOffset()); templateDecl.setExported(exported); templateDecl.setDeclaration(d); d.setParent(templateDecl); @@ -2125,29 +2128,30 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { return returnValue; if (LT(1) == IToken.t_class || LT(1) == IToken.t_typename) { IToken startingToken = LA(1); + int lastOffset = 0; int type = (LT(1) == IToken.t_class ? ICPPASTSimpleTypeTemplateParameter.st_class : ICPPASTSimpleTypeTemplateParameter.st_typename); - consume(); + lastOffset = consume().getEndOffset(); IASTName identifierName = null; IASTTypeId typeId = null; if (LT(1) == IToken.tIDENTIFIER) // optional identifier { identifierName = createName(identifier()); - + lastOffset = calculateEndOffset(identifierName); if (LT(1) == IToken.tASSIGN) // optional = type-id { consume(IToken.tASSIGN); typeId = typeId(false); // type-id + lastOffset = calculateEndOffset(typeId); } } else { identifierName = createName(); } ICPPASTSimpleTypeTemplateParameter parm = createSimpleTemplateParameter(); - int l = lastToken != null ? lastToken.getEndOffset() - - startingToken.getOffset() : 0; - ((ASTNode) parm).setOffsetAndLength(startingToken.getOffset(), l); + ((ASTNode) parm).setOffsetAndLength(startingToken.getOffset(), + lastOffset - startingToken.getOffset()); parm.setParameterType(type); parm.setName(identifierName); identifierName.setParent(parm); @@ -2167,25 +2171,26 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { List subResult = templateParameterList(); consume(IToken.tGT); - consume(IToken.t_class); + int last = consume(IToken.t_class).getEndOffset(); IASTName identifierName = null; IASTExpression optionalExpression = null; if (LT(1) == IToken.tIDENTIFIER) // optional identifier { identifierName = createName(identifier()); - + last = calculateEndOffset(identifierName); if (LT(1) == IToken.tASSIGN) // optional = type-id { consume(IToken.tASSIGN); optionalExpression = primaryExpression(); + last = calculateEndOffset(optionalExpression); } } else identifierName = createName(); ICPPASTTemplatedTypeTemplateParameter parm = createTemplatedTemplateParameter(); - ((ASTNode) parm).setOffsetAndLength(firstToken.getOffset(), - lastToken.getEndOffset() - firstToken.getOffset()); + ((ASTNode) parm).setOffsetAndLength(firstToken.getOffset(), last + - firstToken.getOffset()); parm.setName(identifierName); identifierName.setParent(parm); identifierName @@ -2281,9 +2286,10 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IASTProblem firstFailure = null; IASTProblem secondFailure = null; try { - return simpleDeclaration(SimpleDeclarationStrategy.TRY_CONSTRUCTOR, + IASTDeclaration d = simpleDeclaration(SimpleDeclarationStrategy.TRY_CONSTRUCTOR, false); - // try it first with the original strategy + throwAwayMarksForInitializerClause(); + return d; } catch (BacktrackException bt) { if (simpleDeclarationMark == null) throwBacktrack(bt); @@ -2292,8 +2298,10 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { backup(simpleDeclarationMark); try { - return simpleDeclaration(SimpleDeclarationStrategy.TRY_FUNCTION, + IASTDeclaration d = simpleDeclaration(SimpleDeclarationStrategy.TRY_FUNCTION, false); + throwAwayMarksForInitializerClause(); + return d; } catch (BacktrackException bt2) { if (simpleDeclarationMark == null) { if (firstFailure != null && (bt2.getProblem() == null)) @@ -2304,7 +2312,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { secondFailure = bt2.getProblem(); backup(simpleDeclarationMark); - + throwAwayMarksForInitializerClause(); try { return simpleDeclaration(SimpleDeclarationStrategy.TRY_VARIABLE, false); @@ -2342,11 +2350,13 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { throws BacktrackException, EndOfFileException { IToken first = consume(IToken.t_namespace); + int last = first.getEndOffset(); IASTName name = null; // optional name - if (LT(1) == IToken.tIDENTIFIER) + if (LT(1) == IToken.tIDENTIFIER) { name = createName(identifier()); - else + last = calculateEndOffset(name); + } else name = createName(); if (LT(1) == IToken.tLBRACE) { @@ -2356,8 +2366,6 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { namespaceDefinition.setName(name); name.setParent(namespaceDefinition); name.setPropertyInParent(ICPPASTNamespaceDefinition.NAMESPACE_NAME); - - cleanupLastToken(); namespaceDeclarationLoop: while (LT(1) != IToken.tRBRACE) { int checkToken = LA(1).hashCode(); switch (LT(1)) { @@ -2417,8 +2425,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { qualifiedName.setPropertyInParent(ICPPASTNamespaceAlias.MAPPING_NAME); return alias; } else { - int endOffset = (lastToken != null) ? lastToken.getEndOffset() : 0; - throwBacktrack(first.getOffset(), endOffset - first.getOffset()); + throwBacktrack(first.getOffset(), last - first.getOffset()); return null; } } @@ -2637,6 +2644,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { s.setParent(funcDefinition); s.setPropertyInParent(IASTFunctionDefinition.FUNCTION_BODY); } + ((CPPASTNode) funcDefinition).setLength(calculateEndOffset(s) + - firstOffset); if (hasFunctionTryBlock && declarator instanceof ICPPASTFunctionTryBlockDeclarator) { @@ -2650,17 +2659,18 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { handler.setParent(declarator); handler .setPropertyInParent(ICPPASTFunctionTryBlockDeclarator.CATCH_HANDLER); + ((CPPASTNode) funcDefinition) + .setLength(calculateEndOffset(handler) - firstOffset); + } + } - ((CPPASTNode) funcDefinition).setLength(lastToken.getEndOffset() - - firstOffset); return funcDefinition; } IASTSimpleDeclaration simpleDeclaration = createSimpleDeclaration(); - ((ASTNode) simpleDeclaration).setOffsetAndLength(firstOffset, lastToken - .getEndOffset() - - firstOffset); + ((ASTNode) simpleDeclaration).setOffsetAndLength(firstOffset, + figureEndOffset(declSpec, declarators) - firstOffset); simpleDeclaration.setDeclSpecifier(declSpec); declSpec.setParent(simpleDeclaration); declSpec.setPropertyInParent(IASTSimpleDeclaration.DECL_SPECIFIER); @@ -2765,14 +2775,14 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { declarator = initDeclarator(SimpleDeclarationStrategy.TRY_FUNCTION); if (current == LA(1)) { - int endOffset = (lastToken != null) ? lastToken.getEndOffset() : 0; - throwBacktrack(current.getOffset(), endOffset - current.getOffset()); + throwBacktrack(current.getOffset(), figureEndOffset(declSpec, + declarator) + - current.getOffset()); } ICPPASTParameterDeclaration parm = createParameterDeclaration(); - int length = (lastToken != null) ? lastToken.getEndOffset() - - current.getOffset() : ((ASTNode) declSpec).getLength() - + ((ASTNode) declarator).getLength(); - ((ASTNode) parm).setOffsetAndLength(current.getOffset(), length); + ((ASTNode) parm).setOffsetAndLength(current.getOffset(), figureEndOffset( + declSpec, declarator) + - current.getOffset()); parm.setDeclSpecifier(declSpec); declSpec.setParent(parm); declSpec.setPropertyInParent(IASTParameterDeclaration.DECL_SPECIFIER); @@ -2893,6 +2903,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { boolean tryConstructor) throws BacktrackException, EndOfFileException { IToken firstToken = LA(1); Flags flags = new Flags(parm, tryConstructor); + IToken last = null; boolean isInline = false, isVirtual = false, isExplicit = false, isFriend = false; boolean isConst = false, isVolatile = false, isRestrict = false; @@ -2910,52 +2921,52 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { declSpecifiers: for (;;) { switch (LT(1)) { case IToken.t_inline: - consume(); + last = consume(); isInline = true; break; case IToken.t_typedef: storageClass = IASTDeclSpecifier.sc_typedef; - consume(); + last = consume(); break; case IToken.t_auto: - consume(); + last = consume(); storageClass = IASTDeclSpecifier.sc_auto; break; case IToken.t_register: - consume(); + last = consume(); storageClass = IASTDeclSpecifier.sc_register; break; case IToken.t_static: storageClass = IASTDeclSpecifier.sc_static; - consume(); + last = consume(); break; case IToken.t_extern: storageClass = IASTDeclSpecifier.sc_extern; - consume(); + last = consume(); break; case IToken.t_mutable: storageClass = ICPPASTDeclSpecifier.sc_mutable; - consume(); + last = consume(); break; case IToken.t_virtual: isVirtual = true; - consume(); + last = consume(); break; case IToken.t_explicit: isExplicit = true; - consume(); + last = consume(); break; case IToken.t_friend: isFriend = true; - consume(); + last = consume(); break; case IToken.t_const: isConst = true; - consume(); + last = consume(); break; case IToken.t_volatile: isVolatile = true; - consume(); + last = consume(); break; case IToken.t_restrict: if (!supportRestrict) { @@ -2964,22 +2975,22 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { - la.getOffset()); } isRestrict = true; - consume(); + last = consume(); break; case IToken.t_signed: isSigned = true; flags.setEncounteredRawType(true); - consume(); + last = consume(); break; case IToken.t_unsigned: isUnsigned = true; flags.setEncounteredRawType(true); - consume(); + last = consume(); break; case IToken.t_short: isShort = true; flags.setEncounteredRawType(true); - consume(); + last = consume(); break; case IToken.t_long: if (isLong && supportLongLong) { @@ -2988,7 +2999,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } else isLong = true; flags.setEncounteredRawType(true); - consume(); + last = consume(); break; case IToken.t__Complex: if (!supportComplex) { @@ -2996,7 +3007,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { throwBacktrack(la.getOffset(), la.getEndOffset() - la.getOffset()); } - consume(IToken.t__Complex); + last = consume(IToken.t__Complex); simpleType = IGPPASTSimpleDeclSpecifier.t_Complex; break; case IToken.t__Imaginary: @@ -3004,47 +3015,47 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IToken la = LA(1); throwBacktrack(la.getOffset(), la.getLength()); } - consume(IToken.t__Imaginary); + last = consume(IToken.t__Imaginary); simpleType = IGPPASTSimpleDeclSpecifier.t_Imaginary; break; case IToken.t_char: simpleType = IASTSimpleDeclSpecifier.t_char; flags.setEncounteredRawType(true); - consume(); + last = consume(); break; case IToken.t_wchar_t: simpleType = ICPPASTSimpleDeclSpecifier.t_wchar_t; flags.setEncounteredRawType(true); - consume(); + last = consume(); break; case IToken.t_bool: simpleType = ICPPASTSimpleDeclSpecifier.t_bool; flags.setEncounteredRawType(true); - consume(); + last = consume(); break; case IToken.t_int: flags.setEncounteredRawType(true); - consume(); + last = consume(); simpleType = IASTSimpleDeclSpecifier.t_int; break; case IToken.t_float: simpleType = IASTSimpleDeclSpecifier.t_float; flags.setEncounteredRawType(true); - consume(); + last = consume(); break; case IToken.t_double: simpleType = IASTSimpleDeclSpecifier.t_double; flags.setEncounteredRawType(true); - consume(); + last = consume(); break; case IToken.t_void: simpleType = IASTSimpleDeclSpecifier.t_void; flags.setEncounteredRawType(true); - consume(); + last = consume(); break; case IToken.t_typename: isTypename = true; - consume(IToken.t_typename); + last = consume(IToken.t_typename); duple = name(); flags.setEncounteredTypename(true); break; @@ -3064,6 +3075,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { break declSpecifiers; duple = name(); + last = duple.getLastToken(); flags.setEncounteredTypename(true); break; case IToken.t_class: @@ -3169,8 +3181,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } else simpleDeclSpec = createSimpleDeclSpecifier(); - int l = lastToken != null ? lastToken.getEndOffset() - - firstToken.getOffset() : 0; + int l = last != null ? last.getEndOffset() - firstToken.getOffset() : 0; ((ASTNode) simpleDeclSpec).setOffsetAndLength(firstToken.getOffset(), l); simpleDeclSpec.setConst(isConst); simpleDeclSpec.setVolatile(isVolatile); @@ -3251,7 +3262,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { ICPPASTElaboratedTypeSpecifier elaboratedTypeSpec = createElaboratedTypeSpecifier(); ((ASTNode) elaboratedTypeSpec).setOffsetAndLength(t.getOffset(), - lastToken.getEndOffset() - t.getOffset()); + calculateEndOffset(name) - t.getOffset()); elaboratedTypeSpec.setKind(eck); elaboratedTypeSpec.setName(name); name.setParent(elaboratedTypeSpec); @@ -3313,9 +3324,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // initializer in constructor int o = consume(IToken.tLPAREN).getOffset(); // EAT IT! IASTExpression astExpression = expression(); - consume(IToken.tRPAREN); + int l = consume(IToken.tRPAREN).getEndOffset(); ICPPASTConstructorInitializer result = createConstructorInitializer(); - ((ASTNode) result).setOffsetAndLength(o, lastToken.getEndOffset() - o); + ((ASTNode) result).setOffsetAndLength(o, l - o); result.setExpression(astExpression); astExpression.setParent(result); astExpression @@ -3344,9 +3355,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { ((ASTNode) result).setOffset(startingOffset); if (LT(1) == (IToken.tRBRACE)) { - consume(IToken.tRBRACE); - ((ASTNode) result).setLength(lastToken.getEndOffset() - - startingOffset); + int l = consume(IToken.tRBRACE).getEndOffset(); + ((ASTNode) result).setLength(l - startingOffset); return result; } @@ -3367,9 +3377,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { break; consume(IToken.tCOMMA); } - consume(IToken.tRBRACE); - ((ASTNode) result) - .setLength(lastToken.getEndOffset() - startingOffset); + int l = consume(IToken.tRBRACE).getEndOffset(); + ((ASTNode) result).setLength(l - startingOffset); return result; } @@ -3478,20 +3487,12 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IToken newMark = mark(); consume(IToken.tLPAREN); try { - try { - name(); - //TODO - we need to lookup/resolve this name - //see if its a type ... - //if it is a type, failed = false - //else failed = true - failed = false; - } catch (Exception e) { - int endOffset = (lastToken != null) ? lastToken - .getEndOffset() : 0; - logException("declarator:queryIsTypeName", e); //$NON-NLS-1$ - throwBacktrack(startingOffset, endOffset - - startingOffset); - } + name(); + //TODO - we need to lookup/resolve this name + //see if its a type ... + //if it is a type, failed = false + //else failed = true + failed = false; } catch (BacktrackException b) { failed = true; } @@ -3504,24 +3505,24 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // parameterDeclarationClause isFunction = true; // TODO need to create a temporary scope object here - consume(IToken.tLPAREN); + IToken last = consume(IToken.tLPAREN); boolean seenParameter = false; parameterDeclarationLoop: for (;;) { switch (LT(1)) { case IToken.tRPAREN: - consume(); + last = consume(); break parameterDeclarationLoop; case IToken.tELLIPSIS: - consume(); + last = consume(); encounteredVarArgs = true; break; case IToken.tCOMMA: - consume(); + last = consume(); seenParameter = false; break; default: - int endOffset = (lastToken != null) ? lastToken - .getEndOffset() : 0; + int endOffset = (last != null) ? last + .getEndOffset() : LA(1).getEndOffset(); if (seenParameter) throwBacktrack(startingOffset, endOffset - startingOffset); @@ -3782,15 +3783,14 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { end = operatorId(start, (hasTemplateId ? argumentList : null)) .getLastToken(); else { - int endOffset = (lastToken != null) ? lastToken.getEndOffset() - : 0; + int endOffset = (end != null) ? end.getEndOffset() : 0; backup(mark); throwBacktrack(mark.getOffset(), endOffset - mark.getOffset()); } return TokenFactory.createTokenDuple(start, end, argumentList .getTemplateArgumentsList()); } - int endOffset = (lastToken != null) ? lastToken.getEndOffset() : 0; + int endOffset = (mark != null) ? mark.getEndOffset() : 0; backup(mark); throwBacktrack(mark.getOffset(), endOffset - mark.getOffset()); @@ -3867,7 +3867,6 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (LT(1) == IToken.tLBRACE) { consume(IToken.tLBRACE); - cleanupLastToken(); memberDeclarationLoop: while (LT(1) != IToken.tRBRACE) { int checkToken = LA(1).hashCode(); switch (LT(1)) { @@ -3875,10 +3874,10 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { case IToken.t_protected: case IToken.t_private: IToken key = consume(); - consume(IToken.tCOLON); + int l = consume(IToken.tCOLON).getEndOffset(); ICPPASTVisiblityLabel label = createVisibilityLabel(); - ((ASTNode) label).setOffsetAndLength(key.getOffset(), - lastToken.getEndOffset() - key.getOffset()); + ((ASTNode) label).setOffsetAndLength(key.getOffset(), l + - key.getOffset()); label.setVisibility(token2Visibility(key.getType())); astClassSpecifier.addMemberDeclaration(label); label.setParent(astClassSpecifier); @@ -3914,9 +3913,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { failParseWithErrorHandling(); } // consume the } - consume(IToken.tRBRACE); - ((ASTNode) astClassSpecifier).setLength(lastToken.getEndOffset() - - classKey.getOffset()); + int l = consume(IToken.tRBRACE).getEndOffset(); + ((ASTNode) astClassSpecifier).setLength(l - classKey.getOffset()); } return astClassSpecifier; @@ -3967,7 +3965,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { protected void baseSpecifier(ICPPASTCompositeTypeSpecifier astClassSpec) throws EndOfFileException, BacktrackException { - consume(IToken.tCOLON); + IToken last = consume(IToken.tCOLON); boolean isVirtual = false; int visibility = 0; //ASTAccessVisibility.PUBLIC; @@ -3979,7 +3977,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (firstToken == null) firstToken = consume(IToken.t_virtual); else - consume(IToken.t_virtual); + last = consume(IToken.t_virtual); isVirtual = true; break; case IToken.t_public: @@ -3987,26 +3985,28 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (firstToken == null) firstToken = consume(); else - consume(); + last = consume(); break; case IToken.t_protected: visibility = ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier.v_protected; if (firstToken == null) firstToken = consume(); else - consume(); + last = consume(); break; case IToken.t_private: visibility = ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier.v_private; if (firstToken == null) firstToken = consume(); else - consume(); + last = consume(); break; case IToken.tCOLONCOLON: case IToken.tIDENTIFIER: //to get templates right we need to use the class as the scope - name = createName(name()); + ITokenDuple d = name(); + name = createName(d); + last = d.getLastToken(); break; case IToken.tCOMMA: if (name == null) @@ -4015,7 +4015,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier baseSpec = createBaseSpecifier(); if (firstToken != null) ((ASTNode) baseSpec).setOffsetAndLength(firstToken - .getOffset(), lastToken.getEndOffset() + .getOffset(), last.getEndOffset() - firstToken.getOffset()); baseSpec.setVirtual(isVirtual); baseSpec.setVisibility(visibility); @@ -4040,9 +4040,10 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { name = createName(); baseSpec = createBaseSpecifier(); if (firstToken != null) - ((ASTNode) baseSpec).setOffsetAndLength(firstToken - .getOffset(), lastToken.getEndOffset() - - firstToken.getOffset()); + ((ASTNode) baseSpec) + .setOffsetAndLength(firstToken.getOffset(), last + .getOffset() + - firstToken.getOffset()); baseSpec.setVirtual(isVirtual); baseSpec.setVisibility(visibility); baseSpec.setName(name); @@ -4073,7 +4074,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (LT(1) != IToken.t_catch) { IToken la = LA(1); throwBacktrack(la.getOffset(), la.getLength()); // error, need at least - // one of these + // one of these } while (LT(1) == IToken.t_catch) { int startOffset = consume(IToken.t_catch).getOffset(); @@ -4101,9 +4102,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IASTStatement compoundStatement = catchBlockCompoundStatement(); ICPPASTCatchHandler handler = createCatchHandler(); - ((ASTNode) handler).setOffsetAndLength(startOffset, lastToken - .getEndOffset() - - startOffset); + ((ASTNode) handler).setOffsetAndLength(startOffset, + calculateEndOffset(compoundStatement) - startOffset); handler.setIsCatchAll(isEllipsis); if (decl != null) { handler.setDeclaration(decl); @@ -4130,14 +4130,24 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { protected IASTStatement catchBlockCompoundStatement() throws BacktrackException, EndOfFileException { if (mode == ParserMode.QUICK_PARSE || mode == ParserMode.STRUCTURAL_PARSE) { - skipOverCompoundStatement(); - return null; + IToken curr = LA(1); + IToken last = skipOverCompoundStatement(); + IASTCompoundStatement cs = createCompoundStatement(); + ((ASTNode) cs).setOffsetAndLength(curr.getOffset(), last + .getEndOffset() + - curr.getOffset()); + return cs; } else if (mode == ParserMode.COMPLETION_PARSE || mode == ParserMode.SELECTION_PARSE) { if (scanner.isOnTopContext()) return compoundStatement(); - skipOverCompoundStatement(); - return null; + IToken curr = LA(1); + IToken last = skipOverCompoundStatement(); + IASTCompoundStatement cs = createCompoundStatement(); + ((ASTNode) cs).setOffsetAndLength(curr.getOffset(), last + .getEndOffset() + - curr.getOffset()); + return cs; } return compoundStatement(); } @@ -4262,10 +4272,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (LT(1) != IToken.tRBRACKET) { exp = constantExpression(); } - consume(IToken.tRBRACKET); + int l = consume(IToken.tRBRACKET).getEndOffset(); IASTArrayModifier arrayMod = createArrayModifier(); - ((ASTNode) arrayMod).setOffsetAndLength(o, lastToken.getEndOffset() - - o); + ((ASTNode) arrayMod).setOffsetAndLength(o, l - o); if (exp != null) { arrayMod.setConstantExpression(exp); exp.setParent(arrayMod); @@ -4586,11 +4595,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IASTStatement tryBlock = compoundStatement(); List catchHandlers = new ArrayList(DEFAULT_CATCH_HANDLER_LIST_SIZE); catchHandlerSequence(catchHandlers); - cleanupLastToken(); ICPPASTTryBlockStatement tryStatement = createTryBlockStatement(); - ((ASTNode) tryStatement).setOffsetAndLength(startO, lastToken - .getEndOffset() - - startO); + ((ASTNode) tryStatement).setOffset(startO); tryStatement.setTryBody(tryBlock); tryBlock.setParent(tryStatement); tryBlock.setPropertyInParent(ICPPASTTryBlockStatement.BODY); @@ -4601,6 +4607,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { tryStatement.addCatchHandler(handler); handler.setParent(tryStatement); handler.setPropertyInParent(ICPPASTTryBlockStatement.CATCH_HANDLER); + ((ASTNode) tryStatement).setLength(calculateEndOffset(handler) + - startO); } return tryStatement; }