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 c8b85da97ee..67845ea338f 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 @@ -14,6 +14,7 @@ * Thomas Corbat (IFS) * Anders Dahlberg (Ericsson) - bug 84144 * Justin You (Synopsys) - bug 84144 + * Alexander Nyßen (itemis AG) - bug 475908 *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.parser; @@ -255,6 +256,10 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser { backtrack.initialize(offset, (length < 0) ? 0 : length); throw backtrack; } + + protected INodeFactory getNodeFactory() { + return nodeFactory; + } @Override public IASTCompletionNode getCompletionNode() { 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 2804f055f88..b2e55a3984a 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 @@ -13,6 +13,7 @@ * Sergey Prigogin (Google) * Thomas Corbat (IFS) * Anders Dahlberg (Ericsson) - bug 84144 + * Alexander Nyßen (itemis AG) - bug 475908 *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.parser.c; @@ -112,8 +113,6 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { protected IASTTranslationUnit translationUnit; private int fPreventKnrCheck= 0; - - private final ICNodeFactory nodeFactory; public GNUCSourceParser(IScanner scanner, ParserMode parserMode, IParserLogService logService, ICParserExtensionConfiguration config) { @@ -136,7 +135,11 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { supportExtendedSizeofOperator= config.supportExtendedSizeofOperator(); supportFunctionStyleAsm= config.supportFunctionStyleAssembler(); this.index= index; - this.nodeFactory = CNodeFactory.getDefault(); + } + + @Override + protected ICNodeFactory getNodeFactory() { + return (ICNodeFactory) super.getNodeFactory(); } @Override @@ -144,7 +147,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { if (LTcatchEOF(1) == IToken.tASSIGN) { final int offset= consume().getOffset(); IASTInitializerClause initClause = initClause(); - IASTEqualsInitializer result= nodeFactory.newEqualsInitializer(initClause); + IASTEqualsInitializer result= getNodeFactory().newEqualsInitializer(initClause); return setRange(result, offset, calculateEndOffset(initClause)); } return null; @@ -157,7 +160,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { // it's an aggregate initializer consume(IToken.tLBRACE); - IASTInitializerList result = nodeFactory.newInitializerList(); + IASTInitializerList result = getNodeFactory().newInitializerList(); // bug 196468, gcc accepts empty braces. if (supportGCCStyleDesignators && LT(1) == IToken.tRBRACE) { @@ -181,7 +184,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { // in any way add the initializer such that the actual size can be tracked. result.addClause(clause); } else { - ICASTDesignatedInitializer desigInitializer = nodeFactory.newDesignatedInitializer((IASTInitializerClause) null); + ICASTDesignatedInitializer desigInitializer = getNodeFactory().newDesignatedInitializer((IASTInitializerClause) null); setRange(desigInitializer, designator.get(0)); for (ICASTDesignator d : designator) { desigInitializer.addDesignator(d); @@ -232,7 +235,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { case IToken.tDOT: int offset = consume().getOffset(); IASTName n = identifier(); - ICASTFieldDesignator fieldDesignator = nodeFactory.newFieldDesignator(n); + ICASTFieldDesignator fieldDesignator = getNodeFactory().newFieldDesignator(n); setRange(fieldDesignator, offset, calculateEndOffset(n)); if (designatorList == null) designatorList = new ArrayList(DEFAULT_DESIGNATOR_LIST_SIZE); @@ -246,14 +249,14 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { consume(IToken.tELLIPSIS); IASTExpression constantExpression2 = expression(); int lastOffset = consume(IToken.tRBRACKET).getEndOffset(); - IGCCASTArrayRangeDesignator designator = nodeFactory.newArrayRangeDesignatorGCC(constantExpression, constantExpression2); + IGCCASTArrayRangeDesignator designator = getNodeFactory().newArrayRangeDesignatorGCC(constantExpression, constantExpression2); setRange(designator, offset, lastOffset); if (designatorList == null) designatorList = new ArrayList(DEFAULT_DESIGNATOR_LIST_SIZE); designatorList.add(designator); } else { int lastOffset = consume(IToken.tRBRACKET).getEndOffset(); - ICASTArrayDesignator designator = nodeFactory.newArrayDesignator(constantExpression); + ICASTArrayDesignator designator = getNodeFactory().newArrayDesignator(constantExpression); setRange(designator, offset, lastOffset); if (designatorList == null) designatorList = new ArrayList(DEFAULT_DESIGNATOR_LIST_SIZE); @@ -272,7 +275,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { int offset= LA(1).getOffset(); IASTName n = identifier(); int lastOffset = consume(IToken.tCOLON).getEndOffset(); - ICASTFieldDesignator designator = nodeFactory.newFieldDesignator(n); + ICASTFieldDesignator designator = getNodeFactory().newFieldDesignator(n); setRange(designator, offset, lastOffset); return Collections.singletonList(designator); } @@ -287,8 +290,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { return asmDeclaration(); case IToken.tSEMI: IToken semi= consume(); - IASTDeclSpecifier declspec= nodeFactory.newSimpleDeclSpecifier(); - IASTSimpleDeclaration decl= nodeFactory.newSimpleDeclaration(declspec); + IASTDeclSpecifier declspec= getNodeFactory().newSimpleDeclSpecifier(); + IASTSimpleDeclaration decl= getNodeFactory().newSimpleDeclaration(declspec); decl.setDeclSpecifier(declspec); ((ASTNode) declspec).setOffsetAndLength(semi.getOffset(), 0); ((ASTNode) decl).setOffsetAndLength(semi.getOffset(), semi.getLength()); @@ -326,7 +329,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } catch (BacktrackException e) { IASTNode node= e.getNodeBeforeProblem(); if (node instanceof IASTDeclSpecifier) { - IASTSimpleDeclaration d= nodeFactory.newSimpleDeclaration((IASTDeclSpecifier) node); + IASTSimpleDeclaration d= getNodeFactory().newSimpleDeclaration((IASTDeclSpecifier) node); setRange(d, node); throwBacktrack(e.getProblem(), d); } @@ -395,7 +398,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } // no function body - IASTSimpleDeclaration simpleDeclaration = nodeFactory.newSimpleDeclaration(declSpec); + IASTSimpleDeclaration simpleDeclaration = getNodeFactory().newSimpleDeclaration(declSpec); for (IASTDeclarator declarator : declarators) simpleDeclaration.addDeclarator(declarator); @@ -422,7 +425,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { if (!(fdtor instanceof IASTFunctionDeclarator)) throwBacktrack(firstOffset, LA(1).getEndOffset() - firstOffset); - IASTFunctionDefinition funcDefinition = nodeFactory.newFunctionDefinition(declSpec, (IASTFunctionDeclarator) fdtor, null); + IASTFunctionDefinition funcDefinition = getNodeFactory().newFunctionDefinition(declSpec, (IASTFunctionDeclarator) fdtor, null); try { IASTStatement s= handleFunctionBody(); @@ -444,7 +447,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { @Override protected void setupTranslationUnit() throws DOMException { - translationUnit = nodeFactory.newTranslationUnit(scanner); + translationUnit = getNodeFactory().newTranslationUnit(scanner); translationUnit.setIndex(index); // add built-in names to the scope @@ -583,7 +586,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { @Override protected IASTExpression buildBinaryExpression(int operator, IASTExpression expr1, IASTInitializerClause expr2, int lastOffset) { - IASTBinaryExpression result = nodeFactory.newBinaryExpression(operator, expr1, (IASTExpression) expr2); + IASTBinaryExpression result = getNodeFactory().newBinaryExpression(operator, expr1, (IASTExpression) expr2); int o = ((ASTNode) expr1).getOffset(); ((ASTNode) result).setOffsetAndLength(o, lastOffset - o); return result; @@ -635,7 +638,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { consume(IToken.tRPAREN); if (LT(1) == IToken.tLBRACE) { IASTInitializer i = (IASTInitializerList) initClause(); - firstExpression= nodeFactory.newTypeIdInitializerExpression(t, i); + firstExpression= getNodeFactory().newTypeIdInitializerExpression(t, i); setRange(firstExpression, offset, calculateEndOffset(i)); break; } @@ -669,7 +672,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { throw backtrack; } - IASTArraySubscriptExpression s = nodeFactory.newArraySubscriptExpression(firstExpression, secondExpression); + IASTArraySubscriptExpression s = getNodeFactory().newArraySubscriptExpression(firstExpression, secondExpression); ((ASTNode) s).setOffsetAndLength(((ASTNode) firstExpression).getOffset(), last - ((ASTNode) firstExpression).getOffset()); firstExpression = s; @@ -708,7 +711,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } else { args= argList.toArray(new IASTExpression[argList.size()]); } - IASTFunctionCallExpression f = nodeFactory.newFunctionCallExpression(firstExpression, args); + IASTFunctionCallExpression f = getNodeFactory().newFunctionCallExpression(firstExpression, args); firstExpression = setRange(f, firstExpression, endOffset); break; case IToken.tINCR: @@ -730,7 +733,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { if (name == null) throwBacktrack(((ASTNode) firstExpression).getOffset(), ((ASTNode) firstExpression).getLength() + dot.getLength()); - IASTFieldReference result = nodeFactory.newFieldReference(name, firstExpression); + IASTFieldReference result = getNodeFactory().newFieldReference(name, firstExpression); result.setIsPointerDereference(false); ((ASTNode) result).setOffsetAndLength( ((ASTNode) firstExpression).getOffset(), @@ -744,7 +747,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { if (name == null) throwBacktrack(((ASTNode) firstExpression).getOffset(), ((ASTNode) firstExpression).getLength() + arrow.getLength()); - result = nodeFactory.newFieldReference(name, firstExpression); + result = getNodeFactory().newFieldReference(name, firstExpression); result.setIsPointerDereference(true); ((ASTNode) result).setOffsetAndLength( ((ASTNode) firstExpression).getOffset(), @@ -765,12 +768,12 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { // TO DO: we need more literals... case IToken.tINTEGER: t = consume(); - literalExpression = nodeFactory.newLiteralExpression(IASTLiteralExpression.lk_integer_constant, t.getImage()); + literalExpression = getNodeFactory().newLiteralExpression(IASTLiteralExpression.lk_integer_constant, t.getImage()); ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset()); return literalExpression; case IToken.tFLOATINGPT: t = consume(); - literalExpression = nodeFactory.newLiteralExpression(IASTLiteralExpression.lk_float_constant, t.getImage()); + literalExpression = getNodeFactory().newLiteralExpression(IASTLiteralExpression.lk_float_constant, t.getImage()); ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset()); return literalExpression; case IToken.tSTRING: @@ -778,7 +781,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { case IToken.tUTF16STRING: case IToken.tUTF32STRING: t = consume(); - literalExpression = nodeFactory.newLiteralExpression(IASTLiteralExpression.lk_string_literal, t.getImage()); + literalExpression = getNodeFactory().newLiteralExpression(IASTLiteralExpression.lk_string_literal, t.getImage()); ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset()); return literalExpression; case IToken.tCHAR: @@ -786,7 +789,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { case IToken.tUTF16CHAR: case IToken.tUTF32CHAR: t = consume(); - literalExpression = nodeFactory.newLiteralExpression(IASTLiteralExpression.lk_char_constant, t.getImage()); + literalExpression = getNodeFactory().newLiteralExpression(IASTLiteralExpression.lk_char_constant, t.getImage()); ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getLength()); return literalExpression; case IToken.tLPAREN: @@ -810,7 +813,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { case IToken.tEOC: int startingOffset = LA(1).getOffset(); IASTName name = identifier(); - IASTIdExpression idExpression = nodeFactory.newIdExpression(name); + IASTIdExpression idExpression = getNodeFactory().newIdExpression(name); ((ASTNode) idExpression).setOffsetAndLength((ASTNode) name); return idExpression; default: @@ -844,7 +847,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { fPreventKnrCheck--; } - IASTTypeId result = nodeFactory.newTypeId(declSpecifier, declarator); + IASTTypeId result = getNodeFactory().newTypeId(declSpecifier, declarator); setRange(result, offset, figureEndOffset(declSpecifier, declarator)); return result; } @@ -896,7 +899,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { break; } - ICASTPointer po = nodeFactory.newPointer(); + ICASTPointer po = getNodeFactory().newPointer(); ((ASTNode) po).setOffsetAndLength(startOffset, last.getEndOffset() - startOffset); po.setConst(isConst); po.setVolatile(isVolatile); @@ -1229,7 +1232,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { private ICASTTypedefNameSpecifier buildNamedTypeSpecifier(IASTName name, int storageClass, int options, int offset, int endOffset) { - ICASTTypedefNameSpecifier declSpec = nodeFactory.newTypedefNameSpecifier(name); + ICASTTypedefNameSpecifier declSpec = getNodeFactory().newTypedefNameSpecifier(name); configureDeclSpec(declSpec, storageClass, options); declSpec.setRestrict((options & RESTRICT) != 0); ((ASTNode) declSpec).setOffsetAndLength(offset, endOffset - offset); @@ -1238,7 +1241,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { private ICASTSimpleDeclSpecifier buildSimpleDeclSpec(int storageClass, int simpleType, int options, int isLong, IASTExpression typeofExpression, int offset, int endOffset) { - ICASTSimpleDeclSpecifier declSpec= nodeFactory.newSimpleDeclSpecifier(); + ICASTSimpleDeclSpecifier declSpec= getNodeFactory().newSimpleDeclSpecifier(); configureDeclSpec(declSpec, storageClass, options); declSpec.setType(simpleType); @@ -1313,9 +1316,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } if (name == null) { - name= nodeFactory.newName(); + name= getNodeFactory().newName(); } - ICASTCompositeTypeSpecifier result = nodeFactory.newCompositeTypeSpecifier(classKind, name); + ICASTCompositeTypeSpecifier result = getNodeFactory().newCompositeTypeSpecifier(classKind, name); declarationListInBraces(result, offset, DeclarationOptions.C_MEMBER); return result; } @@ -1344,7 +1347,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { __attribute_decl_seq(supportAttributeSpecifiers, supportDeclspecSpecifiers); IASTName name = identifier(); - IASTElaboratedTypeSpecifier result = nodeFactory.newElaboratedTypeSpecifier(eck, name); + IASTElaboratedTypeSpecifier result = getNodeFactory().newElaboratedTypeSpecifier(eck, name); ((ASTNode) result).setOffsetAndLength(t.getOffset(), calculateEndOffset(name) - t.getOffset()); return result; } @@ -1405,7 +1408,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { if (option.fAllowAbstract) { final IToken mark= mark(); try { - cand1= declarator(pointerOps, attributes, nodeFactory.newName(), null, + cand1= declarator(pointerOps, attributes, getNodeFactory().newName(), null, startingOffset, endOffset, option); if (option.fRequireAbstract) return cand1; @@ -1449,7 +1452,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { if (!option.fAllowAbstract) { throwBacktrack(LA(1)); } - return declarator(pointerOps, attributes, nodeFactory.newName(), null, startingOffset, + return declarator(pointerOps, attributes, getNodeFactory().newName(), null, startingOffset, endOffset, option); } @@ -1503,7 +1506,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } if (result == null) { - result= nodeFactory.newDeclarator(null); + result= getNodeFactory().newDeclarator(null); setDeclaratorID(result, declaratorName, nestedDeclarator); } else { endOffset= calculateEndOffset(result); @@ -1541,7 +1544,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { private void setDeclaratorID(IASTDeclarator declarator, IASTName declaratorName, IASTDeclarator nestedDeclarator) { if (nestedDeclarator != null) { declarator.setNestedDeclarator(nestedDeclarator); - declarator.setName(nodeFactory.newName()); + declarator.setName(getNodeFactory().newName()); } else { declarator.setName(declaratorName); } @@ -1605,7 +1608,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } parmDeclarations = ArrayUtil.removeNulls( IASTDeclaration.class, parmDeclarations ); - ICASTKnRFunctionDeclarator functionDecltor = nodeFactory.newKnRFunctionDeclarator(parmNames, parmDeclarations); + ICASTKnRFunctionDeclarator functionDecltor = getNodeFactory().newKnRFunctionDeclarator(parmNames, parmDeclarations); ((ASTNode) functionDecltor).setOffsetAndLength(startOffset, endOffset-startOffset); return functionDecltor; } @@ -1646,7 +1649,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { break; } } - IASTStandardFunctionDeclarator fc = nodeFactory.newFunctionDeclarator(null); + IASTStandardFunctionDeclarator fc = getNodeFactory().newFunctionDeclarator(null); fc.setVarArgs(encounteredVarArgs); if (parameters != null) { for (IASTParameterDeclaration pd : parameters) { @@ -1689,7 +1692,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { throwBacktrack(LA(1)); final int endOffset = calculateEndOffset(arrayMods.get(arrayMods.size() - 1)); - final IASTArrayDeclarator d = nodeFactory.newArrayDeclarator(null); + final IASTArrayDeclarator d = getNodeFactory().newArrayDeclarator(null); for (IASTArrayModifier m : arrayMods) { d.addArrayModifier(m); } @@ -1708,7 +1711,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { final IASTExpression bitField = constantExpression(); final int endOffset = calculateEndOffset(bitField); - IASTFieldDeclarator d = nodeFactory.newFieldDeclarator(null, bitField); + IASTFieldDeclarator d = getNodeFactory().newFieldDeclarator(null, bitField); d.setBitFieldSize(bitField); ((ASTNode) d).setOffsetAndLength(start, endOffset-start); @@ -1723,13 +1726,13 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { switch (t.getType()) { case IToken.tIDENTIFIER: consume(); - n = nodeFactory.newName(t.getCharImage()); + n = getNodeFactory().newName(t.getCharImage()); break; case IToken.tCOMPLETION: case IToken.tEOC: consume(); - n = nodeFactory.newName(t.getCharImage()); + n = getNodeFactory().newName(t.getCharImage()); createCompletionNode(t).addName(n); return n; @@ -1799,7 +1802,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { throw backtrack; } - ICASTArrayModifier arrayMod = nodeFactory.newArrayModifier(exp); + ICASTArrayModifier arrayMod = getNodeFactory().newArrayModifier(exp); arrayMod.setStatic(isStatic); arrayMod.setConst(isConst); arrayMod.setVolatile(isVolatile); @@ -1838,10 +1841,10 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } final int length = figureEndOffset(declSpec, declarator) - startingOffset; - IASTParameterDeclaration result = nodeFactory.newParameterDeclaration(declSpec, declarator); + IASTParameterDeclaration result = getNodeFactory().newParameterDeclaration(declSpec, declarator); ((ASTNode) result).setOffsetAndLength(startingOffset, length); if (altDeclarator != null && altDeclSpec != null) { - IASTParameterDeclaration alt = nodeFactory.newParameterDeclaration(altDeclSpec, altDeclarator); + IASTParameterDeclaration alt = getNodeFactory().newParameterDeclaration(altDeclSpec, altDeclarator); ((ASTNode) alt).setOffsetAndLength(startingOffset, length); // order is important, prefer variant with declspec over the one without result= new CASTAmbiguousParameterDeclaration(result, alt); @@ -1989,7 +1992,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { private IASTProblemDeclaration createKnRCProblemDeclaration(int offset, int length) throws EndOfFileException { IASTProblem p = createProblem(IProblem.SYNTAX_ERROR, offset, length); - IASTProblemDeclaration pd = nodeFactory.newProblemDeclaration(p); + IASTProblemDeclaration pd = getNodeFactory().newProblemDeclaration(p); ((ASTNode) pd).setOffsetAndLength((ASTNode) p); // consume until LBRACE is found (to leave off at the function body and @@ -2043,7 +2046,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { IASTExpression condition= condition(true); if (LT(1) == IToken.tEOC) { // Completing in the condition - IASTIfStatement new_if = nodeFactory.newIfStatement(condition, null, null); + IASTIfStatement new_if = getNodeFactory().newIfStatement(condition, null, null); if (if_statement != null) { if_statement.setElseClause(new_if); @@ -2053,7 +2056,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { consume(IToken.tRPAREN); IASTStatement thenClause = statement(); - IASTIfStatement new_if_statement = nodeFactory.newIfStatement(null, null, null); + IASTIfStatement new_if_statement = getNodeFactory().newIfStatement(null, null, null); ((ASTNode) new_if_statement).setOffset(so); if( condition != null ) // shouldn't be possible but failure in condition() makes it so { @@ -2131,7 +2134,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { } IASTStatement switch_body = parseSwitchBody(); - IASTSwitchStatement switch_statement = nodeFactory.newSwitchStatement(switch_condition, switch_body); + IASTSwitchStatement switch_statement = getNodeFactory().newSwitchStatement(switch_condition, switch_body); ((ASTNode) switch_statement).setOffsetAndLength(startOffset, (switch_body != null ? calculateEndOffset(switch_body) : LA(1).getEndOffset()) - startOffset); return switch_statement; @@ -2177,7 +2180,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser { throw backtrack; } - IASTForStatement for_statement = nodeFactory.newForStatement(init, for_condition, iterationExpression, null); + IASTForStatement for_statement = getNodeFactory().newForStatement(init, for_condition, iterationExpression, null); if (LT(1) != IToken.tEOC) { IASTStatement for_body = statement(); ((ASTNode) for_statement).setOffsetAndLength(startOffset, calculateEndOffset(for_body) - startOffset); 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 ec1c08b61b3..7cb113fcf2f 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 @@ -178,6 +178,7 @@ import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor; * * Contributors: * John Camelon (IBM Rational Software) - Initial API and implementation + * Alexander Nyßen (itemis AG) - bug 475908 *******************************************************************************/ /** @@ -205,7 +206,6 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { private char[] currentClassName; private char[] additionalNumericalSuffixes; - private final ICPPNodeFactory nodeFactory; private TemplateIdStrategy fTemplateParameterListStrategy; private Map fContextSensitiveTokens; @@ -234,12 +234,16 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { supportAutoTypeSpecifier= true; supportUserDefinedLiterals= config.supportUserDefinedLiterals(); this.index= index; - this.nodeFactory = CPPNodeFactory.getDefault(); scanner.setSplitShiftROperator(true); fContextSensitiveTokens = createContextSensitiveTokenMap(config); additionalNumericalSuffixes = scanner.getAdditionalNumericLiteralSuffixes(); } + @Override + protected ICPPNodeFactory getNodeFactory() { + return (ICPPNodeFactory) super.getNodeFactory(); + } + private Map createContextSensitiveTokenMap( ICPPParserExtensionConfiguration config) { Map result = new HashMap(); @@ -301,7 +305,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { int endOffset= offset; if (LT(1) == IToken.tCOLONCOLON) { endOffset= consume().getEndOffset(); - qname= nodeFactory.newQualifiedName(null); + qname= getNodeFactory().newQualifiedName(null); qname.setFullyQualified(true); } @@ -344,7 +348,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (!haveName || destructorOffset >= 0 || keywordTemplate) { throwBacktrack(LA(1)); } - nameSpec= nodeFactory.newName(CharArrayUtils.EMPTY); + nameSpec= getNodeFactory().newName(CharArrayUtils.EMPTY); if (qname != null) { addNameSpecifier(qname, nameSpec); } @@ -387,7 +391,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { endOffset= consume().getEndOffset(); // :: if (qname == null) { - qname= nodeFactory.newQualifiedName(null); + qname= getNodeFactory().newQualifiedName(null); addNameSpecifier(qname, nameSpec); } } @@ -429,7 +433,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { private IASTName buildName(int destructorOffset, IToken nt) { IASTName name; if (destructorOffset < 0) { - name= nodeFactory.newName(nt.getCharImage()); + name= getNodeFactory().newName(nt.getCharImage()); setRange(name, nt.getOffset(), nt.getEndOffset()); } else { char[] nchars= nt.getCharImage(); @@ -437,7 +441,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { char[] image = new char[len+1]; image[0]= '~'; System.arraycopy(nchars, 0, image, 1, len); - name= nodeFactory.newName(image); + name= getNodeFactory().newName(image); setRange(name, destructorOffset, nt.getEndOffset()); } switch (nt.getType()) { @@ -468,7 +472,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } private ICPPASTTemplateId buildTemplateID(IASTName templateName, int endOffset, List args) { - ICPPASTTemplateId result = nodeFactory.newTemplateId(templateName); + ICPPASTTemplateId result = getNodeFactory().newTemplateId(templateName); setRange(result, ((ASTNode) templateName).getOffset(), endOffset); for (IASTNode n : args) { if (n instanceof IASTTypeId) { @@ -490,7 +494,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { consume(IToken.tLPAREN); ICPPASTExpression decltypeExpression = (ICPPASTExpression) expression(); int end = consume(IToken.tRPAREN).getEndOffset(); - ICPPASTDecltypeSpecifier decltypeSpec = nodeFactory.newDecltypeSpecifier(decltypeExpression); + ICPPASTDecltypeSpecifier decltypeSpec = getNodeFactory().newDecltypeSpecifier(decltypeExpression); setRange(decltypeSpec, start, end); return decltypeSpec; } @@ -742,7 +746,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { namedTypeSpec = (IASTNamedTypeSpecifier) declSpec; name = namedTypeSpec.getName(); if (name.contains(typeId)) { - idExpression = setRange(nodeFactory.newIdExpression(name), name); + idExpression = setRange(getNodeFactory().newIdExpression(name), name); } } @@ -809,7 +813,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } private IASTExpression addPackExpansion(IASTExpression expr, IToken ellipsis) { - IASTExpression result= nodeFactory.newPackExpansionExpression(expr); + IASTExpression result= getNodeFactory().newPackExpansionExpression(expr); return setRange(result, expr, ellipsis.getEndOffset()); } @@ -866,7 +870,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { operatorName = CharArrayUtils.concat(operatorName, strOp.getCharImage()); operatorName = CharArrayUtils.concat(operatorName, ident.getCharImage()); - IASTName name = nodeFactory.newOperatorName(operatorName); + IASTName name = getNodeFactory().newOperatorName(operatorName); setRange(name, firstToken.getOffset(), ident.getEndOffset()); return name; } @@ -880,7 +884,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } if (op != null) { - IASTName name= nodeFactory.newOperatorName(op.toCharArray()); + IASTName name= getNodeFactory().newOperatorName(op.toCharArray()); setRange(name, firstToken.getOffset(), endOffset); return name; } @@ -888,7 +892,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // must be a conversion function typeId= typeId(DeclarationOptions.TYPEID_CONVERSION); - IASTName name = nodeFactory.newConversionName(typeId); + IASTName name = getNodeFactory().newConversionName(typeId); setRange(name, firstToken.getOffset(), calculateEndOffset(typeId)); return name; } @@ -1216,7 +1220,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { @Override protected IASTExpression buildBinaryExpression(int operator, IASTExpression expr1, IASTInitializerClause expr2, int lastOffset) { - IASTBinaryExpression result = nodeFactory.newBinaryExpression(operator, expr1, expr2); + IASTBinaryExpression result = getNodeFactory().newBinaryExpression(operator, expr1, expr2); int o = ((ASTNode) expr1).getOffset(); ((ASTNode) result).setOffsetAndLength(o, lastOffset - o); return result; @@ -1256,7 +1260,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { vectored = true; } IASTExpression castExpression = castExpression(CastExprCtx.eNotInBExpr, null); - ICPPASTDeleteExpression deleteExpression = nodeFactory.newDeleteExpression(castExpression); + ICPPASTDeleteExpression deleteExpression = getNodeFactory().newDeleteExpression(castExpression); ((ASTNode) deleteExpression).setOffsetAndLength(startingOffset, calculateEndOffset(castExpression) - startingOffset); deleteExpression.setIsGlobal(global); deleteExpression.setIsVectored(vectored); @@ -1395,7 +1399,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (plcmt != null && !plcmt.isEmpty()) { plcmtArray= plcmt.toArray(new IASTInitializerClause[plcmt.size()]); } - ICPPASTNewExpression result = nodeFactory.newNewExpression(plcmtArray, init, typeid); + ICPPASTNewExpression result = getNodeFactory().newNewExpression(plcmtArray, init, typeid); result.setIsGlobal(isGlobal); result.setIsNewTypeId(isNewTypeId); ((ASTNode) result).setOffsetAndLength(offset, endOffset - offset); @@ -1494,9 +1498,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { int endOffset= consumeOrEOC(IToken.tRPAREN).getEndOffset(); IASTExpression result; if (isBinary) { - result= nodeFactory.newBinaryTypeIdExpression(getBinaryTypeTraitOperator(first), typeId, secondTypeId); + result= getNodeFactory().newBinaryTypeIdExpression(getBinaryTypeTraitOperator(first), typeId, secondTypeId); } else { - result= nodeFactory.newTypeIdExpression(getUnaryTypeTraitOperator(first), typeId); + result= getNodeFactory().newTypeIdExpression(getUnaryTypeTraitOperator(first), typeId); } return setRange(result, first.getOffset(), endOffset); } @@ -1622,7 +1626,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { offset= consume().getOffset(); // noexcept consume(IToken.tLPAREN); // ( firstExpression= expression(); - firstExpression= nodeFactory.newUnaryExpression(IASTUnaryExpression.op_noexcept, firstExpression); + firstExpression= getNodeFactory().newUnaryExpression(IASTUnaryExpression.op_noexcept, firstExpression); final int endOffset = consume(IToken.tRPAREN).getEndOffset(); // ) setRange(firstExpression, offset, endOffset); break; @@ -1639,7 +1643,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { consume(IToken.tRPAREN); if (LT(1) == IToken.tLBRACE) { IASTInitializer i = bracedInitList(false); - firstExpression= nodeFactory.newTypeIdInitializerExpression(t, i); + firstExpression= getNodeFactory().newTypeIdInitializerExpression(t, i); setRange(firstExpression, offset, calculateEndOffset(i)); break; } @@ -1687,7 +1691,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { firstExpression = primaryExpression(ctx, strat); if (firstExpression instanceof IASTIdExpression && LT(1) == IToken.tLBRACE) { IASTName name = ((IASTIdExpression) firstExpression).getName(); - ICPPASTDeclSpecifier declSpec= nodeFactory.newTypedefNameSpecifier(name); + ICPPASTDeclSpecifier declSpec= getNodeFactory().newTypedefNameSpecifier(name); firstExpression = simpleTypeConstructorExpression(setRange(declSpec, name)); } break; @@ -1706,7 +1710,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { expression= expression(); } int endOffset= consumeOrEOC(IToken.tRBRACKET).getEndOffset(); - IASTArraySubscriptExpression s = nodeFactory.newArraySubscriptExpression(firstExpression, expression); + IASTArraySubscriptExpression s = getNodeFactory().newArraySubscriptExpression(firstExpression, expression); firstExpression= setRange(s, firstExpression, endOffset); break; case IToken.tLPAREN: @@ -1722,7 +1726,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } endOffset = consumeOrEOC(IToken.tRPAREN).getEndOffset(); - IASTFunctionCallExpression fce = nodeFactory.newFunctionCallExpression(firstExpression, initArray); + IASTFunctionCallExpression fce = getNodeFactory().newFunctionCallExpression(firstExpression, initArray); firstExpression= setRange(fce, firstExpression, endOffset); break; @@ -1751,7 +1755,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { throwBacktrack(((ASTNode) firstExpression).getOffset(), ((ASTNode) firstExpression).getLength() + dot.getLength()); - ICPPASTFieldReference fieldReference = nodeFactory.newFieldReference(name, firstExpression); + ICPPASTFieldReference fieldReference = getNodeFactory().newFieldReference(name, firstExpression); fieldReference.setIsPointerDereference(false); fieldReference.setIsTemplate(isTemplate); ((ASTNode) fieldReference).setOffsetAndLength( @@ -1774,7 +1778,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { throwBacktrack(((ASTNode) firstExpression).getOffset(), ((ASTNode) firstExpression).getLength() + arrow.getLength()); - fieldReference = nodeFactory.newFieldReference(name, firstExpression); + fieldReference = getNodeFactory().newFieldReference(name, firstExpression); fieldReference.setIsPointerDereference(true); fieldReference.setIsTemplate(isTemplate); ((ASTNode) fieldReference).setOffsetAndLength( @@ -1809,7 +1813,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { private IASTExpression simpleTypeConstructorExpression(ICPPASTDeclSpecifier declSpec) throws EndOfFileException, BacktrackException { IASTInitializer initializer = bracedOrCtorStyleInitializer(); - ICPPASTSimpleTypeConstructorExpression result = nodeFactory.newSimpleTypeConstructorExpression( + ICPPASTSimpleTypeConstructorExpression result = getNodeFactory().newSimpleTypeConstructorExpression( declSpec, initializer); return setRange(result, declSpec, calculateEndOffset(initializer)); } @@ -1823,13 +1827,13 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { switch (LT(1)) { case IToken.tINTEGER: t = consume(); - literalExpr = nodeFactory.newLiteralExpression(IASTLiteralExpression.lk_integer_constant, t.getImage()); + literalExpr = getNodeFactory().newLiteralExpression(IASTLiteralExpression.lk_integer_constant, t.getImage()); literalExprWithRange = setRange(literalExpr, t.getOffset(), t.getEndOffset()); ((CPPASTLiteralExpression) literalExpr).calculateSuffix(additionalNumericalSuffixes); break; case IToken.tFLOATINGPT: t = consume(); - literalExpr = nodeFactory.newLiteralExpression(IASTLiteralExpression.lk_float_constant, t.getImage()); + literalExpr = getNodeFactory().newLiteralExpression(IASTLiteralExpression.lk_float_constant, t.getImage()); literalExprWithRange = setRange(literalExpr, t.getOffset(), t.getEndOffset()); ((CPPASTLiteralExpression) literalExpr).calculateSuffix(additionalNumericalSuffixes); break; @@ -1849,7 +1853,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { case IToken.tUTF32CHAR: case IToken.tUSER_DEFINED_CHAR_LITERAL: t = consume(); - literalExpr = nodeFactory.newLiteralExpression( + literalExpr = getNodeFactory().newLiteralExpression( IASTLiteralExpression.lk_char_constant, t.getImage()); literalExprWithRange = setRange(literalExpr, t.getOffset(), t.getEndOffset()); if (supportUserDefinedLiterals) { @@ -1858,20 +1862,20 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { break; case IToken.t_false: t = consume(); - literalExpr = nodeFactory.newLiteralExpression(IASTLiteralExpression.lk_false, t.getImage()); + literalExpr = getNodeFactory().newLiteralExpression(IASTLiteralExpression.lk_false, t.getImage()); return setRange(literalExpr, t.getOffset(), t.getEndOffset()); case IToken.t_true: t = consume(); - literalExpr = nodeFactory.newLiteralExpression(IASTLiteralExpression.lk_true, t.getImage()); + literalExpr = getNodeFactory().newLiteralExpression(IASTLiteralExpression.lk_true, t.getImage()); return setRange(literalExpr, t.getOffset(), t.getEndOffset()); case IToken.t_nullptr: t= consume(); - literalExpr = nodeFactory.newLiteralExpression(IASTLiteralExpression.lk_nullptr, t.getImage()); + literalExpr = getNodeFactory().newLiteralExpression(IASTLiteralExpression.lk_nullptr, t.getImage()); return setRange(literalExpr, t.getOffset(), t.getEndOffset()); case IToken.t_this: t = consume(); - literalExpr = nodeFactory.newLiteralExpression(IASTLiteralExpression.lk_this, t.getImage()); + literalExpr = getNodeFactory().newLiteralExpression(IASTLiteralExpression.lk_this, t.getImage()); return setRange(literalExpr, t.getOffset(), t.getEndOffset()); case IToken.tLPAREN: if (supportStatementsInExpressions && LT(2) == IToken.tLBRACE) { @@ -1901,7 +1905,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // (unless we are invoking code completion at the '::'). if (name.getLookupKey().length == 0 && LT(1) != IToken.tEOC) throwBacktrack(LA(1)); - IASTIdExpression idExpression = nodeFactory.newIdExpression(name); + IASTIdExpression idExpression = getNodeFactory().newIdExpression(name); return setRange(idExpression, name); } case IToken.tLBRACKET: @@ -1943,14 +1947,14 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { throwBacktrack(LA(1)); } IToken t= consume(); - ICPPASTLiteralExpression r= nodeFactory.newLiteralExpression(IASTLiteralExpression.lk_string_literal, t.getImage()); + ICPPASTLiteralExpression r= getNodeFactory().newLiteralExpression(IASTLiteralExpression.lk_string_literal, t.getImage()); return setRange(r, t.getOffset(), t.getEndOffset()); } private IASTExpression lambdaExpression() throws EndOfFileException, BacktrackException { final int offset= LA().getOffset(); - ICPPASTLambdaExpression lambdaExpr= nodeFactory.newLambdaExpression(); + ICPPASTLambdaExpression lambdaExpr= getNodeFactory().newLambdaExpression(); // Lambda introducer consume(IToken.tLBRACKET); @@ -2002,7 +2006,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { private ICPPASTCapture capture() throws EndOfFileException, BacktrackException { final int offset= LA().getOffset(); - final ICPPASTCapture result = nodeFactory.newCapture(); + final ICPPASTCapture result = getNodeFactory().newCapture(); switch (LT(1)) { case IToken.t_this: @@ -2099,7 +2103,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { default: throw backtrack; } - ICPPASTUsingDirective astUD = nodeFactory.newUsingDirective(name); + ICPPASTUsingDirective astUD = getNodeFactory().newUsingDirective(name); addAttributeSpecifiers(attributes, astUD); @@ -2138,7 +2142,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } int endOffset = consume().getEndOffset(); - ICPPASTAliasDeclaration aliasDeclaration = nodeFactory.newAliasDeclaration(aliasName, aliasedType); + ICPPASTAliasDeclaration aliasDeclaration = getNodeFactory().newAliasDeclaration(aliasName, aliasedType); addAttributeSpecifiers(attributes, aliasDeclaration); setRange(aliasDeclaration, offset, endOffset); return aliasDeclaration; @@ -2162,7 +2166,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { throw backtrack; } - ICPPASTUsingDeclaration result = nodeFactory.newUsingDeclaration(name); + ICPPASTUsingDeclaration result = getNodeFactory().newUsingDeclaration(name); ((ASTNode) result).setOffsetAndLength(offset, end - offset); result.setIsTypename(typeName); return result; @@ -2184,7 +2188,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { consume(IToken.tRPAREN); endOffset= consume(IToken.tSEMI).getEndOffset(); } - ICPPASTStaticAssertDeclaration assertion = nodeFactory.newStaticAssertion(e, lit); + ICPPASTStaticAssertDeclaration assertion = getNodeFactory().newStaticAssertion(e, lit); return setRange(assertion, offset, endOffset); } @@ -2199,7 +2203,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { protected ICPPASTLinkageSpecification linkageSpecification() throws EndOfFileException, BacktrackException { int offset= consume().getOffset(); // t_extern String spec = consume().getImage(); // tString - ICPPASTLinkageSpecification linkage = nodeFactory.newLinkageSpecification(spec); + ICPPASTLinkageSpecification linkage = getNodeFactory().newLinkageSpecification(spec); if (LT(1) == IToken.tLBRACE) { declarationListInBraces(linkage, offset, DeclarationOptions.GLOBAL); @@ -2252,7 +2256,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (LT(1) != IToken.tLT) { // explicit-instantiation IASTDeclaration d = declaration(option); - ICPPASTExplicitTemplateInstantiation ti= nodeFactory.newExplicitTemplateInstantiation(d); + ICPPASTExplicitTemplateInstantiation ti= getNodeFactory().newExplicitTemplateInstantiation(d); ti.setModifier(explicitInstMod); setRange(ti, offset, calculateEndOffset(d)); return ti; @@ -2267,7 +2271,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // explicit-specialization consume(); IASTDeclaration d = declaration(option); - ICPPASTTemplateSpecialization templateSpecialization = nodeFactory.newTemplateSpecialization(d); + ICPPASTTemplateSpecialization templateSpecialization = getNodeFactory().newTemplateSpecialization(d); setRange(templateSpecialization, offset, calculateEndOffset(d)); return templateSpecialization; } @@ -2277,7 +2281,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { consume(IToken.tGT, IToken.tGT_in_SHIFTR); } IASTDeclaration d = declaration(option); - ICPPASTTemplateDeclaration templateDecl = nodeFactory.newTemplateDeclaration(d); + ICPPASTTemplateDeclaration templateDecl = getNodeFactory().newTemplateDeclaration(d); setRange(templateDecl, offset, calculateEndOffset(d)); templateDecl.setExported(exported); for (int i = 0; i < parms.size(); ++i) { @@ -2363,7 +2367,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { identifierName = identifier(); endOffset = calculateEndOffset(identifierName); } else { - identifierName = nodeFactory.newName(); + identifierName = getNodeFactory().newName(); setRange(identifierName, endOffset, endOffset); } if (LT(1) == IToken.tASSIGN) { // optional = type-id @@ -2380,7 +2384,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { case IToken.tEOC: case IToken.tGT_in_SHIFTR: case IToken.tCOMMA: - ICPPASTSimpleTypeTemplateParameter tpar = nodeFactory.newSimpleTypeTemplateParameter(type, identifierName, defaultValue); + ICPPASTSimpleTypeTemplateParameter tpar = getNodeFactory().newSimpleTypeTemplateParameter(type, identifierName, defaultValue); tpar.setIsParameterPack(parameterPack); setRange(tpar, start.getOffset(), endOffset); return tpar; @@ -2417,10 +2421,10 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { endOffset = calculateEndOffset(defaultValue); } } else { - identifierName = nodeFactory.newName(); + identifierName = getNodeFactory().newName(); } - ICPPASTTemplatedTypeTemplateParameter tpar = nodeFactory.newTemplatedTypeTemplateParameter(identifierName, defaultValue); + ICPPASTTemplatedTypeTemplateParameter tpar = getNodeFactory().newTemplatedTypeTemplateParameter(identifierName, defaultValue); tpar.setIsParameterPack(parameterPack); setRange(tpar, start.getOffset(), endOffset); @@ -2480,8 +2484,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { break; case IToken.tSEMI: IToken t= consume(); - IASTSimpleDeclSpecifier declspec= nodeFactory.newSimpleDeclSpecifier(); - IASTSimpleDeclaration decl= nodeFactory.newSimpleDeclaration(declspec); + IASTSimpleDeclSpecifier declspec= getNodeFactory().newSimpleDeclSpecifier(); + IASTSimpleDeclaration decl= getNodeFactory().newSimpleDeclaration(declspec); ((ASTNode) declspec).setOffsetAndLength(t.getOffset(), 0); ((ASTNode) decl).setOffsetAndLength(t.getOffset(), t.getLength()); return decl; @@ -2492,7 +2496,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { t= consume(); int key= t.getType(); int endOffset= consume(IToken.tCOLON).getEndOffset(); - ICPPASTVisibilityLabel label = nodeFactory.newVisibilityLabel(token2Visibility(key)); + ICPPASTVisibilityLabel label = getNodeFactory().newVisibilityLabel(token2Visibility(key)); setRange(label, t.getOffset(), endOffset); return label; } @@ -2541,14 +2545,14 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { name = identifier(); endOffset= calculateEndOffset(name); } else { - name = nodeFactory.newName(); + name = getNodeFactory().newName(); } // bug 195701, gcc 4.2 allows visibility attribute for namespaces. List attributeSpecifiers = __attribute_decl_seq(true, false); if (LT(1) == IToken.tLBRACE) { - ICPPASTNamespaceDefinition ns = nodeFactory.newNamespaceDefinition(name); + ICPPASTNamespaceDefinition ns = getNodeFactory().newNamespaceDefinition(name); ns.setIsInline(isInline); declarationListInBraces(ns, offset, DeclarationOptions.GLOBAL); addAttributeSpecifiers(attributeSpecifiers, ns); @@ -2565,7 +2569,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IASTName qualifiedName= qualifiedName(); endOffset = consume(IToken.tSEMI).getEndOffset(); - ICPPASTNamespaceAlias alias = nodeFactory.newNamespaceAlias(name, qualifiedName); + ICPPASTNamespaceAlias alias = getNodeFactory().newNamespaceAlias(name, qualifiedName); ((ASTNode) alias).setOffsetAndLength(offset, endOffset - offset); return alias; } @@ -2582,7 +2586,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { specifiers = new ArrayList(); int offset = consumeOrEOC(IToken.tLBRACKET).getOffset(); consumeOrEOC(IToken.tLBRACKET); - ICPPASTAttributeSpecifier attributeSpecifier = nodeFactory.newAttributeSpecifier(); + ICPPASTAttributeSpecifier attributeSpecifier = getNodeFactory().newAttributeSpecifier(); while (LT(1) != IToken.tRBRACKET) { if (LT(1) == IToken.tCOMMA) consume(); @@ -2629,7 +2633,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } char[] attributeName = nameToken.getCharImage(); char[] scopeName = scopeToken != null ? scopeToken.getCharImage() : null; - ICPPASTAttribute result = nodeFactory.newAttribute(attributeName, scopeName, + ICPPASTAttribute result = getNodeFactory().newAttribute(attributeName, scopeName, argumentClause, packExpansion); setRange(result, nameToken.getOffset(), endOffset); return result; @@ -2678,7 +2682,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } catch (BacktrackException e) { IASTNode node= e.getNodeBeforeProblem(); if (node instanceof IASTDeclSpecifier && isLegalWithoutDtor((IASTDeclSpecifier) node)) { - IASTSimpleDeclaration d= nodeFactory.newSimpleDeclaration((IASTDeclSpecifier) node); + IASTSimpleDeclaration d= getNodeFactory().newSimpleDeclaration((IASTDeclSpecifier) node); setRange(d, node); throwBacktrack(e.getProblem(), d); } @@ -2765,10 +2769,10 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (isAmbiguous) { // class C { C(T); }; // if T is a type this is a constructor, so // prefer the empty declspec, it shall be used if both variants show no problems - simpleDeclaration= nodeFactory.newSimpleDeclaration(altDeclSpec); + simpleDeclaration= getNodeFactory().newSimpleDeclaration(altDeclSpec); simpleDeclaration.addDeclarator(altDtor); } else { - simpleDeclaration= nodeFactory.newSimpleDeclaration(declSpec); + simpleDeclaration= getNodeFactory().newSimpleDeclaration(declSpec); for (IASTDeclarator declarator : declarators) { simpleDeclaration.addDeclarator(declarator); } @@ -2798,9 +2802,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { ICPPASTFunctionDefinition fdef; if (LT(1) == IToken.t_try) { consume(); - fdef= nodeFactory.newFunctionTryBlock(declSpec, (ICPPASTFunctionDeclarator) dtor, null); + fdef= getNodeFactory().newFunctionTryBlock(declSpec, (ICPPASTFunctionDeclarator) dtor, null); } else { - fdef= nodeFactory.newFunctionDefinition(declSpec, (ICPPASTFunctionDeclarator) dtor, null); + fdef= getNodeFactory().newFunctionDefinition(declSpec, (ICPPASTFunctionDeclarator) dtor, null); } if (LT(1) == IToken.tASSIGN) { consume(); @@ -2879,7 +2883,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { init= null; endOffset= calculateEndOffset(name); } - ICPPASTConstructorChainInitializer ctorInitializer = nodeFactory.newConstructorChainInitializer(name, init); + ICPPASTConstructorChainInitializer ctorInitializer = getNodeFactory().newConstructorChainInitializer(name, init); if (LT(1) == IToken.tELLIPSIS) { ctorInitializer.setIsPackExpansion(true); endOffset= consume().getEndOffset(); @@ -2918,7 +2922,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { declarator= addInitializer(lie, DeclarationOptions.PARAMETER); } - final ICPPASTParameterDeclaration parm = nodeFactory.newParameterDeclaration(declSpec, declarator); + final ICPPASTParameterDeclaration parm = getNodeFactory().newParameterDeclaration(declSpec, declarator); final int endOffset = figureEndOffset(declSpec, declarator); setRange(parm, startOffset, endOffset); return parm; @@ -3383,7 +3387,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { private ICPPASTNamedTypeSpecifier buildNamedTypeSpecifier(IASTName name, boolean isTypename, int storageClass, int options, int offset, int endOffset) { - ICPPASTNamedTypeSpecifier declSpec = nodeFactory.newTypedefNameSpecifier(name); + ICPPASTNamedTypeSpecifier declSpec = getNodeFactory().newTypedefNameSpecifier(name); declSpec.setIsTypename(isTypename); configureDeclSpec(declSpec, storageClass, options); ((ASTNode) declSpec).setOffsetAndLength(offset, endOffset - offset); @@ -3392,7 +3396,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { private ICPPASTSimpleDeclSpecifier buildSimpleDeclSpec(int storageClass, int simpleType, int options, int isLong, IASTExpression typeofExpression, int offset, int endOffset) { - ICPPASTSimpleDeclSpecifier declSpec= nodeFactory.newSimpleDeclSpecifier(); + ICPPASTSimpleDeclSpecifier declSpec= getNodeFactory().newSimpleDeclSpecifier(); configureDeclSpec(declSpec, storageClass, options); @@ -3472,10 +3476,10 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (name == null) { if (isOpaque) throwBacktrack(LA(1)); - name= nodeFactory.newName(); + name= getNodeFactory().newName(); } - final ICPPASTEnumerationSpecifier result= nodeFactory.newEnumerationSpecifier(isScoped, name, baseType); + final ICPPASTEnumerationSpecifier result= getNodeFactory().newEnumerationSpecifier(isScoped, name, baseType); result.setIsOpaque(isOpaque); if (lt1 == IToken.tLBRACE) { endOffset= enumBody(result); @@ -3520,7 +3524,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { attributes = CollectionUtils.merge(attributes, attributeSpecifierSeq()); IASTName name = qualifiedName(); - ICPPASTElaboratedTypeSpecifier elaboratedTypeSpecifier = nodeFactory.newElaboratedTypeSpecifier(eck, name); + ICPPASTElaboratedTypeSpecifier elaboratedTypeSpecifier = getNodeFactory().newElaboratedTypeSpecifier(eck, name); addAttributeSpecifiers(attributes, elaboratedTypeSpecifier); return setRange(elaboratedTypeSpecifier, offset, calculateEndOffset(name)); } @@ -3534,7 +3538,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { consume(IToken.tLPAREN); ICPPASTTypeId operand = typeId(options); final int endOffset = consumeOrEOC(IToken.tRPAREN).getEndOffset(); - return setRange(nodeFactory.newTypeTransformationSpecifier(ICPPUnaryTypeTransformation.Operator.underlying_type, operand), offset, endOffset); + return setRange(getNodeFactory().newTypeTransformationSpecifier(ICPPUnaryTypeTransformation.Operator.underlying_type, operand), offset, endOffset); } @Override @@ -3777,13 +3781,13 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { ContextSensitiveTokenType contextSensitiveType = getContextSensitiveType(token); if (contextSensitiveType == ContextSensitiveTokenType.OVERRIDE) { consume(); - ICPPASTVirtSpecifier spec = nodeFactory.newVirtSpecifier( + ICPPASTVirtSpecifier spec = getNodeFactory().newVirtSpecifier( ICPPASTVirtSpecifier.SpecifierKind.Override); setRange(spec, token.getOffset(), token.getOffset() + token.getLength()); typeRelevantDtor.addVirtSpecifier(spec); } else if (contextSensitiveType == ContextSensitiveTokenType.FINAL) { consume(); - ICPPASTVirtSpecifier spec = nodeFactory.newVirtSpecifier( + ICPPASTVirtSpecifier spec = getNodeFactory().newVirtSpecifier( ICPPASTVirtSpecifier.SpecifierKind.Final); setRange(spec, token.getOffset(), token.getOffset() + token.getLength()); typeRelevantDtor.addVirtSpecifier(spec); @@ -3816,7 +3820,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { int offset= consume().getOffset(); final boolean allowSkipping = LT(1) == IToken.tLBRACE && specifiesArray(dtor); IASTInitializerClause initClause = initClause(allowSkipping); - IASTEqualsInitializer initExpr= nodeFactory.newEqualsInitializer(initClause); + IASTEqualsInitializer initExpr= getNodeFactory().newEqualsInitializer(initClause); return setRange(initExpr, offset, calculateEndOffset(initClause)); } @@ -3861,7 +3865,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { initArray = exprList.toArray(new IASTInitializerClause[exprList.size()]); } int endOffset = consumeOrEOC(IToken.tRPAREN).getEndOffset(); - return setRange(nodeFactory.newConstructorInitializer(initArray), offset, endOffset); + return setRange(getNodeFactory().newConstructorInitializer(initArray), offset, endOffset); } private List expressionList() throws EndOfFileException, BacktrackException { @@ -3896,7 +3900,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // { } if (LT(1) == IToken.tRBRACE) { - return setRange(nodeFactory.newInitializerList(), offset, consume().getEndOffset()); + return setRange(getNodeFactory().newInitializerList(), offset, consume().getEndOffset()); } // { initializer-list ,opt } @@ -3905,7 +3909,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { consume(); int endOffset= consumeOrEOC(IToken.tRBRACE).getEndOffset(); - ICPPASTInitializerList result = nodeFactory.newInitializerList(); + ICPPASTInitializerList result = getNodeFactory().newInitializerList(); for (IASTInitializerClause init : initList) { result.addClause(init); } @@ -3937,7 +3941,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { adjustEndOffset(clause, endOffset); } else if (clause instanceof IASTExpression) { // Wrap pack expanded assignment expressions - IASTExpression packExpansion= nodeFactory.newPackExpansionExpression((IASTExpression) clause); + IASTExpression packExpansion= getNodeFactory().newPackExpansionExpression((IASTExpression) clause); clause= setRange(packExpansion, clause, endOffset); } } @@ -3972,7 +3976,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // type-ids have no initializers throwBacktrack(lie.fDeclarator); } - ICPPASTTypeId result = nodeFactory.newTypeId(declSpecifier, declarator); + ICPPASTTypeId result = getNodeFactory().newTypeId(declSpecifier, declarator); setRange(result, offset, figureEndOffset(declSpecifier, declarator)); return result; } @@ -4035,7 +4039,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (option.fAllowAbstract && option.fAllowFunctions) { final IToken mark= mark(); try { - cand1= declarator(pointerOps, hasEllipsis, nodeFactory.newName(), null, + cand1= declarator(pointerOps, hasEllipsis, getNodeFactory().newName(), null, startingOffset, endOffset, strategy, option, attributes); if (option.fRequireAbstract || !option.fAllowNested || hasEllipsis) return cand1; @@ -4049,7 +4053,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // type-ids for new or operator-id: if (!option.fAllowNested || hasEllipsis) { if (option.fAllowAbstract) { - return declarator(pointerOps, hasEllipsis, nodeFactory.newName(), null, + return declarator(pointerOps, hasEllipsis, getNodeFactory().newName(), null, startingOffset, endOffset, strategy, option, attributes); } throwBacktrack(LA(1)); @@ -4063,7 +4067,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { final IASTDeclarator nested= declarator(DtorStrategy.PREFER_FUNCTION, option); endOffset= consume(IToken.tRPAREN).getEndOffset(); - final IASTDeclarator cand2= declarator(pointerOps, hasEllipsis, nodeFactory.newName(), nested, + final IASTDeclarator cand2= declarator(pointerOps, hasEllipsis, getNodeFactory().newName(), nested, startingOffset, endOffset, strategy, option, attributes); if (cand1 == null || cand1End == null) return cand2; @@ -4091,7 +4095,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (!option.fAllowBitField || LT(1) != IToken.tCOLON) throwBacktrack(LA(1)); } - return declarator(pointerOps, hasEllipsis, nodeFactory.newName(), null, startingOffset, + return declarator(pointerOps, hasEllipsis, getNodeFactory().newName(), null, startingOffset, endOffset, strategy, option, attributes); } @@ -4122,7 +4126,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (allowCPPRestrict && LT(1) == IToken.t_restrict) { endToken= consume(); } - ICPPASTReferenceOperator refOp = nodeFactory.newReferenceOperator(lt1 == IToken.tAND); + ICPPASTReferenceOperator refOp = getNodeFactory().newReferenceOperator(lt1 == IToken.tAND); setRange(refOp, offset, endToken.getEndOffset()); attributes = CollectionUtils.merge(attributes, attributeSpecifierSeq()); @@ -4192,9 +4196,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IASTPointer pointer; if (name != null) { - pointer= nodeFactory.newPointerToMember(name); + pointer= getNodeFactory().newPointerToMember(name); } else { - pointer = nodeFactory.newPointer(); + pointer = getNodeFactory().newPointer(); } pointer.setConst(isConst); pointer.setVolatile(isVolatile); @@ -4263,7 +4267,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { __attribute_decl_seq(supportAttributeSpecifiers, supportDeclspecSpecifiers)); if (result == null) { - result= nodeFactory.newDeclarator(null); + result= getNodeFactory().newDeclarator(null); setDeclaratorID(result, hasEllipsis, declaratorName, nestedDeclarator); } else { endOffset= calculateEndOffset(result); @@ -4292,7 +4296,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { private void setDeclaratorID(ICPPASTDeclarator declarator, boolean hasEllipsis, IASTName declaratorName, IASTDeclarator nestedDeclarator) { if (nestedDeclarator != null) { declarator.setNestedDeclarator(nestedDeclarator); - declarator.setName(nodeFactory.newName()); + declarator.setName(getNodeFactory().newName()); } else { declarator.setName(declaratorName); } @@ -4307,7 +4311,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { final int startOffset= last.getOffset(); int endOffset= last.getEndOffset(); - final ICPPASTFunctionDeclarator fc = nodeFactory.newFunctionDeclarator(null); + final ICPPASTFunctionDeclarator fc = getNodeFactory().newFunctionDeclarator(null); ICPPASTParameterDeclaration pd= null; paramLoop: while(true) { switch (LT(1)) { @@ -4417,7 +4421,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { thendoffset = consume().getEndOffset(); } IASTProblem p = createProblem(IProblem.SYNTAX_ERROR, thoffset, thendoffset - thoffset); - IASTProblemTypeId typeIdProblem = nodeFactory.newProblemTypeId(p); + IASTProblemTypeId typeIdProblem = getNodeFactory().newProblemTypeId(p); ((ASTNode) typeIdProblem).setOffsetAndLength(((ASTNode) p)); fc.addExceptionSpecificationTypeId(typeIdProblem); } @@ -4471,7 +4475,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { throwBacktrack(LA(1)); final int endOffset = calculateEndOffset(arrayMods.get(arrayMods.size() - 1)); - final ICPPASTArrayDeclarator d = nodeFactory.newArrayDeclarator(null); + final ICPPASTArrayDeclarator d = getNodeFactory().newArrayDeclarator(null); for (IASTArrayModifier m : arrayMods) { d.addArrayModifier(m); } @@ -4489,7 +4493,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { final IASTExpression bitField = constantExpression(); final int endOffset = calculateEndOffset(bitField); - ICPPASTFieldDeclarator d = nodeFactory.newFieldDeclarator(null, bitField); + ICPPASTFieldDeclarator d = getNodeFactory().newFieldDeclarator(null, bitField); ((ASTNode) d).setOffsetAndLength(start, endOffset-start); return d; } @@ -4534,13 +4538,13 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (LT(1) == IToken.tIDENTIFIER) { name = qualifiedName(); } else { - name = nodeFactory.newName(); + name = getNodeFactory().newName(); } // if __attribute__ or __declspec occurs after struct/union/class identifier and before the { or ; attributes = CollectionUtils.merge(attributes, __attribute_decl_seq(supportAttributeSpecifiers, supportDeclspecSpecifiers)); - ICPPASTCompositeTypeSpecifier astClassSpecifier = nodeFactory.newCompositeTypeSpecifier(classKind, name); + ICPPASTCompositeTypeSpecifier astClassSpecifier = getNodeFactory().newCompositeTypeSpecifier(classKind, name); addAttributeSpecifiers(attributes, astClassSpecifier); // class virt specifier @@ -4624,7 +4628,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { ContextSensitiveTokenType contextSensitiveType = getContextSensitiveType(token); if (contextSensitiveType == ContextSensitiveTokenType.FINAL) { consume(); - ICPPASTClassVirtSpecifier spec = nodeFactory.newClassVirtSpecifier( + ICPPASTClassVirtSpecifier spec = getNodeFactory().newClassVirtSpecifier( ICPPASTClassVirtSpecifier.SpecifierKind.Final); setRange(spec, token.getOffset(), token.getOffset() + token.getLength()); astClassSpecifier.setVirtSpecifier(spec); @@ -4668,7 +4672,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } } nameSpec = nameSpecifier(); - ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier baseSpec = nodeFactory.newBaseSpecifier(nameSpec, visibility, isVirtual); + ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier baseSpec = getNodeFactory().newBaseSpecifier(nameSpec, visibility, isVirtual); setRange(baseSpec, startOffset, calculateEndOffset(nameSpec)); return baseSpec; } @@ -4698,12 +4702,12 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } catch (BacktrackException bte) { failParse(); IASTProblem p = createProblem(bte); - IASTProblemDeclaration pd = nodeFactory.newProblemDeclaration(p); + IASTProblemDeclaration pd = getNodeFactory().newProblemDeclaration(p); ((ASTNode) pd).setOffsetAndLength(((ASTNode) p)); decl = pd; } - ICPPASTCatchHandler handler = nodeFactory.newCatchHandler(decl, null); + ICPPASTCatchHandler handler = getNodeFactory().newCatchHandler(decl, null); if (LT(1) != IToken.tEOC) { IASTStatement compoundStatement = catchBlockCompoundStatement(); @@ -4735,7 +4739,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } final int endOffset = figureEndOffset(declSpec, declarator); - final IASTSimpleDeclaration decl= nodeFactory.newSimpleDeclaration(declSpec); + final IASTSimpleDeclaration decl= getNodeFactory().newSimpleDeclaration(declSpec); if (declarator != null) decl.addDeclarator(declarator); ((ASTNode) decl).setOffsetAndLength(startOffset, endOffset - startOffset); @@ -4747,7 +4751,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { if (mode == ParserMode.QUICK_PARSE || mode == ParserMode.STRUCTURAL_PARSE || !isActiveCode()) { int offset = LA(1).getOffset(); IToken last = skipOverCompoundStatement(true); - IASTCompoundStatement cs = nodeFactory.newCompoundStatement(); + IASTCompoundStatement cs = getNodeFactory().newCompoundStatement(); setRange(cs, offset, last.getEndOffset()); return cs; } else if (mode == ParserMode.COMPLETION_PARSE || mode == ParserMode.SELECTION_PARSE) { @@ -4755,7 +4759,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { return compoundStatement(); int offset = LA(1).getOffset(); IToken last = skipOverCompoundStatement(true); - IASTCompoundStatement cs = nodeFactory.newCompoundStatement(); + IASTCompoundStatement cs = getNodeFactory().newCompoundStatement(); setRange(cs, offset, last.getEndOffset()); return cs; } @@ -4764,7 +4768,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { @Override protected void setupTranslationUnit() throws DOMException { - translationUnit = nodeFactory.newTranslationUnit(scanner); + translationUnit = getNodeFactory().newTranslationUnit(scanner); translationUnit.setIndex(index); // Add built-in names to the scope. @@ -4798,7 +4802,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { default: throw backtrack; } - IASTArrayModifier arrayMod = nodeFactory.newArrayModifier(exp); + IASTArrayModifier arrayMod = getNodeFactory().newArrayModifier(exp); ((ASTNode) arrayMod).setOffsetAndLength(o, l - o); List attributes = attributeSpecifierSeq(); @@ -4886,7 +4890,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IASTStatement tryBlock = compoundStatement(); List catchHandlers = new ArrayList(DEFAULT_CATCH_HANDLER_LIST_SIZE); catchHandlerSequence(catchHandlers); - ICPPASTTryBlockStatement tryStatement = nodeFactory.newTryBlockStatement(tryBlock); + ICPPASTTryBlockStatement tryStatement = getNodeFactory().newTryBlockStatement(tryBlock); ((ASTNode) tryStatement).setOffset(startO); for (int i = 0; i < catchHandlers.size(); ++i) { @@ -4922,9 +4926,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IASTWhileStatement while_statement; if (while_condition instanceof IASTExpression) - while_statement = nodeFactory.newWhileStatement((IASTExpression)while_condition, while_body); + while_statement = getNodeFactory().newWhileStatement((IASTExpression)while_condition, while_body); else - while_statement = nodeFactory.newWhileStatement((IASTDeclaration)while_condition, while_body); + while_statement = getNodeFactory().newWhileStatement((IASTDeclaration)while_condition, while_body); ((ASTNode) while_statement).setOffsetAndLength(startOffset, (while_body != null ? calculateEndOffset(while_body) : LA(1).getEndOffset()) - startOffset); @@ -5005,7 +5009,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IASTNode condition= cppStyleCondition(IToken.tRPAREN); if (LT(1) == IToken.tEOC) { // Completing in the condition - ICPPASTIfStatement new_if = nodeFactory.newIfStatement(); + ICPPASTIfStatement new_if = getNodeFactory().newIfStatement(); if (condition instanceof IASTExpression) new_if.setConditionExpression((IASTExpression) condition); else if (condition instanceof IASTDeclaration) @@ -5019,7 +5023,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { consume(IToken.tRPAREN); IASTStatement thenClause = statement(); - ICPPASTIfStatement new_if_statement = nodeFactory.newIfStatement(); + ICPPASTIfStatement new_if_statement = getNodeFactory().newIfStatement(); ((ASTNode) new_if_statement).setOffset(so); if (condition != null && (condition instanceof IASTExpression || condition instanceof IASTDeclaration)) // shouldn't be possible but failure in condition() makes it so @@ -5107,7 +5111,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { } IASTStatement switch_body = parseSwitchBody(); - ICPPASTSwitchStatement switch_statement = nodeFactory.newSwitchStatement(); + ICPPASTSwitchStatement switch_statement = getNodeFactory().newSwitchStatement(); ((ASTNode) switch_statement).setOffsetAndLength(startOffset, (switch_body != null ? calculateEndOffset(switch_body) : LA(1).getEndOffset()) - startOffset); if (switch_condition instanceof IASTExpression) { @@ -5170,7 +5174,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { init= expression(); } - ICPPASTRangeBasedForStatement result = nodeFactory.newRangeBasedForStatement(); + ICPPASTRangeBasedForStatement result = getNodeFactory().newRangeBasedForStatement(); result.setDeclaration(decl); result.setInitializerClause(init); return result; @@ -5192,7 +5196,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { iterExpr = expression(); } - ICPPASTForStatement result = nodeFactory.newForStatement(); + ICPPASTForStatement result = getNodeFactory().newForStatement(); result.setInitializerStatement(initStmt); if (condition instanceof IASTExpression) { result.setConditionExpression((IASTExpression) condition); @@ -5218,7 +5222,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // Semicolon final int endOffset= consumeOrEOC(IToken.tSEMI).getEndOffset(); - return setRange(nodeFactory.newReturnStatement(expr), offset, endOffset); + return setRange(getNodeFactory().newReturnStatement(expr), offset, endOffset); } @Override