mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-08-04 14:55:41 +02:00
Code Issues Wiki Activity

Bug 475908: Replace nodeFactory field with getter().

Browse source 
Removed (duplicate) nodeFactory field within GNUCSourceParser and
GNUCPPSourceParser with getter() that is provided by
AbstractGNUSourceCodeParser.

Change-Id: If70bcda1a85f934548e680e0fb0d5b4e5cd467d6
Signed-off-by: anyssen <alexander.nyssen@itemis.de>
This commit is contained in:
anyssen 2015-08-28 09:32:58 +02:00 • committed by Sergey Prigogin
parent 12c4de0f27
commit c6b5cf53a4
3 changed files with 176 additions and 164 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/AbstractGNUSourceCodeParser.java
View file

@ -14,6 +14,7 @@
* Thomas Corbat (IFS) * Thomas Corbat (IFS)
* Anders Dahlberg (Ericsson) - bug 84144 * Anders Dahlberg (Ericsson) - bug 84144
* Justin You (Synopsys) - bug 84144 * Justin You (Synopsys) - bug 84144
* Alexander Nyßen (itemis AG) - bug 475908
*******************************************************************************/ *******************************************************************************/
package org.eclipse.cdt.internal.core.dom.parser; package org.eclipse.cdt.internal.core.dom.parser;
@ -256,6 +257,10 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
throw backtrack; throw backtrack;
} }
protected INodeFactory getNodeFactory() {
return nodeFactory;
}
@Override @Override
public IASTCompletionNode getCompletionNode() { public IASTCompletionNode getCompletionNode() {
return completionNode; return completionNode;

107
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/c/GNUCSourceParser.java
View file

@ -13,6 +13,7 @@
* Sergey Prigogin (Google) * Sergey Prigogin (Google)
* Thomas Corbat (IFS) * Thomas Corbat (IFS)
* Anders Dahlberg (Ericsson) - bug 84144 * Anders Dahlberg (Ericsson) - bug 84144
* Alexander Nyßen (itemis AG) - bug 475908
*******************************************************************************/ *******************************************************************************/
package org.eclipse.cdt.internal.core.dom.parser.c; package org.eclipse.cdt.internal.core.dom.parser.c;
@ -113,8 +114,6 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
private int fPreventKnrCheck= 0; private int fPreventKnrCheck= 0;
private final ICNodeFactory nodeFactory;
public GNUCSourceParser(IScanner scanner, ParserMode parserMode, public GNUCSourceParser(IScanner scanner, ParserMode parserMode,
IParserLogService logService, ICParserExtensionConfiguration config) { IParserLogService logService, ICParserExtensionConfiguration config) {
this(scanner, parserMode, logService, config, null); this(scanner, parserMode, logService, config, null);
@ -136,7 +135,11 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
supportExtendedSizeofOperator= config.supportExtendedSizeofOperator(); supportExtendedSizeofOperator= config.supportExtendedSizeofOperator();
supportFunctionStyleAsm= config.supportFunctionStyleAssembler(); supportFunctionStyleAsm= config.supportFunctionStyleAssembler();
this.index= index; this.index= index;
this.nodeFactory = CNodeFactory.getDefault(); }
@Override
protected ICNodeFactory getNodeFactory() {
return (ICNodeFactory) super.getNodeFactory();
} }
@Override @Override
@ -144,7 +147,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
if (LTcatchEOF(1) == IToken.tASSIGN) { if (LTcatchEOF(1) == IToken.tASSIGN) {
final int offset= consume().getOffset(); final int offset= consume().getOffset();
IASTInitializerClause initClause = initClause(); IASTInitializerClause initClause = initClause();
IASTEqualsInitializer result= nodeFactory.newEqualsInitializer(initClause); IASTEqualsInitializer result= getNodeFactory().newEqualsInitializer(initClause);
return setRange(result, offset, calculateEndOffset(initClause)); return setRange(result, offset, calculateEndOffset(initClause));
} }
return null; return null;
@ -157,7 +160,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
// it's an aggregate initializer // it's an aggregate initializer
consume(IToken.tLBRACE); consume(IToken.tLBRACE);
IASTInitializerList result = nodeFactory.newInitializerList(); IASTInitializerList result = getNodeFactory().newInitializerList();
// bug 196468, gcc accepts empty braces. // bug 196468, gcc accepts empty braces.
if (supportGCCStyleDesignators && LT(1) == IToken.tRBRACE) { 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. // in any way add the initializer such that the actual size can be tracked.
result.addClause(clause); result.addClause(clause);
} else { } else {
ICASTDesignatedInitializer desigInitializer = nodeFactory.newDesignatedInitializer((IASTInitializerClause) null); ICASTDesignatedInitializer desigInitializer = getNodeFactory().newDesignatedInitializer((IASTInitializerClause) null);
setRange(desigInitializer, designator.get(0)); setRange(desigInitializer, designator.get(0));
for (ICASTDesignator d : designator) { for (ICASTDesignator d : designator) {
desigInitializer.addDesignator(d); desigInitializer.addDesignator(d);
@ -232,7 +235,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
case IToken.tDOT: case IToken.tDOT:
int offset = consume().getOffset(); int offset = consume().getOffset();
IASTName n = identifier(); IASTName n = identifier();
ICASTFieldDesignator fieldDesignator = nodeFactory.newFieldDesignator(n); ICASTFieldDesignator fieldDesignator = getNodeFactory().newFieldDesignator(n);
setRange(fieldDesignator, offset, calculateEndOffset(n)); setRange(fieldDesignator, offset, calculateEndOffset(n));
if (designatorList == null) if (designatorList == null)
designatorList = new ArrayList<ICASTDesignator>(DEFAULT_DESIGNATOR_LIST_SIZE); designatorList = new ArrayList<ICASTDesignator>(DEFAULT_DESIGNATOR_LIST_SIZE);
@ -246,14 +249,14 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
consume(IToken.tELLIPSIS); consume(IToken.tELLIPSIS);
IASTExpression constantExpression2 = expression(); IASTExpression constantExpression2 = expression();
int lastOffset = consume(IToken.tRBRACKET).getEndOffset(); int lastOffset = consume(IToken.tRBRACKET).getEndOffset();
IGCCASTArrayRangeDesignator designator = nodeFactory.newArrayRangeDesignatorGCC(constantExpression, constantExpression2); IGCCASTArrayRangeDesignator designator = getNodeFactory().newArrayRangeDesignatorGCC(constantExpression, constantExpression2);
setRange(designator, offset, lastOffset); setRange(designator, offset, lastOffset);
if (designatorList == null) if (designatorList == null)
designatorList = new ArrayList<ICASTDesignator>(DEFAULT_DESIGNATOR_LIST_SIZE); designatorList = new ArrayList<ICASTDesignator>(DEFAULT_DESIGNATOR_LIST_SIZE);
designatorList.add(designator); designatorList.add(designator);
} else { } else {
int lastOffset = consume(IToken.tRBRACKET).getEndOffset(); int lastOffset = consume(IToken.tRBRACKET).getEndOffset();
ICASTArrayDesignator designator = nodeFactory.newArrayDesignator(constantExpression); ICASTArrayDesignator designator = getNodeFactory().newArrayDesignator(constantExpression);
setRange(designator, offset, lastOffset); setRange(designator, offset, lastOffset);
if (designatorList == null) if (designatorList == null)
designatorList = new ArrayList<ICASTDesignator>(DEFAULT_DESIGNATOR_LIST_SIZE); designatorList = new ArrayList<ICASTDesignator>(DEFAULT_DESIGNATOR_LIST_SIZE);
@ -272,7 +275,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
int offset= LA(1).getOffset(); int offset= LA(1).getOffset();
IASTName n = identifier(); IASTName n = identifier();
int lastOffset = consume(IToken.tCOLON).getEndOffset(); int lastOffset = consume(IToken.tCOLON).getEndOffset();
ICASTFieldDesignator designator = nodeFactory.newFieldDesignator(n); ICASTFieldDesignator designator = getNodeFactory().newFieldDesignator(n);
setRange(designator, offset, lastOffset); setRange(designator, offset, lastOffset);
return Collections.singletonList(designator); return Collections.singletonList(designator);
} }
@ -287,8 +290,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
return asmDeclaration(); return asmDeclaration();
case IToken.tSEMI: case IToken.tSEMI:
IToken semi= consume(); IToken semi= consume();
IASTDeclSpecifier declspec= nodeFactory.newSimpleDeclSpecifier(); IASTDeclSpecifier declspec= getNodeFactory().newSimpleDeclSpecifier();
IASTSimpleDeclaration decl= nodeFactory.newSimpleDeclaration(declspec); IASTSimpleDeclaration decl= getNodeFactory().newSimpleDeclaration(declspec);
decl.setDeclSpecifier(declspec); decl.setDeclSpecifier(declspec);
((ASTNode) declspec).setOffsetAndLength(semi.getOffset(), 0); ((ASTNode) declspec).setOffsetAndLength(semi.getOffset(), 0);
((ASTNode) decl).setOffsetAndLength(semi.getOffset(), semi.getLength()); ((ASTNode) decl).setOffsetAndLength(semi.getOffset(), semi.getLength());
@ -326,7 +329,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} catch (BacktrackException e) { } catch (BacktrackException e) {
IASTNode node= e.getNodeBeforeProblem(); IASTNode node= e.getNodeBeforeProblem();
if (node instanceof IASTDeclSpecifier) { if (node instanceof IASTDeclSpecifier) {
IASTSimpleDeclaration d= nodeFactory.newSimpleDeclaration((IASTDeclSpecifier) node); IASTSimpleDeclaration d= getNodeFactory().newSimpleDeclaration((IASTDeclSpecifier) node);
setRange(d, node); setRange(d, node);
throwBacktrack(e.getProblem(), d); throwBacktrack(e.getProblem(), d);
} }
@ -395,7 +398,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
// no function body // no function body
IASTSimpleDeclaration simpleDeclaration = nodeFactory.newSimpleDeclaration(declSpec); IASTSimpleDeclaration simpleDeclaration = getNodeFactory().newSimpleDeclaration(declSpec);
for (IASTDeclarator declarator : declarators) for (IASTDeclarator declarator : declarators)
simpleDeclaration.addDeclarator(declarator); simpleDeclaration.addDeclarator(declarator);
@ -422,7 +425,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
if (!(fdtor instanceof IASTFunctionDeclarator)) if (!(fdtor instanceof IASTFunctionDeclarator))
throwBacktrack(firstOffset, LA(1).getEndOffset() - firstOffset); throwBacktrack(firstOffset, LA(1).getEndOffset() - firstOffset);
IASTFunctionDefinition funcDefinition = nodeFactory.newFunctionDefinition(declSpec, (IASTFunctionDeclarator) fdtor, null); IASTFunctionDefinition funcDefinition = getNodeFactory().newFunctionDefinition(declSpec, (IASTFunctionDeclarator) fdtor, null);
try { try {
IASTStatement s= handleFunctionBody(); IASTStatement s= handleFunctionBody();
@ -444,7 +447,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
@Override @Override
protected void setupTranslationUnit() throws DOMException { protected void setupTranslationUnit() throws DOMException {
translationUnit = nodeFactory.newTranslationUnit(scanner); translationUnit = getNodeFactory().newTranslationUnit(scanner);
translationUnit.setIndex(index); translationUnit.setIndex(index);
// add built-in names to the scope // add built-in names to the scope
@ -583,7 +586,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
@Override @Override
protected IASTExpression buildBinaryExpression(int operator, IASTExpression expr1, IASTInitializerClause expr2, int lastOffset) { 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(); int o = ((ASTNode) expr1).getOffset();
((ASTNode) result).setOffsetAndLength(o, lastOffset - o); ((ASTNode) result).setOffsetAndLength(o, lastOffset - o);
return result; return result;
@ -635,7 +638,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
consume(IToken.tRPAREN); consume(IToken.tRPAREN);
if (LT(1) == IToken.tLBRACE) { if (LT(1) == IToken.tLBRACE) {
IASTInitializer i = (IASTInitializerList) initClause(); IASTInitializer i = (IASTInitializerList) initClause();
firstExpression= nodeFactory.newTypeIdInitializerExpression(t, i); firstExpression= getNodeFactory().newTypeIdInitializerExpression(t, i);
setRange(firstExpression, offset, calculateEndOffset(i)); setRange(firstExpression, offset, calculateEndOffset(i));
break; break;
} }
@ -669,7 +672,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
throw backtrack; throw backtrack;
} }
IASTArraySubscriptExpression s = nodeFactory.newArraySubscriptExpression(firstExpression, secondExpression); IASTArraySubscriptExpression s = getNodeFactory().newArraySubscriptExpression(firstExpression, secondExpression);
((ASTNode) s).setOffsetAndLength(((ASTNode) firstExpression).getOffset(), ((ASTNode) s).setOffsetAndLength(((ASTNode) firstExpression).getOffset(),
last - ((ASTNode) firstExpression).getOffset()); last - ((ASTNode) firstExpression).getOffset());
firstExpression = s; firstExpression = s;
@ -708,7 +711,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} else { } else {
args= argList.toArray(new IASTExpression[argList.size()]); args= argList.toArray(new IASTExpression[argList.size()]);
} }
IASTFunctionCallExpression f = nodeFactory.newFunctionCallExpression(firstExpression, args); IASTFunctionCallExpression f = getNodeFactory().newFunctionCallExpression(firstExpression, args);
firstExpression = setRange(f, firstExpression, endOffset); firstExpression = setRange(f, firstExpression, endOffset);
break; break;
case IToken.tINCR: case IToken.tINCR:
@ -730,7 +733,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
if (name == null) if (name == null)
throwBacktrack(((ASTNode) firstExpression).getOffset(), throwBacktrack(((ASTNode) firstExpression).getOffset(),
((ASTNode) firstExpression).getLength() + dot.getLength()); ((ASTNode) firstExpression).getLength() + dot.getLength());
IASTFieldReference result = nodeFactory.newFieldReference(name, firstExpression); IASTFieldReference result = getNodeFactory().newFieldReference(name, firstExpression);
result.setIsPointerDereference(false); result.setIsPointerDereference(false);
((ASTNode) result).setOffsetAndLength( ((ASTNode) result).setOffsetAndLength(
((ASTNode) firstExpression).getOffset(), ((ASTNode) firstExpression).getOffset(),
@ -744,7 +747,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
if (name == null) if (name == null)
throwBacktrack(((ASTNode) firstExpression).getOffset(), throwBacktrack(((ASTNode) firstExpression).getOffset(),
((ASTNode) firstExpression).getLength() + arrow.getLength()); ((ASTNode) firstExpression).getLength() + arrow.getLength());
result = nodeFactory.newFieldReference(name, firstExpression); result = getNodeFactory().newFieldReference(name, firstExpression);
result.setIsPointerDereference(true); result.setIsPointerDereference(true);
((ASTNode) result).setOffsetAndLength( ((ASTNode) result).setOffsetAndLength(
((ASTNode) firstExpression).getOffset(), ((ASTNode) firstExpression).getOffset(),
@ -765,12 +768,12 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
// TO DO: we need more literals... // TO DO: we need more literals...
case IToken.tINTEGER: case IToken.tINTEGER:
t = consume(); 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()); ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset());
return literalExpression; return literalExpression;
case IToken.tFLOATINGPT: case IToken.tFLOATINGPT:
t = consume(); 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()); ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset());
return literalExpression; return literalExpression;
case IToken.tSTRING: case IToken.tSTRING:
@ -778,7 +781,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
case IToken.tUTF16STRING: case IToken.tUTF16STRING:
case IToken.tUTF32STRING: case IToken.tUTF32STRING:
t = consume(); 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()); ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset());
return literalExpression; return literalExpression;
case IToken.tCHAR: case IToken.tCHAR:
@ -786,7 +789,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
case IToken.tUTF16CHAR: case IToken.tUTF16CHAR:
case IToken.tUTF32CHAR: case IToken.tUTF32CHAR:
t = consume(); 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()); ((ASTNode) literalExpression).setOffsetAndLength(t.getOffset(), t.getLength());
return literalExpression; return literalExpression;
case IToken.tLPAREN: case IToken.tLPAREN:
@ -810,7 +813,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
case IToken.tEOC: case IToken.tEOC:
int startingOffset = LA(1).getOffset(); int startingOffset = LA(1).getOffset();
IASTName name = identifier(); IASTName name = identifier();
IASTIdExpression idExpression = nodeFactory.newIdExpression(name); IASTIdExpression idExpression = getNodeFactory().newIdExpression(name);
((ASTNode) idExpression).setOffsetAndLength((ASTNode) name); ((ASTNode) idExpression).setOffsetAndLength((ASTNode) name);
return idExpression; return idExpression;
default: default:
@ -844,7 +847,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
fPreventKnrCheck--; fPreventKnrCheck--;
} }
IASTTypeId result = nodeFactory.newTypeId(declSpecifier, declarator); IASTTypeId result = getNodeFactory().newTypeId(declSpecifier, declarator);
setRange(result, offset, figureEndOffset(declSpecifier, declarator)); setRange(result, offset, figureEndOffset(declSpecifier, declarator));
return result; return result;
} }
@ -896,7 +899,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
break; break;
} }
ICASTPointer po = nodeFactory.newPointer(); ICASTPointer po = getNodeFactory().newPointer();
((ASTNode) po).setOffsetAndLength(startOffset, last.getEndOffset() - startOffset); ((ASTNode) po).setOffsetAndLength(startOffset, last.getEndOffset() - startOffset);
po.setConst(isConst); po.setConst(isConst);
po.setVolatile(isVolatile); po.setVolatile(isVolatile);
@ -1229,7 +1232,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
private ICASTTypedefNameSpecifier buildNamedTypeSpecifier(IASTName name, int storageClass, private ICASTTypedefNameSpecifier buildNamedTypeSpecifier(IASTName name, int storageClass,
int options, int offset, int endOffset) { int options, int offset, int endOffset) {
ICASTTypedefNameSpecifier declSpec = nodeFactory.newTypedefNameSpecifier(name); ICASTTypedefNameSpecifier declSpec = getNodeFactory().newTypedefNameSpecifier(name);
configureDeclSpec(declSpec, storageClass, options); configureDeclSpec(declSpec, storageClass, options);
declSpec.setRestrict((options & RESTRICT) != 0); declSpec.setRestrict((options & RESTRICT) != 0);
((ASTNode) declSpec).setOffsetAndLength(offset, endOffset - offset); ((ASTNode) declSpec).setOffsetAndLength(offset, endOffset - offset);
@ -1238,7 +1241,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
private ICASTSimpleDeclSpecifier buildSimpleDeclSpec(int storageClass, int simpleType, private ICASTSimpleDeclSpecifier buildSimpleDeclSpec(int storageClass, int simpleType,
int options, int isLong, IASTExpression typeofExpression, int offset, int endOffset) { int options, int isLong, IASTExpression typeofExpression, int offset, int endOffset) {
ICASTSimpleDeclSpecifier declSpec= nodeFactory.newSimpleDeclSpecifier(); ICASTSimpleDeclSpecifier declSpec= getNodeFactory().newSimpleDeclSpecifier();
configureDeclSpec(declSpec, storageClass, options); configureDeclSpec(declSpec, storageClass, options);
declSpec.setType(simpleType); declSpec.setType(simpleType);
@ -1313,9 +1316,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
if (name == null) { 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); declarationListInBraces(result, offset, DeclarationOptions.C_MEMBER);
return result; return result;
} }
@ -1344,7 +1347,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
__attribute_decl_seq(supportAttributeSpecifiers, supportDeclspecSpecifiers); __attribute_decl_seq(supportAttributeSpecifiers, supportDeclspecSpecifiers);
IASTName name = identifier(); IASTName name = identifier();
IASTElaboratedTypeSpecifier result = nodeFactory.newElaboratedTypeSpecifier(eck, name); IASTElaboratedTypeSpecifier result = getNodeFactory().newElaboratedTypeSpecifier(eck, name);
((ASTNode) result).setOffsetAndLength(t.getOffset(), calculateEndOffset(name) - t.getOffset()); ((ASTNode) result).setOffsetAndLength(t.getOffset(), calculateEndOffset(name) - t.getOffset());
return result; return result;
} }
@ -1405,7 +1408,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
if (option.fAllowAbstract) { if (option.fAllowAbstract) {
final IToken mark= mark(); final IToken mark= mark();
try { try {
cand1= declarator(pointerOps, attributes, nodeFactory.newName(), null, cand1= declarator(pointerOps, attributes, getNodeFactory().newName(), null,
startingOffset, endOffset, option); startingOffset, endOffset, option);
if (option.fRequireAbstract) if (option.fRequireAbstract)
return cand1; return cand1;
@ -1449,7 +1452,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
if (!option.fAllowAbstract) { if (!option.fAllowAbstract) {
throwBacktrack(LA(1)); throwBacktrack(LA(1));
} }
return declarator(pointerOps, attributes, nodeFactory.newName(), null, startingOffset, return declarator(pointerOps, attributes, getNodeFactory().newName(), null, startingOffset,
endOffset, option); endOffset, option);
} }
@ -1503,7 +1506,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
if (result == null) { if (result == null) {
result= nodeFactory.newDeclarator(null); result= getNodeFactory().newDeclarator(null);
setDeclaratorID(result, declaratorName, nestedDeclarator); setDeclaratorID(result, declaratorName, nestedDeclarator);
} else { } else {
endOffset= calculateEndOffset(result); endOffset= calculateEndOffset(result);
@ -1541,7 +1544,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
private void setDeclaratorID(IASTDeclarator declarator, IASTName declaratorName, IASTDeclarator nestedDeclarator) { private void setDeclaratorID(IASTDeclarator declarator, IASTName declaratorName, IASTDeclarator nestedDeclarator) {
if (nestedDeclarator != null) { if (nestedDeclarator != null) {
declarator.setNestedDeclarator(nestedDeclarator); declarator.setNestedDeclarator(nestedDeclarator);
declarator.setName(nodeFactory.newName()); declarator.setName(getNodeFactory().newName());
} else { } else {
declarator.setName(declaratorName); declarator.setName(declaratorName);
} }
@ -1605,7 +1608,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
parmDeclarations = ArrayUtil.removeNulls( IASTDeclaration.class, parmDeclarations ); parmDeclarations = ArrayUtil.removeNulls( IASTDeclaration.class, parmDeclarations );
ICASTKnRFunctionDeclarator functionDecltor = nodeFactory.newKnRFunctionDeclarator(parmNames, parmDeclarations); ICASTKnRFunctionDeclarator functionDecltor = getNodeFactory().newKnRFunctionDeclarator(parmNames, parmDeclarations);
((ASTNode) functionDecltor).setOffsetAndLength(startOffset, endOffset-startOffset); ((ASTNode) functionDecltor).setOffsetAndLength(startOffset, endOffset-startOffset);
return functionDecltor; return functionDecltor;
} }
@ -1646,7 +1649,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
break; break;
} }
} }
IASTStandardFunctionDeclarator fc = nodeFactory.newFunctionDeclarator(null); IASTStandardFunctionDeclarator fc = getNodeFactory().newFunctionDeclarator(null);
fc.setVarArgs(encounteredVarArgs); fc.setVarArgs(encounteredVarArgs);
if (parameters != null) { if (parameters != null) {
for (IASTParameterDeclaration pd : parameters) { for (IASTParameterDeclaration pd : parameters) {
@ -1689,7 +1692,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
throwBacktrack(LA(1)); throwBacktrack(LA(1));
final int endOffset = calculateEndOffset(arrayMods.get(arrayMods.size() - 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) { for (IASTArrayModifier m : arrayMods) {
d.addArrayModifier(m); d.addArrayModifier(m);
} }
@ -1708,7 +1711,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
final IASTExpression bitField = constantExpression(); final IASTExpression bitField = constantExpression();
final int endOffset = calculateEndOffset(bitField); final int endOffset = calculateEndOffset(bitField);
IASTFieldDeclarator d = nodeFactory.newFieldDeclarator(null, bitField); IASTFieldDeclarator d = getNodeFactory().newFieldDeclarator(null, bitField);
d.setBitFieldSize(bitField); d.setBitFieldSize(bitField);
((ASTNode) d).setOffsetAndLength(start, endOffset-start); ((ASTNode) d).setOffsetAndLength(start, endOffset-start);
@ -1723,13 +1726,13 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
switch (t.getType()) { switch (t.getType()) {
case IToken.tIDENTIFIER: case IToken.tIDENTIFIER:
consume(); consume();
n = nodeFactory.newName(t.getCharImage()); n = getNodeFactory().newName(t.getCharImage());
break; break;
case IToken.tCOMPLETION: case IToken.tCOMPLETION:
case IToken.tEOC: case IToken.tEOC:
consume(); consume();
n = nodeFactory.newName(t.getCharImage()); n = getNodeFactory().newName(t.getCharImage());
createCompletionNode(t).addName(n); createCompletionNode(t).addName(n);
return n; return n;
@ -1799,7 +1802,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
throw backtrack; throw backtrack;
} }
ICASTArrayModifier arrayMod = nodeFactory.newArrayModifier(exp); ICASTArrayModifier arrayMod = getNodeFactory().newArrayModifier(exp);
arrayMod.setStatic(isStatic); arrayMod.setStatic(isStatic);
arrayMod.setConst(isConst); arrayMod.setConst(isConst);
arrayMod.setVolatile(isVolatile); arrayMod.setVolatile(isVolatile);
@ -1838,10 +1841,10 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
final int length = figureEndOffset(declSpec, declarator) - startingOffset; final int length = figureEndOffset(declSpec, declarator) - startingOffset;
IASTParameterDeclaration result = nodeFactory.newParameterDeclaration(declSpec, declarator); IASTParameterDeclaration result = getNodeFactory().newParameterDeclaration(declSpec, declarator);
((ASTNode) result).setOffsetAndLength(startingOffset, length); ((ASTNode) result).setOffsetAndLength(startingOffset, length);
if (altDeclarator != null && altDeclSpec != null) { if (altDeclarator != null && altDeclSpec != null) {
IASTParameterDeclaration alt = nodeFactory.newParameterDeclaration(altDeclSpec, altDeclarator); IASTParameterDeclaration alt = getNodeFactory().newParameterDeclaration(altDeclSpec, altDeclarator);
((ASTNode) alt).setOffsetAndLength(startingOffset, length); ((ASTNode) alt).setOffsetAndLength(startingOffset, length);
// order is important, prefer variant with declspec over the one without // order is important, prefer variant with declspec over the one without
result= new CASTAmbiguousParameterDeclaration(result, alt); result= new CASTAmbiguousParameterDeclaration(result, alt);
@ -1989,7 +1992,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
private IASTProblemDeclaration createKnRCProblemDeclaration(int offset, int length) throws EndOfFileException { private IASTProblemDeclaration createKnRCProblemDeclaration(int offset, int length) throws EndOfFileException {
IASTProblem p = createProblem(IProblem.SYNTAX_ERROR, offset, length); IASTProblem p = createProblem(IProblem.SYNTAX_ERROR, offset, length);
IASTProblemDeclaration pd = nodeFactory.newProblemDeclaration(p); IASTProblemDeclaration pd = getNodeFactory().newProblemDeclaration(p);
((ASTNode) pd).setOffsetAndLength((ASTNode) p); ((ASTNode) pd).setOffsetAndLength((ASTNode) p);
// consume until LBRACE is found (to leave off at the function body and // 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); IASTExpression condition= condition(true);
if (LT(1) == IToken.tEOC) { if (LT(1) == IToken.tEOC) {
// Completing in the condition // 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 (if_statement != null) {
if_statement.setElseClause(new_if); if_statement.setElseClause(new_if);
@ -2053,7 +2056,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
consume(IToken.tRPAREN); consume(IToken.tRPAREN);
IASTStatement thenClause = statement(); 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); ((ASTNode) new_if_statement).setOffset(so);
if( condition != null ) // shouldn't be possible but failure in condition() makes it 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(); 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, ((ASTNode) switch_statement).setOffsetAndLength(startOffset,
(switch_body != null ? calculateEndOffset(switch_body) : LA(1).getEndOffset()) - startOffset); (switch_body != null ? calculateEndOffset(switch_body) : LA(1).getEndOffset()) - startOffset);
return switch_statement; return switch_statement;
@ -2177,7 +2180,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
throw backtrack; 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) { if (LT(1) != IToken.tEOC) {
IASTStatement for_body = statement(); IASTStatement for_body = statement();
((ASTNode) for_statement).setOffsetAndLength(startOffset, calculateEndOffset(for_body) - startOffset); ((ASTNode) for_statement).setOffsetAndLength(startOffset, calculateEndOffset(for_body) - startOffset);

228
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java
View file

@ -178,6 +178,7 @@ import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor;
* *
* Contributors: * Contributors:
* John Camelon (IBM Rational Software) - Initial API and implementation * 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[] currentClassName;
private char[] additionalNumericalSuffixes; private char[] additionalNumericalSuffixes;
private final ICPPNodeFactory nodeFactory;
private TemplateIdStrategy fTemplateParameterListStrategy; private TemplateIdStrategy fTemplateParameterListStrategy;
private Map<String, ContextSensitiveTokenType> fContextSensitiveTokens; private Map<String, ContextSensitiveTokenType> fContextSensitiveTokens;
@ -234,12 +234,16 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
supportAutoTypeSpecifier= true; supportAutoTypeSpecifier= true;
supportUserDefinedLiterals= config.supportUserDefinedLiterals(); supportUserDefinedLiterals= config.supportUserDefinedLiterals();
this.index= index; this.index= index;
this.nodeFactory = CPPNodeFactory.getDefault();
scanner.setSplitShiftROperator(true); scanner.setSplitShiftROperator(true);
fContextSensitiveTokens = createContextSensitiveTokenMap(config); fContextSensitiveTokens = createContextSensitiveTokenMap(config);
additionalNumericalSuffixes = scanner.getAdditionalNumericLiteralSuffixes(); additionalNumericalSuffixes = scanner.getAdditionalNumericLiteralSuffixes();
} }
@Override
protected ICPPNodeFactory getNodeFactory() {
return (ICPPNodeFactory) super.getNodeFactory();
}
private Map<String, ContextSensitiveTokenType> createContextSensitiveTokenMap( private Map<String, ContextSensitiveTokenType> createContextSensitiveTokenMap(
ICPPParserExtensionConfiguration config) { ICPPParserExtensionConfiguration config) {
Map<String, ContextSensitiveTokenType> result = new HashMap<String, ContextSensitiveTokenType>(); Map<String, ContextSensitiveTokenType> result = new HashMap<String, ContextSensitiveTokenType>();
@ -301,7 +305,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
int endOffset= offset; int endOffset= offset;
if (LT(1) == IToken.tCOLONCOLON) { if (LT(1) == IToken.tCOLONCOLON) {
endOffset= consume().getEndOffset(); endOffset= consume().getEndOffset();
qname= nodeFactory.newQualifiedName(null); qname= getNodeFactory().newQualifiedName(null);
qname.setFullyQualified(true); qname.setFullyQualified(true);
} }
@ -344,7 +348,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
if (!haveName || destructorOffset >= 0 || keywordTemplate) { if (!haveName || destructorOffset >= 0 || keywordTemplate) {
throwBacktrack(LA(1)); throwBacktrack(LA(1));
} }
nameSpec= nodeFactory.newName(CharArrayUtils.EMPTY); nameSpec= getNodeFactory().newName(CharArrayUtils.EMPTY);
if (qname != null) { if (qname != null) {
addNameSpecifier(qname, nameSpec); addNameSpecifier(qname, nameSpec);
} }
@ -387,7 +391,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
endOffset= consume().getEndOffset(); // :: endOffset= consume().getEndOffset(); // ::
if (qname == null) { if (qname == null) {
qname= nodeFactory.newQualifiedName(null); qname= getNodeFactory().newQualifiedName(null);
addNameSpecifier(qname, nameSpec); addNameSpecifier(qname, nameSpec);
} }
} }
@ -429,7 +433,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
private IASTName buildName(int destructorOffset, IToken nt) { private IASTName buildName(int destructorOffset, IToken nt) {
IASTName name; IASTName name;
if (destructorOffset < 0) { if (destructorOffset < 0) {
name= nodeFactory.newName(nt.getCharImage()); name= getNodeFactory().newName(nt.getCharImage());
setRange(name, nt.getOffset(), nt.getEndOffset()); setRange(name, nt.getOffset(), nt.getEndOffset());
} else { } else {
char[] nchars= nt.getCharImage(); char[] nchars= nt.getCharImage();
@ -437,7 +441,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
char[] image = new char[len+1]; char[] image = new char[len+1];
image[0]= '~'; image[0]= '~';
System.arraycopy(nchars, 0, image, 1, len); System.arraycopy(nchars, 0, image, 1, len);
name= nodeFactory.newName(image); name= getNodeFactory().newName(image);
setRange(name, destructorOffset, nt.getEndOffset()); setRange(name, destructorOffset, nt.getEndOffset());
} }
switch (nt.getType()) { switch (nt.getType()) {
@ -468,7 +472,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
} }
private ICPPASTTemplateId buildTemplateID(IASTName templateName, int endOffset, List<IASTNode> args) { private ICPPASTTemplateId buildTemplateID(IASTName templateName, int endOffset, List<IASTNode> args) {
ICPPASTTemplateId result = nodeFactory.newTemplateId(templateName); ICPPASTTemplateId result = getNodeFactory().newTemplateId(templateName);
setRange(result, ((ASTNode) templateName).getOffset(), endOffset); setRange(result, ((ASTNode) templateName).getOffset(), endOffset);
for (IASTNode n : args) { for (IASTNode n : args) {
if (n instanceof IASTTypeId) { if (n instanceof IASTTypeId) {
@ -490,7 +494,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
consume(IToken.tLPAREN); consume(IToken.tLPAREN);
ICPPASTExpression decltypeExpression = (ICPPASTExpression) expression(); ICPPASTExpression decltypeExpression = (ICPPASTExpression) expression();
int end = consume(IToken.tRPAREN).getEndOffset(); int end = consume(IToken.tRPAREN).getEndOffset();
ICPPASTDecltypeSpecifier decltypeSpec = nodeFactory.newDecltypeSpecifier(decltypeExpression); ICPPASTDecltypeSpecifier decltypeSpec = getNodeFactory().newDecltypeSpecifier(decltypeExpression);
setRange(decltypeSpec, start, end); setRange(decltypeSpec, start, end);
return decltypeSpec; return decltypeSpec;
} }
@ -742,7 +746,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
namedTypeSpec = (IASTNamedTypeSpecifier) declSpec; namedTypeSpec = (IASTNamedTypeSpecifier) declSpec;
name = namedTypeSpec.getName(); name = namedTypeSpec.getName();
if (name.contains(typeId)) { 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) { private IASTExpression addPackExpansion(IASTExpression expr, IToken ellipsis) {
IASTExpression result= nodeFactory.newPackExpansionExpression(expr); IASTExpression result= getNodeFactory().newPackExpansionExpression(expr);
return setRange(result, expr, ellipsis.getEndOffset()); 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, strOp.getCharImage());
operatorName = CharArrayUtils.concat(operatorName, ident.getCharImage()); operatorName = CharArrayUtils.concat(operatorName, ident.getCharImage());
IASTName name = nodeFactory.newOperatorName(operatorName); IASTName name = getNodeFactory().newOperatorName(operatorName);
setRange(name, firstToken.getOffset(), ident.getEndOffset()); setRange(name, firstToken.getOffset(), ident.getEndOffset());
return name; return name;
} }
@ -880,7 +884,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
} }
if (op != null) { if (op != null) {
IASTName name= nodeFactory.newOperatorName(op.toCharArray()); IASTName name= getNodeFactory().newOperatorName(op.toCharArray());
setRange(name, firstToken.getOffset(), endOffset); setRange(name, firstToken.getOffset(), endOffset);
return name; return name;
} }
@ -888,7 +892,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
// must be a conversion function // must be a conversion function
typeId= typeId(DeclarationOptions.TYPEID_CONVERSION); typeId= typeId(DeclarationOptions.TYPEID_CONVERSION);
IASTName name = nodeFactory.newConversionName(typeId); IASTName name = getNodeFactory().newConversionName(typeId);
setRange(name, firstToken.getOffset(), calculateEndOffset(typeId)); setRange(name, firstToken.getOffset(), calculateEndOffset(typeId));
return name; return name;
} }
@ -1216,7 +1220,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
@Override @Override
protected IASTExpression buildBinaryExpression(int operator, IASTExpression expr1, IASTInitializerClause expr2, int lastOffset) { 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(); int o = ((ASTNode) expr1).getOffset();
((ASTNode) result).setOffsetAndLength(o, lastOffset - o); ((ASTNode) result).setOffsetAndLength(o, lastOffset - o);
return result; return result;
@ -1256,7 +1260,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
vectored = true; vectored = true;
} }
IASTExpression castExpression = castExpression(CastExprCtx.eNotInBExpr, null); IASTExpression castExpression = castExpression(CastExprCtx.eNotInBExpr, null);
ICPPASTDeleteExpression deleteExpression = nodeFactory.newDeleteExpression(castExpression); ICPPASTDeleteExpression deleteExpression = getNodeFactory().newDeleteExpression(castExpression);
((ASTNode) deleteExpression).setOffsetAndLength(startingOffset, calculateEndOffset(castExpression) - startingOffset); ((ASTNode) deleteExpression).setOffsetAndLength(startingOffset, calculateEndOffset(castExpression) - startingOffset);
deleteExpression.setIsGlobal(global); deleteExpression.setIsGlobal(global);
deleteExpression.setIsVectored(vectored); deleteExpression.setIsVectored(vectored);
@ -1395,7 +1399,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
if (plcmt != null && !plcmt.isEmpty()) { if (plcmt != null && !plcmt.isEmpty()) {
plcmtArray= plcmt.toArray(new IASTInitializerClause[plcmt.size()]); 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.setIsGlobal(isGlobal);
result.setIsNewTypeId(isNewTypeId); result.setIsNewTypeId(isNewTypeId);
((ASTNode) result).setOffsetAndLength(offset, endOffset - offset); ((ASTNode) result).setOffsetAndLength(offset, endOffset - offset);
@ -1494,9 +1498,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
int endOffset= consumeOrEOC(IToken.tRPAREN).getEndOffset(); int endOffset= consumeOrEOC(IToken.tRPAREN).getEndOffset();
IASTExpression result; IASTExpression result;
if (isBinary) { if (isBinary) {
result= nodeFactory.newBinaryTypeIdExpression(getBinaryTypeTraitOperator(first), typeId, secondTypeId); result= getNodeFactory().newBinaryTypeIdExpression(getBinaryTypeTraitOperator(first), typeId, secondTypeId);
} else { } else {
result= nodeFactory.newTypeIdExpression(getUnaryTypeTraitOperator(first), typeId); result= getNodeFactory().newTypeIdExpression(getUnaryTypeTraitOperator(first), typeId);
} }
return setRange(result, first.getOffset(), endOffset); return setRange(result, first.getOffset(), endOffset);
} }
@ -1622,7 +1626,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
offset= consume().getOffset(); // noexcept offset= consume().getOffset(); // noexcept
consume(IToken.tLPAREN); // ( consume(IToken.tLPAREN); // (
firstExpression= expression(); firstExpression= expression();
firstExpression= nodeFactory.newUnaryExpression(IASTUnaryExpression.op_noexcept, firstExpression); firstExpression= getNodeFactory().newUnaryExpression(IASTUnaryExpression.op_noexcept, firstExpression);
final int endOffset = consume(IToken.tRPAREN).getEndOffset(); // ) final int endOffset = consume(IToken.tRPAREN).getEndOffset(); // )
setRange(firstExpression, offset, endOffset); setRange(firstExpression, offset, endOffset);
break; break;
@ -1639,7 +1643,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
consume(IToken.tRPAREN); consume(IToken.tRPAREN);
if (LT(1) == IToken.tLBRACE) { if (LT(1) == IToken.tLBRACE) {
IASTInitializer i = bracedInitList(false); IASTInitializer i = bracedInitList(false);
firstExpression= nodeFactory.newTypeIdInitializerExpression(t, i); firstExpression= getNodeFactory().newTypeIdInitializerExpression(t, i);
setRange(firstExpression, offset, calculateEndOffset(i)); setRange(firstExpression, offset, calculateEndOffset(i));
break; break;
} }
@ -1687,7 +1691,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
firstExpression = primaryExpression(ctx, strat); firstExpression = primaryExpression(ctx, strat);
if (firstExpression instanceof IASTIdExpression && LT(1) == IToken.tLBRACE) { if (firstExpression instanceof IASTIdExpression && LT(1) == IToken.tLBRACE) {
IASTName name = ((IASTIdExpression) firstExpression).getName(); IASTName name = ((IASTIdExpression) firstExpression).getName();
ICPPASTDeclSpecifier declSpec= nodeFactory.newTypedefNameSpecifier(name); ICPPASTDeclSpecifier declSpec= getNodeFactory().newTypedefNameSpecifier(name);
firstExpression = simpleTypeConstructorExpression(setRange(declSpec, name)); firstExpression = simpleTypeConstructorExpression(setRange(declSpec, name));
} }
break; break;
@ -1706,7 +1710,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
expression= expression(); expression= expression();
} }
int endOffset= consumeOrEOC(IToken.tRBRACKET).getEndOffset(); int endOffset= consumeOrEOC(IToken.tRBRACKET).getEndOffset();
IASTArraySubscriptExpression s = nodeFactory.newArraySubscriptExpression(firstExpression, expression); IASTArraySubscriptExpression s = getNodeFactory().newArraySubscriptExpression(firstExpression, expression);
firstExpression= setRange(s, firstExpression, endOffset); firstExpression= setRange(s, firstExpression, endOffset);
break; break;
case IToken.tLPAREN: case IToken.tLPAREN:
@ -1722,7 +1726,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
} }
endOffset = consumeOrEOC(IToken.tRPAREN).getEndOffset(); endOffset = consumeOrEOC(IToken.tRPAREN).getEndOffset();
IASTFunctionCallExpression fce = nodeFactory.newFunctionCallExpression(firstExpression, initArray); IASTFunctionCallExpression fce = getNodeFactory().newFunctionCallExpression(firstExpression, initArray);
firstExpression= setRange(fce, firstExpression, endOffset); firstExpression= setRange(fce, firstExpression, endOffset);
break; break;
@ -1751,7 +1755,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
throwBacktrack(((ASTNode) firstExpression).getOffset(), throwBacktrack(((ASTNode) firstExpression).getOffset(),
((ASTNode) firstExpression).getLength() + dot.getLength()); ((ASTNode) firstExpression).getLength() + dot.getLength());
ICPPASTFieldReference fieldReference = nodeFactory.newFieldReference(name, firstExpression); ICPPASTFieldReference fieldReference = getNodeFactory().newFieldReference(name, firstExpression);
fieldReference.setIsPointerDereference(false); fieldReference.setIsPointerDereference(false);
fieldReference.setIsTemplate(isTemplate); fieldReference.setIsTemplate(isTemplate);
((ASTNode) fieldReference).setOffsetAndLength( ((ASTNode) fieldReference).setOffsetAndLength(
@ -1774,7 +1778,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
throwBacktrack(((ASTNode) firstExpression).getOffset(), throwBacktrack(((ASTNode) firstExpression).getOffset(),
((ASTNode) firstExpression).getLength() + arrow.getLength()); ((ASTNode) firstExpression).getLength() + arrow.getLength());
fieldReference = nodeFactory.newFieldReference(name, firstExpression); fieldReference = getNodeFactory().newFieldReference(name, firstExpression);
fieldReference.setIsPointerDereference(true); fieldReference.setIsPointerDereference(true);
fieldReference.setIsTemplate(isTemplate); fieldReference.setIsTemplate(isTemplate);
((ASTNode) fieldReference).setOffsetAndLength( ((ASTNode) fieldReference).setOffsetAndLength(
@ -1809,7 +1813,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
private IASTExpression simpleTypeConstructorExpression(ICPPASTDeclSpecifier declSpec) throws EndOfFileException, BacktrackException { private IASTExpression simpleTypeConstructorExpression(ICPPASTDeclSpecifier declSpec) throws EndOfFileException, BacktrackException {
IASTInitializer initializer = bracedOrCtorStyleInitializer(); IASTInitializer initializer = bracedOrCtorStyleInitializer();
ICPPASTSimpleTypeConstructorExpression result = nodeFactory.newSimpleTypeConstructorExpression( ICPPASTSimpleTypeConstructorExpression result = getNodeFactory().newSimpleTypeConstructorExpression(
declSpec, initializer); declSpec, initializer);
return setRange(result, declSpec, calculateEndOffset(initializer)); return setRange(result, declSpec, calculateEndOffset(initializer));
} }
@ -1823,13 +1827,13 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
switch (LT(1)) { switch (LT(1)) {
case IToken.tINTEGER: case IToken.tINTEGER:
t = consume(); 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()); literalExprWithRange = setRange(literalExpr, t.getOffset(), t.getEndOffset());
((CPPASTLiteralExpression) literalExpr).calculateSuffix(additionalNumericalSuffixes); ((CPPASTLiteralExpression) literalExpr).calculateSuffix(additionalNumericalSuffixes);
break; break;
case IToken.tFLOATINGPT: case IToken.tFLOATINGPT:
t = consume(); 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()); literalExprWithRange = setRange(literalExpr, t.getOffset(), t.getEndOffset());
((CPPASTLiteralExpression) literalExpr).calculateSuffix(additionalNumericalSuffixes); ((CPPASTLiteralExpression) literalExpr).calculateSuffix(additionalNumericalSuffixes);
break; break;
@ -1849,7 +1853,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
case IToken.tUTF32CHAR: case IToken.tUTF32CHAR:
case IToken.tUSER_DEFINED_CHAR_LITERAL: case IToken.tUSER_DEFINED_CHAR_LITERAL:
t = consume(); t = consume();
literalExpr = nodeFactory.newLiteralExpression( literalExpr = getNodeFactory().newLiteralExpression(
IASTLiteralExpression.lk_char_constant, t.getImage()); IASTLiteralExpression.lk_char_constant, t.getImage());
literalExprWithRange = setRange(literalExpr, t.getOffset(), t.getEndOffset()); literalExprWithRange = setRange(literalExpr, t.getOffset(), t.getEndOffset());
if (supportUserDefinedLiterals) { if (supportUserDefinedLiterals) {
@ -1858,20 +1862,20 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
break; break;
case IToken.t_false: case IToken.t_false:
t = consume(); 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()); return setRange(literalExpr, t.getOffset(), t.getEndOffset());
case IToken.t_true: case IToken.t_true:
t = consume(); 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()); return setRange(literalExpr, t.getOffset(), t.getEndOffset());
case IToken.t_nullptr: case IToken.t_nullptr:
t= consume(); 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()); return setRange(literalExpr, t.getOffset(), t.getEndOffset());
case IToken.t_this: case IToken.t_this:
t = consume(); 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()); return setRange(literalExpr, t.getOffset(), t.getEndOffset());
case IToken.tLPAREN: case IToken.tLPAREN:
if (supportStatementsInExpressions && LT(2) == IToken.tLBRACE) { if (supportStatementsInExpressions && LT(2) == IToken.tLBRACE) {
@ -1901,7 +1905,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
// (unless we are invoking code completion at the '::'). // (unless we are invoking code completion at the '::').
if (name.getLookupKey().length == 0 && LT(1) != IToken.tEOC) if (name.getLookupKey().length == 0 && LT(1) != IToken.tEOC)
throwBacktrack(LA(1)); throwBacktrack(LA(1));
IASTIdExpression idExpression = nodeFactory.newIdExpression(name); IASTIdExpression idExpression = getNodeFactory().newIdExpression(name);
return setRange(idExpression, name); return setRange(idExpression, name);
} }
case IToken.tLBRACKET: case IToken.tLBRACKET:
@ -1943,14 +1947,14 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
throwBacktrack(LA(1)); throwBacktrack(LA(1));
} }
IToken t= consume(); 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()); return setRange(r, t.getOffset(), t.getEndOffset());
} }
private IASTExpression lambdaExpression() throws EndOfFileException, BacktrackException { private IASTExpression lambdaExpression() throws EndOfFileException, BacktrackException {
final int offset= LA().getOffset(); final int offset= LA().getOffset();
ICPPASTLambdaExpression lambdaExpr= nodeFactory.newLambdaExpression(); ICPPASTLambdaExpression lambdaExpr= getNodeFactory().newLambdaExpression();
// Lambda introducer // Lambda introducer
consume(IToken.tLBRACKET); consume(IToken.tLBRACKET);
@ -2002,7 +2006,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
private ICPPASTCapture capture() throws EndOfFileException, BacktrackException { private ICPPASTCapture capture() throws EndOfFileException, BacktrackException {
final int offset= LA().getOffset(); final int offset= LA().getOffset();
final ICPPASTCapture result = nodeFactory.newCapture(); final ICPPASTCapture result = getNodeFactory().newCapture();
switch (LT(1)) { switch (LT(1)) {
case IToken.t_this: case IToken.t_this:
@ -2099,7 +2103,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
default: default:
throw backtrack; throw backtrack;
} }
ICPPASTUsingDirective astUD = nodeFactory.newUsingDirective(name); ICPPASTUsingDirective astUD = getNodeFactory().newUsingDirective(name);
addAttributeSpecifiers(attributes, astUD); addAttributeSpecifiers(attributes, astUD);
@ -2138,7 +2142,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
} }
int endOffset = consume().getEndOffset(); int endOffset = consume().getEndOffset();
ICPPASTAliasDeclaration aliasDeclaration = nodeFactory.newAliasDeclaration(aliasName, aliasedType); ICPPASTAliasDeclaration aliasDeclaration = getNodeFactory().newAliasDeclaration(aliasName, aliasedType);
addAttributeSpecifiers(attributes, aliasDeclaration); addAttributeSpecifiers(attributes, aliasDeclaration);
setRange(aliasDeclaration, offset, endOffset); setRange(aliasDeclaration, offset, endOffset);
return aliasDeclaration; return aliasDeclaration;
@ -2162,7 +2166,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
throw backtrack; throw backtrack;
} }
ICPPASTUsingDeclaration result = nodeFactory.newUsingDeclaration(name); ICPPASTUsingDeclaration result = getNodeFactory().newUsingDeclaration(name);
((ASTNode) result).setOffsetAndLength(offset, end - offset); ((ASTNode) result).setOffsetAndLength(offset, end - offset);
result.setIsTypename(typeName); result.setIsTypename(typeName);
return result; return result;
@ -2184,7 +2188,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
consume(IToken.tRPAREN); consume(IToken.tRPAREN);
endOffset= consume(IToken.tSEMI).getEndOffset(); endOffset= consume(IToken.tSEMI).getEndOffset();
} }
ICPPASTStaticAssertDeclaration assertion = nodeFactory.newStaticAssertion(e, lit); ICPPASTStaticAssertDeclaration assertion = getNodeFactory().newStaticAssertion(e, lit);
return setRange(assertion, offset, endOffset); return setRange(assertion, offset, endOffset);
} }
@ -2199,7 +2203,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
protected ICPPASTLinkageSpecification linkageSpecification() throws EndOfFileException, BacktrackException { protected ICPPASTLinkageSpecification linkageSpecification() throws EndOfFileException, BacktrackException {
int offset= consume().getOffset(); // t_extern int offset= consume().getOffset(); // t_extern
String spec = consume().getImage(); // tString String spec = consume().getImage(); // tString
ICPPASTLinkageSpecification linkage = nodeFactory.newLinkageSpecification(spec); ICPPASTLinkageSpecification linkage = getNodeFactory().newLinkageSpecification(spec);
if (LT(1) == IToken.tLBRACE) { if (LT(1) == IToken.tLBRACE) {
declarationListInBraces(linkage, offset, DeclarationOptions.GLOBAL); declarationListInBraces(linkage, offset, DeclarationOptions.GLOBAL);
@ -2252,7 +2256,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
if (LT(1) != IToken.tLT) { if (LT(1) != IToken.tLT) {
// explicit-instantiation // explicit-instantiation
IASTDeclaration d = declaration(option); IASTDeclaration d = declaration(option);
ICPPASTExplicitTemplateInstantiation ti= nodeFactory.newExplicitTemplateInstantiation(d); ICPPASTExplicitTemplateInstantiation ti= getNodeFactory().newExplicitTemplateInstantiation(d);
ti.setModifier(explicitInstMod); ti.setModifier(explicitInstMod);
setRange(ti, offset, calculateEndOffset(d)); setRange(ti, offset, calculateEndOffset(d));
return ti; return ti;
@ -2267,7 +2271,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
// explicit-specialization // explicit-specialization
consume(); consume();
IASTDeclaration d = declaration(option); IASTDeclaration d = declaration(option);
ICPPASTTemplateSpecialization templateSpecialization = nodeFactory.newTemplateSpecialization(d); ICPPASTTemplateSpecialization templateSpecialization = getNodeFactory().newTemplateSpecialization(d);
setRange(templateSpecialization, offset, calculateEndOffset(d)); setRange(templateSpecialization, offset, calculateEndOffset(d));
return templateSpecialization; return templateSpecialization;
} }
@ -2277,7 +2281,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
consume(IToken.tGT, IToken.tGT_in_SHIFTR); consume(IToken.tGT, IToken.tGT_in_SHIFTR);
} }
IASTDeclaration d = declaration(option); IASTDeclaration d = declaration(option);
ICPPASTTemplateDeclaration templateDecl = nodeFactory.newTemplateDeclaration(d); ICPPASTTemplateDeclaration templateDecl = getNodeFactory().newTemplateDeclaration(d);
setRange(templateDecl, offset, calculateEndOffset(d)); setRange(templateDecl, offset, calculateEndOffset(d));
templateDecl.setExported(exported); templateDecl.setExported(exported);
for (int i = 0; i < parms.size(); ++i) { for (int i = 0; i < parms.size(); ++i) {
@ -2363,7 +2367,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
identifierName = identifier(); identifierName = identifier();
endOffset = calculateEndOffset(identifierName); endOffset = calculateEndOffset(identifierName);
} else { } else {
identifierName = nodeFactory.newName(); identifierName = getNodeFactory().newName();
setRange(identifierName, endOffset, endOffset); setRange(identifierName, endOffset, endOffset);
} }
if (LT(1) == IToken.tASSIGN) { // optional = type-id if (LT(1) == IToken.tASSIGN) { // optional = type-id
@ -2380,7 +2384,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
case IToken.tEOC: case IToken.tEOC:
case IToken.tGT_in_SHIFTR: case IToken.tGT_in_SHIFTR:
case IToken.tCOMMA: case IToken.tCOMMA:
ICPPASTSimpleTypeTemplateParameter tpar = nodeFactory.newSimpleTypeTemplateParameter(type, identifierName, defaultValue); ICPPASTSimpleTypeTemplateParameter tpar = getNodeFactory().newSimpleTypeTemplateParameter(type, identifierName, defaultValue);
tpar.setIsParameterPack(parameterPack); tpar.setIsParameterPack(parameterPack);
setRange(tpar, start.getOffset(), endOffset); setRange(tpar, start.getOffset(), endOffset);
return tpar; return tpar;
@ -2417,10 +2421,10 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
endOffset = calculateEndOffset(defaultValue); endOffset = calculateEndOffset(defaultValue);
} }
} else { } else {
identifierName = nodeFactory.newName(); identifierName = getNodeFactory().newName();
} }
ICPPASTTemplatedTypeTemplateParameter tpar = nodeFactory.newTemplatedTypeTemplateParameter(identifierName, defaultValue); ICPPASTTemplatedTypeTemplateParameter tpar = getNodeFactory().newTemplatedTypeTemplateParameter(identifierName, defaultValue);
tpar.setIsParameterPack(parameterPack); tpar.setIsParameterPack(parameterPack);
setRange(tpar, start.getOffset(), endOffset); setRange(tpar, start.getOffset(), endOffset);
@ -2480,8 +2484,8 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
break; break;
case IToken.tSEMI: case IToken.tSEMI:
IToken t= consume(); IToken t= consume();
IASTSimpleDeclSpecifier declspec= nodeFactory.newSimpleDeclSpecifier(); IASTSimpleDeclSpecifier declspec= getNodeFactory().newSimpleDeclSpecifier();
IASTSimpleDeclaration decl= nodeFactory.newSimpleDeclaration(declspec); IASTSimpleDeclaration decl= getNodeFactory().newSimpleDeclaration(declspec);
((ASTNode) declspec).setOffsetAndLength(t.getOffset(), 0); ((ASTNode) declspec).setOffsetAndLength(t.getOffset(), 0);
((ASTNode) decl).setOffsetAndLength(t.getOffset(), t.getLength()); ((ASTNode) decl).setOffsetAndLength(t.getOffset(), t.getLength());
return decl; return decl;
@ -2492,7 +2496,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
t= consume(); t= consume();
int key= t.getType(); int key= t.getType();
int endOffset= consume(IToken.tCOLON).getEndOffset(); int endOffset= consume(IToken.tCOLON).getEndOffset();
ICPPASTVisibilityLabel label = nodeFactory.newVisibilityLabel(token2Visibility(key)); ICPPASTVisibilityLabel label = getNodeFactory().newVisibilityLabel(token2Visibility(key));
setRange(label, t.getOffset(), endOffset); setRange(label, t.getOffset(), endOffset);
return label; return label;
} }
@ -2541,14 +2545,14 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
name = identifier(); name = identifier();
endOffset= calculateEndOffset(name); endOffset= calculateEndOffset(name);
} else { } else {
name = nodeFactory.newName(); name = getNodeFactory().newName();
} }
// bug 195701, gcc 4.2 allows visibility attribute for namespaces. // bug 195701, gcc 4.2 allows visibility attribute for namespaces.
List<IASTAttributeSpecifier> attributeSpecifiers = __attribute_decl_seq(true, false); List<IASTAttributeSpecifier> attributeSpecifiers = __attribute_decl_seq(true, false);
if (LT(1) == IToken.tLBRACE) { if (LT(1) == IToken.tLBRACE) {
ICPPASTNamespaceDefinition ns = nodeFactory.newNamespaceDefinition(name); ICPPASTNamespaceDefinition ns = getNodeFactory().newNamespaceDefinition(name);
ns.setIsInline(isInline); ns.setIsInline(isInline);
declarationListInBraces(ns, offset, DeclarationOptions.GLOBAL); declarationListInBraces(ns, offset, DeclarationOptions.GLOBAL);
addAttributeSpecifiers(attributeSpecifiers, ns); addAttributeSpecifiers(attributeSpecifiers, ns);
@ -2565,7 +2569,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
IASTName qualifiedName= qualifiedName(); IASTName qualifiedName= qualifiedName();
endOffset = consume(IToken.tSEMI).getEndOffset(); endOffset = consume(IToken.tSEMI).getEndOffset();
ICPPASTNamespaceAlias alias = nodeFactory.newNamespaceAlias(name, qualifiedName); ICPPASTNamespaceAlias alias = getNodeFactory().newNamespaceAlias(name, qualifiedName);
((ASTNode) alias).setOffsetAndLength(offset, endOffset - offset); ((ASTNode) alias).setOffsetAndLength(offset, endOffset - offset);
return alias; return alias;
} }
@ -2582,7 +2586,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
specifiers = new ArrayList<IASTAttributeSpecifier>(); specifiers = new ArrayList<IASTAttributeSpecifier>();
int offset = consumeOrEOC(IToken.tLBRACKET).getOffset(); int offset = consumeOrEOC(IToken.tLBRACKET).getOffset();
consumeOrEOC(IToken.tLBRACKET); consumeOrEOC(IToken.tLBRACKET);
ICPPASTAttributeSpecifier attributeSpecifier = nodeFactory.newAttributeSpecifier(); ICPPASTAttributeSpecifier attributeSpecifier = getNodeFactory().newAttributeSpecifier();
while (LT(1) != IToken.tRBRACKET) { while (LT(1) != IToken.tRBRACKET) {
if (LT(1) == IToken.tCOMMA) if (LT(1) == IToken.tCOMMA)
consume(); consume();
@ -2629,7 +2633,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
} }
char[] attributeName = nameToken.getCharImage(); char[] attributeName = nameToken.getCharImage();
char[] scopeName = scopeToken != null ? scopeToken.getCharImage() : null; char[] scopeName = scopeToken != null ? scopeToken.getCharImage() : null;
ICPPASTAttribute result = nodeFactory.newAttribute(attributeName, scopeName, ICPPASTAttribute result = getNodeFactory().newAttribute(attributeName, scopeName,
argumentClause, packExpansion); argumentClause, packExpansion);
setRange(result, nameToken.getOffset(), endOffset); setRange(result, nameToken.getOffset(), endOffset);
return result; return result;
@ -2678,7 +2682,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
} catch (BacktrackException e) { } catch (BacktrackException e) {
IASTNode node= e.getNodeBeforeProblem(); IASTNode node= e.getNodeBeforeProblem();
if (node instanceof IASTDeclSpecifier && isLegalWithoutDtor((IASTDeclSpecifier) node)) { if (node instanceof IASTDeclSpecifier && isLegalWithoutDtor((IASTDeclSpecifier) node)) {
IASTSimpleDeclaration d= nodeFactory.newSimpleDeclaration((IASTDeclSpecifier) node); IASTSimpleDeclaration d= getNodeFactory().newSimpleDeclaration((IASTDeclSpecifier) node);
setRange(d, node); setRange(d, node);
throwBacktrack(e.getProblem(), d); throwBacktrack(e.getProblem(), d);
} }
@ -2765,10 +2769,10 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
if (isAmbiguous) { if (isAmbiguous) {
// class C { C(T); }; // if T is a type this is a constructor, so // 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 // 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); simpleDeclaration.addDeclarator(altDtor);
} else { } else {
simpleDeclaration= nodeFactory.newSimpleDeclaration(declSpec); simpleDeclaration= getNodeFactory().newSimpleDeclaration(declSpec);
for (IASTDeclarator declarator : declarators) { for (IASTDeclarator declarator : declarators) {
simpleDeclaration.addDeclarator(declarator); simpleDeclaration.addDeclarator(declarator);
} }
@ -2798,9 +2802,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
ICPPASTFunctionDefinition fdef; ICPPASTFunctionDefinition fdef;
if (LT(1) == IToken.t_try) { if (LT(1) == IToken.t_try) {
consume(); consume();
fdef= nodeFactory.newFunctionTryBlock(declSpec, (ICPPASTFunctionDeclarator) dtor, null); fdef= getNodeFactory().newFunctionTryBlock(declSpec, (ICPPASTFunctionDeclarator) dtor, null);
} else { } else {
fdef= nodeFactory.newFunctionDefinition(declSpec, (ICPPASTFunctionDeclarator) dtor, null); fdef= getNodeFactory().newFunctionDefinition(declSpec, (ICPPASTFunctionDeclarator) dtor, null);
} }
if (LT(1) == IToken.tASSIGN) { if (LT(1) == IToken.tASSIGN) {
consume(); consume();
@ -2879,7 +2883,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
init= null; init= null;
endOffset= calculateEndOffset(name); endOffset= calculateEndOffset(name);
} }
ICPPASTConstructorChainInitializer ctorInitializer = nodeFactory.newConstructorChainInitializer(name, init); ICPPASTConstructorChainInitializer ctorInitializer = getNodeFactory().newConstructorChainInitializer(name, init);
if (LT(1) == IToken.tELLIPSIS) { if (LT(1) == IToken.tELLIPSIS) {
ctorInitializer.setIsPackExpansion(true); ctorInitializer.setIsPackExpansion(true);
endOffset= consume().getEndOffset(); endOffset= consume().getEndOffset();
@ -2918,7 +2922,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
declarator= addInitializer(lie, DeclarationOptions.PARAMETER); 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); final int endOffset = figureEndOffset(declSpec, declarator);
setRange(parm, startOffset, endOffset); setRange(parm, startOffset, endOffset);
return parm; return parm;
@ -3383,7 +3387,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
private ICPPASTNamedTypeSpecifier buildNamedTypeSpecifier(IASTName name, boolean isTypename, private ICPPASTNamedTypeSpecifier buildNamedTypeSpecifier(IASTName name, boolean isTypename,
int storageClass, int options, int offset, int endOffset) { int storageClass, int options, int offset, int endOffset) {
ICPPASTNamedTypeSpecifier declSpec = nodeFactory.newTypedefNameSpecifier(name); ICPPASTNamedTypeSpecifier declSpec = getNodeFactory().newTypedefNameSpecifier(name);
declSpec.setIsTypename(isTypename); declSpec.setIsTypename(isTypename);
configureDeclSpec(declSpec, storageClass, options); configureDeclSpec(declSpec, storageClass, options);
((ASTNode) declSpec).setOffsetAndLength(offset, endOffset - offset); ((ASTNode) declSpec).setOffsetAndLength(offset, endOffset - offset);
@ -3392,7 +3396,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
private ICPPASTSimpleDeclSpecifier buildSimpleDeclSpec(int storageClass, int simpleType, private ICPPASTSimpleDeclSpecifier buildSimpleDeclSpec(int storageClass, int simpleType,
int options, int isLong, IASTExpression typeofExpression, int offset, int endOffset) { int options, int isLong, IASTExpression typeofExpression, int offset, int endOffset) {
ICPPASTSimpleDeclSpecifier declSpec= nodeFactory.newSimpleDeclSpecifier(); ICPPASTSimpleDeclSpecifier declSpec= getNodeFactory().newSimpleDeclSpecifier();
configureDeclSpec(declSpec, storageClass, options); configureDeclSpec(declSpec, storageClass, options);
@ -3472,10 +3476,10 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
if (name == null) { if (name == null) {
if (isOpaque) if (isOpaque)
throwBacktrack(LA(1)); 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); result.setIsOpaque(isOpaque);
if (lt1 == IToken.tLBRACE) { if (lt1 == IToken.tLBRACE) {
endOffset= enumBody(result); endOffset= enumBody(result);
@ -3520,7 +3524,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
attributes = CollectionUtils.merge(attributes, attributeSpecifierSeq()); attributes = CollectionUtils.merge(attributes, attributeSpecifierSeq());
IASTName name = qualifiedName(); IASTName name = qualifiedName();
ICPPASTElaboratedTypeSpecifier elaboratedTypeSpecifier = nodeFactory.newElaboratedTypeSpecifier(eck, name); ICPPASTElaboratedTypeSpecifier elaboratedTypeSpecifier = getNodeFactory().newElaboratedTypeSpecifier(eck, name);
addAttributeSpecifiers(attributes, elaboratedTypeSpecifier); addAttributeSpecifiers(attributes, elaboratedTypeSpecifier);
return setRange(elaboratedTypeSpecifier, offset, calculateEndOffset(name)); return setRange(elaboratedTypeSpecifier, offset, calculateEndOffset(name));
} }
@ -3534,7 +3538,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
consume(IToken.tLPAREN); consume(IToken.tLPAREN);
ICPPASTTypeId operand = typeId(options); ICPPASTTypeId operand = typeId(options);
final int endOffset = consumeOrEOC(IToken.tRPAREN).getEndOffset(); 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 @Override
@ -3777,13 +3781,13 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
ContextSensitiveTokenType contextSensitiveType = getContextSensitiveType(token); ContextSensitiveTokenType contextSensitiveType = getContextSensitiveType(token);
if (contextSensitiveType == ContextSensitiveTokenType.OVERRIDE) { if (contextSensitiveType == ContextSensitiveTokenType.OVERRIDE) {
consume(); consume();
ICPPASTVirtSpecifier spec = nodeFactory.newVirtSpecifier( ICPPASTVirtSpecifier spec = getNodeFactory().newVirtSpecifier(
ICPPASTVirtSpecifier.SpecifierKind.Override); ICPPASTVirtSpecifier.SpecifierKind.Override);
setRange(spec, token.getOffset(), token.getOffset() + token.getLength()); setRange(spec, token.getOffset(), token.getOffset() + token.getLength());
typeRelevantDtor.addVirtSpecifier(spec); typeRelevantDtor.addVirtSpecifier(spec);
} else if (contextSensitiveType == ContextSensitiveTokenType.FINAL) { } else if (contextSensitiveType == ContextSensitiveTokenType.FINAL) {
consume(); consume();
ICPPASTVirtSpecifier spec = nodeFactory.newVirtSpecifier( ICPPASTVirtSpecifier spec = getNodeFactory().newVirtSpecifier(
ICPPASTVirtSpecifier.SpecifierKind.Final); ICPPASTVirtSpecifier.SpecifierKind.Final);
setRange(spec, token.getOffset(), token.getOffset() + token.getLength()); setRange(spec, token.getOffset(), token.getOffset() + token.getLength());
typeRelevantDtor.addVirtSpecifier(spec); typeRelevantDtor.addVirtSpecifier(spec);
@ -3816,7 +3820,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
int offset= consume().getOffset(); int offset= consume().getOffset();
final boolean allowSkipping = LT(1) == IToken.tLBRACE && specifiesArray(dtor); final boolean allowSkipping = LT(1) == IToken.tLBRACE && specifiesArray(dtor);
IASTInitializerClause initClause = initClause(allowSkipping); IASTInitializerClause initClause = initClause(allowSkipping);
IASTEqualsInitializer initExpr= nodeFactory.newEqualsInitializer(initClause); IASTEqualsInitializer initExpr= getNodeFactory().newEqualsInitializer(initClause);
return setRange(initExpr, offset, calculateEndOffset(initClause)); return setRange(initExpr, offset, calculateEndOffset(initClause));
} }
@ -3861,7 +3865,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
initArray = exprList.toArray(new IASTInitializerClause[exprList.size()]); initArray = exprList.toArray(new IASTInitializerClause[exprList.size()]);
} }
int endOffset = consumeOrEOC(IToken.tRPAREN).getEndOffset(); int endOffset = consumeOrEOC(IToken.tRPAREN).getEndOffset();
return setRange(nodeFactory.newConstructorInitializer(initArray), offset, endOffset); return setRange(getNodeFactory().newConstructorInitializer(initArray), offset, endOffset);
} }
private List<IASTInitializerClause> expressionList() throws EndOfFileException, BacktrackException { private List<IASTInitializerClause> expressionList() throws EndOfFileException, BacktrackException {
@ -3896,7 +3900,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
// { } // { }
if (LT(1) == IToken.tRBRACE) { if (LT(1) == IToken.tRBRACE) {
return setRange(nodeFactory.newInitializerList(), offset, consume().getEndOffset()); return setRange(getNodeFactory().newInitializerList(), offset, consume().getEndOffset());
} }
// { initializer-list ,opt } // { initializer-list ,opt }
@ -3905,7 +3909,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
consume(); consume();
int endOffset= consumeOrEOC(IToken.tRBRACE).getEndOffset(); int endOffset= consumeOrEOC(IToken.tRBRACE).getEndOffset();
ICPPASTInitializerList result = nodeFactory.newInitializerList(); ICPPASTInitializerList result = getNodeFactory().newInitializerList();
for (IASTInitializerClause init : initList) { for (IASTInitializerClause init : initList) {
result.addClause(init); result.addClause(init);
} }
@ -3937,7 +3941,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
adjustEndOffset(clause, endOffset); adjustEndOffset(clause, endOffset);
} else if (clause instanceof IASTExpression) { } else if (clause instanceof IASTExpression) {
// Wrap pack expanded assignment expressions // Wrap pack expanded assignment expressions
IASTExpression packExpansion= nodeFactory.newPackExpansionExpression((IASTExpression) clause); IASTExpression packExpansion= getNodeFactory().newPackExpansionExpression((IASTExpression) clause);
clause= setRange(packExpansion, clause, endOffset); clause= setRange(packExpansion, clause, endOffset);
} }
} }
@ -3972,7 +3976,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
// type-ids have no initializers // type-ids have no initializers
throwBacktrack(lie.fDeclarator); throwBacktrack(lie.fDeclarator);
} }
ICPPASTTypeId result = nodeFactory.newTypeId(declSpecifier, declarator); ICPPASTTypeId result = getNodeFactory().newTypeId(declSpecifier, declarator);
setRange(result, offset, figureEndOffset(declSpecifier, declarator)); setRange(result, offset, figureEndOffset(declSpecifier, declarator));
return result; return result;
} }
@ -4035,7 +4039,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
if (option.fAllowAbstract && option.fAllowFunctions) { if (option.fAllowAbstract && option.fAllowFunctions) {
final IToken mark= mark(); final IToken mark= mark();
try { try {
cand1= declarator(pointerOps, hasEllipsis, nodeFactory.newName(), null, cand1= declarator(pointerOps, hasEllipsis, getNodeFactory().newName(), null,
startingOffset, endOffset, strategy, option, attributes); startingOffset, endOffset, strategy, option, attributes);
if (option.fRequireAbstract || !option.fAllowNested || hasEllipsis) if (option.fRequireAbstract || !option.fAllowNested || hasEllipsis)
return cand1; return cand1;
@ -4049,7 +4053,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
// type-ids for new or operator-id: // type-ids for new or operator-id:
if (!option.fAllowNested || hasEllipsis) { if (!option.fAllowNested || hasEllipsis) {
if (option.fAllowAbstract) { if (option.fAllowAbstract) {
return declarator(pointerOps, hasEllipsis, nodeFactory.newName(), null, return declarator(pointerOps, hasEllipsis, getNodeFactory().newName(), null,
startingOffset, endOffset, strategy, option, attributes); startingOffset, endOffset, strategy, option, attributes);
} }
throwBacktrack(LA(1)); throwBacktrack(LA(1));
@ -4063,7 +4067,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
final IASTDeclarator nested= declarator(DtorStrategy.PREFER_FUNCTION, option); final IASTDeclarator nested= declarator(DtorStrategy.PREFER_FUNCTION, option);
endOffset= consume(IToken.tRPAREN).getEndOffset(); 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); startingOffset, endOffset, strategy, option, attributes);
if (cand1 == null || cand1End == null) if (cand1 == null || cand1End == null)
return cand2; return cand2;
@ -4091,7 +4095,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
if (!option.fAllowBitField || LT(1) != IToken.tCOLON) if (!option.fAllowBitField || LT(1) != IToken.tCOLON)
throwBacktrack(LA(1)); throwBacktrack(LA(1));
} }
return declarator(pointerOps, hasEllipsis, nodeFactory.newName(), null, startingOffset, return declarator(pointerOps, hasEllipsis, getNodeFactory().newName(), null, startingOffset,
endOffset, strategy, option, attributes); endOffset, strategy, option, attributes);
} }
@ -4122,7 +4126,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
if (allowCPPRestrict && LT(1) == IToken.t_restrict) { if (allowCPPRestrict && LT(1) == IToken.t_restrict) {
endToken= consume(); endToken= consume();
} }
ICPPASTReferenceOperator refOp = nodeFactory.newReferenceOperator(lt1 == IToken.tAND); ICPPASTReferenceOperator refOp = getNodeFactory().newReferenceOperator(lt1 == IToken.tAND);
setRange(refOp, offset, endToken.getEndOffset()); setRange(refOp, offset, endToken.getEndOffset());
attributes = CollectionUtils.merge(attributes, attributeSpecifierSeq()); attributes = CollectionUtils.merge(attributes, attributeSpecifierSeq());
@ -4192,9 +4196,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
IASTPointer pointer; IASTPointer pointer;
if (name != null) { if (name != null) {
pointer= nodeFactory.newPointerToMember(name); pointer= getNodeFactory().newPointerToMember(name);
} else { } else {
pointer = nodeFactory.newPointer(); pointer = getNodeFactory().newPointer();
} }
pointer.setConst(isConst); pointer.setConst(isConst);
pointer.setVolatile(isVolatile); pointer.setVolatile(isVolatile);
@ -4263,7 +4267,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
__attribute_decl_seq(supportAttributeSpecifiers, supportDeclspecSpecifiers)); __attribute_decl_seq(supportAttributeSpecifiers, supportDeclspecSpecifiers));
if (result == null) { if (result == null) {
result= nodeFactory.newDeclarator(null); result= getNodeFactory().newDeclarator(null);
setDeclaratorID(result, hasEllipsis, declaratorName, nestedDeclarator); setDeclaratorID(result, hasEllipsis, declaratorName, nestedDeclarator);
} else { } else {
endOffset= calculateEndOffset(result); endOffset= calculateEndOffset(result);
@ -4292,7 +4296,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
private void setDeclaratorID(ICPPASTDeclarator declarator, boolean hasEllipsis, IASTName declaratorName, IASTDeclarator nestedDeclarator) { private void setDeclaratorID(ICPPASTDeclarator declarator, boolean hasEllipsis, IASTName declaratorName, IASTDeclarator nestedDeclarator) {
if (nestedDeclarator != null) { if (nestedDeclarator != null) {
declarator.setNestedDeclarator(nestedDeclarator); declarator.setNestedDeclarator(nestedDeclarator);
declarator.setName(nodeFactory.newName()); declarator.setName(getNodeFactory().newName());
} else { } else {
declarator.setName(declaratorName); declarator.setName(declaratorName);
} }
@ -4307,7 +4311,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
final int startOffset= last.getOffset(); final int startOffset= last.getOffset();
int endOffset= last.getEndOffset(); int endOffset= last.getEndOffset();
final ICPPASTFunctionDeclarator fc = nodeFactory.newFunctionDeclarator(null); final ICPPASTFunctionDeclarator fc = getNodeFactory().newFunctionDeclarator(null);
ICPPASTParameterDeclaration pd= null; ICPPASTParameterDeclaration pd= null;
paramLoop: while(true) { paramLoop: while(true) {
switch (LT(1)) { switch (LT(1)) {
@ -4417,7 +4421,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
thendoffset = consume().getEndOffset(); thendoffset = consume().getEndOffset();
} }
IASTProblem p = createProblem(IProblem.SYNTAX_ERROR, thoffset, thendoffset - thoffset); IASTProblem p = createProblem(IProblem.SYNTAX_ERROR, thoffset, thendoffset - thoffset);
IASTProblemTypeId typeIdProblem = nodeFactory.newProblemTypeId(p); IASTProblemTypeId typeIdProblem = getNodeFactory().newProblemTypeId(p);
((ASTNode) typeIdProblem).setOffsetAndLength(((ASTNode) p)); ((ASTNode) typeIdProblem).setOffsetAndLength(((ASTNode) p));
fc.addExceptionSpecificationTypeId(typeIdProblem); fc.addExceptionSpecificationTypeId(typeIdProblem);
} }
@ -4471,7 +4475,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
throwBacktrack(LA(1)); throwBacktrack(LA(1));
final int endOffset = calculateEndOffset(arrayMods.get(arrayMods.size() - 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) { for (IASTArrayModifier m : arrayMods) {
d.addArrayModifier(m); d.addArrayModifier(m);
} }
@ -4489,7 +4493,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
final IASTExpression bitField = constantExpression(); final IASTExpression bitField = constantExpression();
final int endOffset = calculateEndOffset(bitField); final int endOffset = calculateEndOffset(bitField);
ICPPASTFieldDeclarator d = nodeFactory.newFieldDeclarator(null, bitField); ICPPASTFieldDeclarator d = getNodeFactory().newFieldDeclarator(null, bitField);
((ASTNode) d).setOffsetAndLength(start, endOffset-start); ((ASTNode) d).setOffsetAndLength(start, endOffset-start);
return d; return d;
} }
@ -4534,13 +4538,13 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
if (LT(1) == IToken.tIDENTIFIER) { if (LT(1) == IToken.tIDENTIFIER) {
name = qualifiedName(); name = qualifiedName();
} else { } else {
name = nodeFactory.newName(); name = getNodeFactory().newName();
} }
// if __attribute__ or __declspec occurs after struct/union/class identifier and before the { or ; // if __attribute__ or __declspec occurs after struct/union/class identifier and before the { or ;
attributes = CollectionUtils.merge(attributes, __attribute_decl_seq(supportAttributeSpecifiers, supportDeclspecSpecifiers)); attributes = CollectionUtils.merge(attributes, __attribute_decl_seq(supportAttributeSpecifiers, supportDeclspecSpecifiers));
ICPPASTCompositeTypeSpecifier astClassSpecifier = nodeFactory.newCompositeTypeSpecifier(classKind, name); ICPPASTCompositeTypeSpecifier astClassSpecifier = getNodeFactory().newCompositeTypeSpecifier(classKind, name);
addAttributeSpecifiers(attributes, astClassSpecifier); addAttributeSpecifiers(attributes, astClassSpecifier);
// class virt specifier // class virt specifier
@ -4624,7 +4628,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
ContextSensitiveTokenType contextSensitiveType = getContextSensitiveType(token); ContextSensitiveTokenType contextSensitiveType = getContextSensitiveType(token);
if (contextSensitiveType == ContextSensitiveTokenType.FINAL) { if (contextSensitiveType == ContextSensitiveTokenType.FINAL) {
consume(); consume();
ICPPASTClassVirtSpecifier spec = nodeFactory.newClassVirtSpecifier( ICPPASTClassVirtSpecifier spec = getNodeFactory().newClassVirtSpecifier(
ICPPASTClassVirtSpecifier.SpecifierKind.Final); ICPPASTClassVirtSpecifier.SpecifierKind.Final);
setRange(spec, token.getOffset(), token.getOffset() + token.getLength()); setRange(spec, token.getOffset(), token.getOffset() + token.getLength());
astClassSpecifier.setVirtSpecifier(spec); astClassSpecifier.setVirtSpecifier(spec);
@ -4668,7 +4672,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
} }
} }
nameSpec = nameSpecifier(); nameSpec = nameSpecifier();
ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier baseSpec = nodeFactory.newBaseSpecifier(nameSpec, visibility, isVirtual); ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier baseSpec = getNodeFactory().newBaseSpecifier(nameSpec, visibility, isVirtual);
setRange(baseSpec, startOffset, calculateEndOffset(nameSpec)); setRange(baseSpec, startOffset, calculateEndOffset(nameSpec));
return baseSpec; return baseSpec;
} }
@ -4698,12 +4702,12 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
} catch (BacktrackException bte) { } catch (BacktrackException bte) {
failParse(); failParse();
IASTProblem p = createProblem(bte); IASTProblem p = createProblem(bte);
IASTProblemDeclaration pd = nodeFactory.newProblemDeclaration(p); IASTProblemDeclaration pd = getNodeFactory().newProblemDeclaration(p);
((ASTNode) pd).setOffsetAndLength(((ASTNode) p)); ((ASTNode) pd).setOffsetAndLength(((ASTNode) p));
decl = pd; decl = pd;
} }
ICPPASTCatchHandler handler = nodeFactory.newCatchHandler(decl, null); ICPPASTCatchHandler handler = getNodeFactory().newCatchHandler(decl, null);
if (LT(1) != IToken.tEOC) { if (LT(1) != IToken.tEOC) {
IASTStatement compoundStatement = catchBlockCompoundStatement(); IASTStatement compoundStatement = catchBlockCompoundStatement();
@ -4735,7 +4739,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
} }
final int endOffset = figureEndOffset(declSpec, declarator); final int endOffset = figureEndOffset(declSpec, declarator);
final IASTSimpleDeclaration decl= nodeFactory.newSimpleDeclaration(declSpec); final IASTSimpleDeclaration decl= getNodeFactory().newSimpleDeclaration(declSpec);
if (declarator != null) if (declarator != null)
decl.addDeclarator(declarator); decl.addDeclarator(declarator);
((ASTNode) decl).setOffsetAndLength(startOffset, endOffset - startOffset); ((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()) { if (mode == ParserMode.QUICK_PARSE || mode == ParserMode.STRUCTURAL_PARSE || !isActiveCode()) {
int offset = LA(1).getOffset(); int offset = LA(1).getOffset();
IToken last = skipOverCompoundStatement(true); IToken last = skipOverCompoundStatement(true);
IASTCompoundStatement cs = nodeFactory.newCompoundStatement(); IASTCompoundStatement cs = getNodeFactory().newCompoundStatement();
setRange(cs, offset, last.getEndOffset()); setRange(cs, offset, last.getEndOffset());
return cs; return cs;
} else if (mode == ParserMode.COMPLETION_PARSE || mode == ParserMode.SELECTION_PARSE) { } else if (mode == ParserMode.COMPLETION_PARSE || mode == ParserMode.SELECTION_PARSE) {
@ -4755,7 +4759,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
return compoundStatement(); return compoundStatement();
int offset = LA(1).getOffset(); int offset = LA(1).getOffset();
IToken last = skipOverCompoundStatement(true); IToken last = skipOverCompoundStatement(true);
IASTCompoundStatement cs = nodeFactory.newCompoundStatement(); IASTCompoundStatement cs = getNodeFactory().newCompoundStatement();
setRange(cs, offset, last.getEndOffset()); setRange(cs, offset, last.getEndOffset());
return cs; return cs;
} }
@ -4764,7 +4768,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
@Override @Override
protected void setupTranslationUnit() throws DOMException { protected void setupTranslationUnit() throws DOMException {
translationUnit = nodeFactory.newTranslationUnit(scanner); translationUnit = getNodeFactory().newTranslationUnit(scanner);
translationUnit.setIndex(index); translationUnit.setIndex(index);
// Add built-in names to the scope. // Add built-in names to the scope.
@ -4798,7 +4802,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
default: default:
throw backtrack; throw backtrack;
} }
IASTArrayModifier arrayMod = nodeFactory.newArrayModifier(exp); IASTArrayModifier arrayMod = getNodeFactory().newArrayModifier(exp);
((ASTNode) arrayMod).setOffsetAndLength(o, l - o); ((ASTNode) arrayMod).setOffsetAndLength(o, l - o);
List<IASTAttributeSpecifier> attributes = attributeSpecifierSeq(); List<IASTAttributeSpecifier> attributes = attributeSpecifierSeq();
@ -4886,7 +4890,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
IASTStatement tryBlock = compoundStatement(); IASTStatement tryBlock = compoundStatement();
List<ICPPASTCatchHandler> catchHandlers = new ArrayList<ICPPASTCatchHandler>(DEFAULT_CATCH_HANDLER_LIST_SIZE); List<ICPPASTCatchHandler> catchHandlers = new ArrayList<ICPPASTCatchHandler>(DEFAULT_CATCH_HANDLER_LIST_SIZE);
catchHandlerSequence(catchHandlers); catchHandlerSequence(catchHandlers);
ICPPASTTryBlockStatement tryStatement = nodeFactory.newTryBlockStatement(tryBlock); ICPPASTTryBlockStatement tryStatement = getNodeFactory().newTryBlockStatement(tryBlock);
((ASTNode) tryStatement).setOffset(startO); ((ASTNode) tryStatement).setOffset(startO);
for (int i = 0; i < catchHandlers.size(); ++i) { for (int i = 0; i < catchHandlers.size(); ++i) {
@ -4922,9 +4926,9 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
IASTWhileStatement while_statement; IASTWhileStatement while_statement;
if (while_condition instanceof IASTExpression) if (while_condition instanceof IASTExpression)
while_statement = nodeFactory.newWhileStatement((IASTExpression)while_condition, while_body); while_statement = getNodeFactory().newWhileStatement((IASTExpression)while_condition, while_body);
else else
while_statement = nodeFactory.newWhileStatement((IASTDeclaration)while_condition, while_body); while_statement = getNodeFactory().newWhileStatement((IASTDeclaration)while_condition, while_body);
((ASTNode) while_statement).setOffsetAndLength(startOffset, ((ASTNode) while_statement).setOffsetAndLength(startOffset,
(while_body != null ? calculateEndOffset(while_body) : LA(1).getEndOffset()) - 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); IASTNode condition= cppStyleCondition(IToken.tRPAREN);
if (LT(1) == IToken.tEOC) { if (LT(1) == IToken.tEOC) {
// Completing in the condition // Completing in the condition
ICPPASTIfStatement new_if = nodeFactory.newIfStatement(); ICPPASTIfStatement new_if = getNodeFactory().newIfStatement();
if (condition instanceof IASTExpression) if (condition instanceof IASTExpression)
new_if.setConditionExpression((IASTExpression) condition); new_if.setConditionExpression((IASTExpression) condition);
else if (condition instanceof IASTDeclaration) else if (condition instanceof IASTDeclaration)
@ -5019,7 +5023,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
consume(IToken.tRPAREN); consume(IToken.tRPAREN);
IASTStatement thenClause = statement(); IASTStatement thenClause = statement();
ICPPASTIfStatement new_if_statement = nodeFactory.newIfStatement(); ICPPASTIfStatement new_if_statement = getNodeFactory().newIfStatement();
((ASTNode) new_if_statement).setOffset(so); ((ASTNode) new_if_statement).setOffset(so);
if (condition != null && (condition instanceof IASTExpression || condition instanceof IASTDeclaration)) if (condition != null && (condition instanceof IASTExpression || condition instanceof IASTDeclaration))
// shouldn't be possible but failure in condition() makes it so // shouldn't be possible but failure in condition() makes it so
@ -5107,7 +5111,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
} }
IASTStatement switch_body = parseSwitchBody(); IASTStatement switch_body = parseSwitchBody();
ICPPASTSwitchStatement switch_statement = nodeFactory.newSwitchStatement(); ICPPASTSwitchStatement switch_statement = getNodeFactory().newSwitchStatement();
((ASTNode) switch_statement).setOffsetAndLength(startOffset, ((ASTNode) switch_statement).setOffsetAndLength(startOffset,
(switch_body != null ? calculateEndOffset(switch_body) : LA(1).getEndOffset()) - startOffset); (switch_body != null ? calculateEndOffset(switch_body) : LA(1).getEndOffset()) - startOffset);
if (switch_condition instanceof IASTExpression) { if (switch_condition instanceof IASTExpression) {
@ -5170,7 +5174,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
init= expression(); init= expression();
} }
ICPPASTRangeBasedForStatement result = nodeFactory.newRangeBasedForStatement(); ICPPASTRangeBasedForStatement result = getNodeFactory().newRangeBasedForStatement();
result.setDeclaration(decl); result.setDeclaration(decl);
result.setInitializerClause(init); result.setInitializerClause(init);
return result; return result;
@ -5192,7 +5196,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
iterExpr = expression(); iterExpr = expression();
} }
ICPPASTForStatement result = nodeFactory.newForStatement(); ICPPASTForStatement result = getNodeFactory().newForStatement();
result.setInitializerStatement(initStmt); result.setInitializerStatement(initStmt);
if (condition instanceof IASTExpression) { if (condition instanceof IASTExpression) {
result.setConditionExpression((IASTExpression) condition); result.setConditionExpression((IASTExpression) condition);
@ -5218,7 +5222,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser {
// Semicolon // Semicolon
final int endOffset= consumeOrEOC(IToken.tSEMI).getEndOffset(); final int endOffset= consumeOrEOC(IToken.tSEMI).getEndOffset();
return setRange(nodeFactory.newReturnStatement(expr), offset, endOffset); return setRange(getNodeFactory().newReturnStatement(expr), offset, endOffset);
} }
@Override @Override