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

Removed lastToken from DOM Parsers.

Browse source
This commit is contained in:
John Camelon 2005-01-12 16:43:43 +00:00
parent 703ec24b6c
commit ea5fe525ea
3 changed files with 435 additions and 367 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -21,8 +21,10 @@ import org.eclipse.cdt.core.dom.ast.IASTCastExpression;
import org.eclipse.cdt.core.dom.ast.IASTCompoundStatement; import org.eclipse.cdt.core.dom.ast.IASTCompoundStatement;
import org.eclipse.cdt.core.dom.ast.IASTConditionalExpression; import org.eclipse.cdt.core.dom.ast.IASTConditionalExpression;
import org.eclipse.cdt.core.dom.ast.IASTContinueStatement; import org.eclipse.cdt.core.dom.ast.IASTContinueStatement;
import org.eclipse.cdt.core.dom.ast.IASTDeclSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTDeclaration; import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTDeclarationStatement; import org.eclipse.cdt.core.dom.ast.IASTDeclarationStatement;
import org.eclipse.cdt.core.dom.ast.IASTDeclarator;
import org.eclipse.cdt.core.dom.ast.IASTDefaultStatement; import org.eclipse.cdt.core.dom.ast.IASTDefaultStatement;
import org.eclipse.cdt.core.dom.ast.IASTDoStatement; import org.eclipse.cdt.core.dom.ast.IASTDoStatement;
import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier; import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier;
@ -100,8 +102,6 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
} }
protected IToken currToken; protected IToken currToken;
protected IToken lastToken;
protected IToken prevLastToken;
/** /**
* Look Ahead in the token list to see what is coming. * Look Ahead in the token list to see what is coming.
@ -144,8 +144,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
return LA(i).getType(); return LA(i).getType();
} }
protected int calculateEndOffset( IASTNode n ) protected int calculateEndOffset(IASTNode n) {
{
ASTNode node = (ASTNode) n; ASTNode node = (ASTNode) n;
return node.getOffset() + node.getLength(); return node.getOffset() + node.getLength();
} }
@ -161,10 +160,9 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
if (currToken == null) if (currToken == null)
currToken = fetchToken(); currToken = fetchToken();
if (currToken != null) { IToken lastToken = null;
prevLastToken = lastToken; if (currToken != null)
lastToken = currToken; lastToken = currToken;
}
currToken = currToken.getNext(); currToken = currToken.getNext();
return lastToken; return lastToken;
} }
@ -242,7 +240,6 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
*/ */
protected void backup(IToken mark) { protected void backup(IToken mark) {
currToken = mark; currToken = mark;
lastToken = prevLastToken;
} }
/** /**
@ -367,15 +364,6 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
private static final int DEFAULT_COMPOUNDSTATEMENT_LIST_SIZE = 8; private static final int DEFAULT_COMPOUNDSTATEMENT_LIST_SIZE = 8;
/**
*
*/
protected void cleanupLastToken() {
if (lastToken != null)
lastToken.setNext(null);
simpleDeclarationMark = null;
}
public IASTTranslationUnit parse() { public IASTTranslationUnit parse() {
long startTime = System.currentTimeMillis(); long startTime = System.currentTimeMillis();
translationUnit(); translationUnit();
@ -396,14 +384,16 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
*/ */
protected abstract void nullifyTranslationUnit(); protected abstract void nullifyTranslationUnit();
protected void skipOverCompoundStatement() throws BacktrackException, protected IToken skipOverCompoundStatement() throws BacktrackException,
EndOfFileException { EndOfFileException {
// speed up the parser by skiping the body // speed up the parser by skiping the body
// simply look for matching brace and return // simply look for matching brace and return
consume(IToken.tLBRACE); consume(IToken.tLBRACE);
IToken result = null;
int depth = 1; int depth = 1;
while (depth > 0) { while (depth > 0) {
switch (consume().getType()) { result = consume();
switch (result.getType()) {
case IToken.tRBRACE: case IToken.tRBRACE:
--depth; --depth;
break; break;
@ -412,6 +402,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
break; break;
} }
} }
return result;
} }
/** /**
@ -582,7 +573,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
secondExpression.setParent(expressionList); secondExpression.setParent(expressionList);
secondExpression secondExpression
.setPropertyInParent(IASTExpressionList.NESTED_EXPRESSION); .setPropertyInParent(IASTExpressionList.NESTED_EXPRESSION);
lastOffset = lastToken.getEndOffset(); lastOffset = calculateEndOffset(secondExpression);
} }
((ASTNode) expressionList).setLength(lastOffset - startingOffset); ((ASTNode) expressionList).setLength(lastOffset - startingOffset);
return expressionList; return expressionList;
@ -622,7 +613,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
IASTExpression lhs) throws EndOfFileException, BacktrackException { IASTExpression lhs) throws EndOfFileException, BacktrackException {
consume(); consume();
IASTExpression rhs = assignmentExpression(); IASTExpression rhs = assignmentExpression();
return buildBinaryExpression(kind, lhs, rhs, lastToken.getEndOffset()); return buildBinaryExpression(kind, lhs, rhs, calculateEndOffset(rhs));
} }
/** /**
@ -646,7 +637,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
IASTExpression secondExpression = logicalAndExpression(); IASTExpression secondExpression = logicalAndExpression();
firstExpression = buildBinaryExpression( firstExpression = buildBinaryExpression(
IASTBinaryExpression.op_logicalOr, firstExpression, IASTBinaryExpression.op_logicalOr, firstExpression,
secondExpression, lastToken.getEndOffset()); secondExpression, calculateEndOffset(secondExpression));
} }
return firstExpression; return firstExpression;
} }
@ -663,7 +654,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
IASTExpression secondExpression = inclusiveOrExpression(); IASTExpression secondExpression = inclusiveOrExpression();
firstExpression = buildBinaryExpression( firstExpression = buildBinaryExpression(
IASTBinaryExpression.op_logicalAnd, firstExpression, IASTBinaryExpression.op_logicalAnd, firstExpression,
secondExpression, lastToken.getEndOffset()); secondExpression, calculateEndOffset(secondExpression));
} }
return firstExpression; return firstExpression;
} }
@ -680,7 +671,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
IASTExpression secondExpression = exclusiveOrExpression(); IASTExpression secondExpression = exclusiveOrExpression();
firstExpression = buildBinaryExpression( firstExpression = buildBinaryExpression(
IASTBinaryExpression.op_binaryOr, firstExpression, IASTBinaryExpression.op_binaryOr, firstExpression,
secondExpression, lastToken.getEndOffset()); secondExpression, calculateEndOffset(secondExpression));
} }
return firstExpression; return firstExpression;
} }
@ -697,7 +688,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
IASTExpression secondExpression = andExpression(); IASTExpression secondExpression = andExpression();
firstExpression = buildBinaryExpression( firstExpression = buildBinaryExpression(
IASTBinaryExpression.op_binaryXor, firstExpression, IASTBinaryExpression.op_binaryXor, firstExpression,
secondExpression, lastToken.getEndOffset()); secondExpression, calculateEndOffset(secondExpression));
} }
return firstExpression; return firstExpression;
} }
@ -715,7 +706,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
IASTExpression secondExpression = equalityExpression(); IASTExpression secondExpression = equalityExpression();
firstExpression = buildBinaryExpression( firstExpression = buildBinaryExpression(
IASTBinaryExpression.op_binaryAnd, firstExpression, IASTBinaryExpression.op_binaryAnd, firstExpression,
secondExpression, lastToken.getEndOffset()); secondExpression, calculateEndOffset(secondExpression));
} }
return firstExpression; return firstExpression;
} }
@ -736,8 +727,8 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
: IASTBinaryExpression.op_notequals); : IASTBinaryExpression.op_notequals);
IASTExpression secondExpression = relationalExpression(); IASTExpression secondExpression = relationalExpression();
firstExpression = buildBinaryExpression(operator, firstExpression = buildBinaryExpression(operator,
firstExpression, secondExpression, lastToken firstExpression, secondExpression,
.getEndOffset()); calculateEndOffset(secondExpression));
break; break;
default: default:
return firstExpression; return firstExpression;
@ -782,8 +773,8 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
: IASTBinaryExpression.op_shiftRight; : IASTBinaryExpression.op_shiftRight;
IASTExpression secondExpression = additiveExpression(); IASTExpression secondExpression = additiveExpression();
firstExpression = buildBinaryExpression(operator, firstExpression = buildBinaryExpression(operator,
firstExpression, secondExpression, lastToken firstExpression, secondExpression,
.getEndOffset()); calculateEndOffset(secondExpression));
break; break;
default: default:
return firstExpression; return firstExpression;
@ -807,8 +798,8 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
: IASTBinaryExpression.op_minus; : IASTBinaryExpression.op_minus;
IASTExpression secondExpression = multiplicativeExpression(); IASTExpression secondExpression = multiplicativeExpression();
firstExpression = buildBinaryExpression(operator, firstExpression = buildBinaryExpression(operator,
firstExpression, secondExpression, lastToken firstExpression, secondExpression,
.getEndOffset()); calculateEndOffset(secondExpression));
break; break;
default: default:
return firstExpression; return firstExpression;
@ -856,8 +847,8 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
throws EndOfFileException, BacktrackException { throws EndOfFileException, BacktrackException {
int offset = consume().getOffset(); int offset = consume().getOffset();
IASTExpression castExpression = castExpression(); IASTExpression castExpression = castExpression();
return buildUnaryExpression(operator, castExpression, offset, lastToken return buildUnaryExpression(operator, castExpression, offset,
.getEndOffset()); calculateEndOffset(castExpression));
} }
/** /**
@ -909,10 +900,11 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
backup(m); backup(m);
d = null; d = null;
unaryExpression = unaryExpression(); unaryExpression = unaryExpression();
lastOffset = lastToken.getEndOffset(); lastOffset = calculateEndOffset(unaryExpression);
} }
} else { } else {
unaryExpression = unaryExpression(); unaryExpression = unaryExpression();
lastOffset = calculateEndOffset(unaryExpression);
} }
if (d != null & unaryExpression == null) if (d != null & unaryExpression == null)
return buildTypeIdExpression(IGNUASTTypeIdExpression.op_alignof, d, return buildTypeIdExpression(IGNUASTTypeIdExpression.op_alignof, d,
@ -934,7 +926,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
if (LT(1) == IToken.tLPAREN) { if (LT(1) == IToken.tLPAREN) {
if (LT(2) == IToken.tLBRACE) { if (LT(2) == IToken.tLBRACE) {
unaryExpression = compoundStatementExpression(); unaryExpression = compoundStatementExpression();
lastOffset = lastToken.getEndOffset(); lastOffset = calculateEndOffset(unaryExpression);
} else } else
try { try {
consume(IToken.tLPAREN); consume(IToken.tLPAREN);
@ -944,10 +936,11 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
backup(m); backup(m);
d = null; d = null;
unaryExpression = unaryExpression(); unaryExpression = unaryExpression();
lastOffset = lastToken.getEndOffset(); lastOffset = calculateEndOffset(unaryExpression);
} }
} else { } else {
unaryExpression = unaryExpression(); unaryExpression = unaryExpression();
lastOffset = calculateEndOffset(unaryExpression);
} }
if (d != null & unaryExpression == null) if (d != null & unaryExpression == null)
return buildTypeIdExpression(IGNUASTTypeIdExpression.op_typeof, d, return buildTypeIdExpression(IGNUASTTypeIdExpression.op_typeof, d,
@ -961,14 +954,24 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
protected IASTStatement handleFunctionBody() throws BacktrackException, protected IASTStatement handleFunctionBody() throws BacktrackException,
EndOfFileException { EndOfFileException {
if (mode == ParserMode.QUICK_PARSE || mode == ParserMode.STRUCTURAL_PARSE) { if (mode == ParserMode.QUICK_PARSE || mode == ParserMode.STRUCTURAL_PARSE) {
skipOverCompoundStatement(); IToken curr = LA(1);
return null; IToken last = skipOverCompoundStatement();
IASTCompoundStatement cs = createCompoundStatement();
((ASTNode) cs).setOffsetAndLength(curr.getOffset(), last
.getEndOffset()
- curr.getOffset());
return cs;
} else if (mode == ParserMode.COMPLETION_PARSE } else if (mode == ParserMode.COMPLETION_PARSE
|| mode == ParserMode.SELECTION_PARSE) { || mode == ParserMode.SELECTION_PARSE) {
if (scanner.isOnTopContext()) if (scanner.isOnTopContext())
return functionBody(); return functionBody();
skipOverCompoundStatement(); IToken curr = LA(1);
return null; IToken last = skipOverCompoundStatement();
IASTCompoundStatement cs = createCompoundStatement();
((ASTNode) cs).setOffsetAndLength(curr.getOffset(), last
.getEndOffset()
- curr.getOffset());
return cs;
} else if (mode == ParserMode.COMPLETE_PARSE) } else if (mode == ParserMode.COMPLETE_PARSE)
return functionBody(); return functionBody();
return null; return null;
@ -1102,12 +1105,15 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
result.setName(name); result.setName(name);
name.setParent(result); name.setParent(result);
name.setPropertyInParent(IASTEnumerationSpecifier.ENUMERATION_NAME); name.setPropertyInParent(IASTEnumerationSpecifier.ENUMERATION_NAME);
cleanupLastToken();
consume(IToken.tLBRACE); consume(IToken.tLBRACE);
while (LT(1) != IToken.tRBRACE) { while (LT(1) != IToken.tRBRACE) {
IASTName enumeratorName = null; IASTName enumeratorName = null;
int lastOffset = 0;
if (LT(1) == IToken.tIDENTIFIER) { if (LT(1) == IToken.tIDENTIFIER) {
enumeratorName = createName(identifier()); enumeratorName = createName(identifier());
lastOffset = calculateEndOffset(enumeratorName);
} else { } else {
IToken la = LA(1); IToken la = LA(1);
throwBacktrack(la.getOffset(), la.getLength()); throwBacktrack(la.getOffset(), la.getLength());
@ -1116,14 +1122,14 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
if (LT(1) == IToken.tASSIGN) { if (LT(1) == IToken.tASSIGN) {
consume(IToken.tASSIGN); consume(IToken.tASSIGN);
initialValue = constantExpression(); initialValue = constantExpression();
lastOffset = calculateEndOffset(initialValue);
} }
IASTEnumerationSpecifier.IASTEnumerator enumerator = null; IASTEnumerationSpecifier.IASTEnumerator enumerator = null;
if (LT(1) == IToken.tRBRACE) { if (LT(1) == IToken.tRBRACE) {
enumerator = createEnumerator(); enumerator = createEnumerator();
enumerator.setName(enumeratorName); enumerator.setName(enumeratorName);
((ASTNode) enumerator).setOffsetAndLength( ((ASTNode) enumerator).setOffsetAndLength(
((ASTNode) enumeratorName).getOffset(), lastToken ((ASTNode) enumeratorName).getOffset(), lastOffset
.getEndOffset()
- ((ASTNode) enumeratorName).getOffset()); - ((ASTNode) enumeratorName).getOffset());
enumeratorName.setParent(enumerator); enumeratorName.setParent(enumerator);
enumeratorName enumeratorName
@ -1138,7 +1144,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
enumerator.setParent(result); enumerator.setParent(result);
enumerator enumerator
.setPropertyInParent(IASTEnumerationSpecifier.ENUMERATOR); .setPropertyInParent(IASTEnumerationSpecifier.ENUMERATOR);
cleanupLastToken();
break; break;
} }
if (LT(1) != IToken.tCOMMA) { if (LT(1) != IToken.tCOMMA) {
@ -1148,8 +1154,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
enumerator = createEnumerator(); enumerator = createEnumerator();
enumerator.setName(enumeratorName); enumerator.setName(enumeratorName);
((ASTNode) enumerator).setOffsetAndLength( ((ASTNode) enumerator).setOffsetAndLength(
((ASTNode) enumeratorName).getOffset(), lastToken ((ASTNode) enumeratorName).getOffset(), lastOffset
.getEndOffset()
- ((ASTNode) enumeratorName).getOffset()); - ((ASTNode) enumeratorName).getOffset());
enumeratorName.setParent(enumerator); enumeratorName.setParent(enumerator);
enumeratorName enumeratorName
@ -1163,7 +1168,6 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
result.addEnumerator(enumerator); result.addEnumerator(enumerator);
enumerator.setParent(result); enumerator.setParent(result);
enumerator.setPropertyInParent(IASTEnumerationSpecifier.ENUMERATOR); enumerator.setPropertyInParent(IASTEnumerationSpecifier.ENUMERATOR);
cleanupLastToken();
consume(IToken.tCOMMA); consume(IToken.tCOMMA);
} }
@ -1207,7 +1211,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
protected IASTExpression condition() throws BacktrackException, protected IASTExpression condition() throws BacktrackException,
EndOfFileException { EndOfFileException {
IASTExpression cond = expression(); IASTExpression cond = expression();
cleanupLastToken();
return cond; return cond;
} }
@ -1313,7 +1317,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
String assembly = consume(IToken.tSTRING).getImage(); String assembly = consume(IToken.tSTRING).getImage();
consume(IToken.tRPAREN); consume(IToken.tRPAREN);
int lastOffset = consume(IToken.tSEMI).getEndOffset(); int lastOffset = consume(IToken.tSEMI).getEndOffset();
cleanupLastToken();
return buildASMDirective(first.getOffset(), assembly, lastOffset); return buildASMDirective(first.getOffset(), assembly, lastOffset);
} }
@ -1411,7 +1415,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
} }
if (expressionStatement == null && ds != null) { if (expressionStatement == null && ds != null) {
cleanupLastToken();
return ds; return ds;
} }
if (expressionStatement != null && ds == null) { if (expressionStatement != null && ds == null) {
@ -1419,7 +1423,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
if (consume() == lastTokenOfExpression) if (consume() == lastTokenOfExpression)
break; break;
} }
cleanupLastToken();
return expressionStatement; return expressionStatement;
} }
@ -1435,12 +1439,12 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
IASTExpression lhs = exp.getOperand1(); IASTExpression lhs = exp.getOperand1();
if (lhs instanceof IASTBinaryExpression if (lhs instanceof IASTBinaryExpression
&& ((IASTBinaryExpression) lhs).getOperator() == IASTBinaryExpression.op_multiply) { && ((IASTBinaryExpression) lhs).getOperator() == IASTBinaryExpression.op_multiply) {
cleanupLastToken();
return ds; return ds;
} }
if (lhs instanceof IASTBinaryExpression if (lhs instanceof IASTBinaryExpression
&& ((IASTBinaryExpression) lhs).getOperator() == IASTBinaryExpression.op_binaryAnd) { && ((IASTBinaryExpression) lhs).getOperator() == IASTBinaryExpression.op_binaryAnd) {
cleanupLastToken();
return ds; return ds;
} }
} }
@ -1458,7 +1462,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
if (consume() == lastTokenOfExpression) if (consume() == lastTokenOfExpression)
break; break;
} }
cleanupLastToken();
return expressionStatement; return expressionStatement;
} }
backup(mark); backup(mark);
@ -1466,7 +1470,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
if (consume() == lastTokenOfExpression) if (consume() == lastTokenOfExpression)
break; break;
} }
cleanupLastToken();
return expressionStatement; return expressionStatement;
} }
@ -1497,7 +1501,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
protected IASTStatement parseNullStatement() throws EndOfFileException, protected IASTStatement parseNullStatement() throws EndOfFileException,
BacktrackException { BacktrackException {
IToken t = consume(IToken.tSEMI); IToken t = consume(IToken.tSEMI);
cleanupLastToken();
IASTNullStatement null_statement = createNullStatement(); IASTNullStatement null_statement = createNullStatement();
((ASTNode) null_statement).setOffsetAndLength(t.getOffset(), t ((ASTNode) null_statement).setOffsetAndLength(t.getOffset(), t
.getEndOffset() .getEndOffset()
@ -1515,7 +1519,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
int startOffset = consume(IToken.t_goto).getOffset(); int startOffset = consume(IToken.t_goto).getOffset();
IToken identifier = consume(IToken.tIDENTIFIER); IToken identifier = consume(IToken.tIDENTIFIER);
int lastOffset = consume(IToken.tSEMI).getEndOffset(); int lastOffset = consume(IToken.tSEMI).getEndOffset();
cleanupLastToken();
IASTName goto_label_name = createName(identifier); IASTName goto_label_name = createName(identifier);
IASTGotoStatement goto_statement = createGoToStatement(); IASTGotoStatement goto_statement = createGoToStatement();
((ASTNode) goto_statement).setOffsetAndLength(startOffset, lastOffset ((ASTNode) goto_statement).setOffsetAndLength(startOffset, lastOffset
@ -1535,7 +1539,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
BacktrackException { BacktrackException {
int startOffset = consume(IToken.t_break).getOffset(); int startOffset = consume(IToken.t_break).getOffset();
int lastOffset = consume(IToken.tSEMI).getEndOffset(); int lastOffset = consume(IToken.tSEMI).getEndOffset();
cleanupLastToken();
IASTBreakStatement break_statement = createBreakStatement(); IASTBreakStatement break_statement = createBreakStatement();
((ASTNode) break_statement).setOffsetAndLength(startOffset, lastOffset ((ASTNode) break_statement).setOffsetAndLength(startOffset, lastOffset
- startOffset); - startOffset);
@ -1551,7 +1555,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
BacktrackException { BacktrackException {
int startOffset = consume(IToken.t_continue).getOffset(); int startOffset = consume(IToken.t_continue).getOffset();
int lastOffset = consume(IToken.tSEMI).getEndOffset(); int lastOffset = consume(IToken.tSEMI).getEndOffset();
cleanupLastToken();
IASTContinueStatement continue_statement = createContinueStatement(); IASTContinueStatement continue_statement = createContinueStatement();
((ASTNode) continue_statement).setOffsetAndLength(startOffset, lastOffset ((ASTNode) continue_statement).setOffsetAndLength(startOffset, lastOffset
- startOffset); - startOffset);
@ -1570,10 +1574,10 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
IASTExpression result = null; IASTExpression result = null;
if (LT(1) != IToken.tSEMI) { if (LT(1) != IToken.tSEMI) {
result = expression(); result = expression();
cleanupLastToken();
} }
int lastOffset = consume(IToken.tSEMI).getEndOffset(); int lastOffset = consume(IToken.tSEMI).getEndOffset();
cleanupLastToken();
IASTReturnStatement return_statement = createReturnStatement(); IASTReturnStatement return_statement = createReturnStatement();
((ASTNode) return_statement).setOffsetAndLength(startOffset, lastOffset ((ASTNode) return_statement).setOffsetAndLength(startOffset, lastOffset
- startOffset); - startOffset);
@ -1603,15 +1607,14 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
IASTExpression iterationExpression = null; IASTExpression iterationExpression = null;
if (LT(1) != IToken.tRPAREN) { if (LT(1) != IToken.tRPAREN) {
iterationExpression = expression(); iterationExpression = expression();
cleanupLastToken();
} }
consume(IToken.tRPAREN); consume(IToken.tRPAREN);
IASTStatement for_body = statement(); IASTStatement for_body = statement();
IASTForStatement for_statement = createForStatement(); IASTForStatement for_statement = createForStatement();
((ASTNode) for_statement).setOffsetAndLength(startOffset, lastToken ((ASTNode) for_statement).setOffsetAndLength(startOffset,
.getEndOffset() calculateEndOffset(for_body) - startOffset);
- startOffset);
cleanupLastToken();
if (init instanceof IASTDeclaration) { if (init instanceof IASTDeclaration) {
for_statement.setInit((IASTDeclaration) init); for_statement.setInit((IASTDeclaration) init);
((IASTDeclaration) init).setParent(for_statement); ((IASTDeclaration) init).setParent(for_statement);
@ -1653,7 +1656,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
consume(IToken.tLPAREN); consume(IToken.tLPAREN);
IASTExpression do_condition = condition(); IASTExpression do_condition = condition();
int lastOffset = consume(IToken.tRPAREN).getEndOffset(); int lastOffset = consume(IToken.tRPAREN).getEndOffset();
cleanupLastToken();
IASTDoStatement do_statement = createDoStatement(); IASTDoStatement do_statement = createDoStatement();
((ASTNode) do_statement).setOffsetAndLength(startOffset, lastOffset ((ASTNode) do_statement).setOffsetAndLength(startOffset, lastOffset
- startOffset); - startOffset);
@ -1679,11 +1682,10 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
IASTExpression while_condition = condition(); IASTExpression while_condition = condition();
consume(IToken.tRPAREN); consume(IToken.tRPAREN);
IASTStatement while_body = statement(); IASTStatement while_body = statement();
cleanupLastToken();
IASTWhileStatement while_statement = createWhileStatement(); IASTWhileStatement while_statement = createWhileStatement();
((ASTNode) while_statement).setOffsetAndLength(startOffset, lastToken ((ASTNode) while_statement).setOffsetAndLength(startOffset,
.getEndOffset() calculateEndOffset(while_body) - startOffset);
- startOffset);
while_statement.setCondition(while_condition); while_statement.setCondition(while_condition);
while_condition.setParent(while_statement); while_condition.setParent(while_statement);
while_condition.setPropertyInParent(IASTWhileStatement.CONDITION); while_condition.setPropertyInParent(IASTWhileStatement.CONDITION);
@ -1707,11 +1709,10 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
IASTExpression switch_condition = condition(); IASTExpression switch_condition = condition();
consume(IToken.tRPAREN); consume(IToken.tRPAREN);
IASTStatement switch_body = statement(); IASTStatement switch_body = statement();
cleanupLastToken();
IASTSwitchStatement switch_statement = createSwitchStatement(); IASTSwitchStatement switch_statement = createSwitchStatement();
((ASTNode) switch_statement).setOffsetAndLength(startOffset, lastToken ((ASTNode) switch_statement).setOffsetAndLength(startOffset,
.getEndOffset() calculateEndOffset(switch_body) - startOffset);
- startOffset);
switch_statement.setController(switch_condition); switch_statement.setController(switch_condition);
switch_condition.setParent(switch_statement); switch_condition.setParent(switch_statement);
switch_condition.setPropertyInParent(IASTSwitchStatement.CONTROLLER); switch_condition.setPropertyInParent(IASTSwitchStatement.CONTROLLER);
@ -1770,7 +1771,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
consume(IToken.t_else); consume(IToken.t_else);
if (LT(1) == IToken.t_if) { if (LT(1) == IToken.t_if) {
//an else if, don't recurse, just loop and do another if //an else if, don't recurse, just loop and do another if
cleanupLastToken();
if (if_statement != null) { if (if_statement != null) {
if_statement.setElseClause(new_if_statement); if_statement.setElseClause(new_if_statement);
new_if_statement.setParent(if_statement); new_if_statement.setParent(if_statement);
@ -1787,14 +1788,21 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
if_statement.setElseClause(new_if_statement); if_statement.setElseClause(new_if_statement);
new_if_statement.setParent(if_statement); new_if_statement.setParent(if_statement);
new_if_statement.setPropertyInParent(IASTIfStatement.ELSE); new_if_statement.setPropertyInParent(IASTIfStatement.ELSE);
} else ((ASTNode) new_if_statement)
.setLength(calculateEndOffset(new_if_statement) - start);
} else {
((ASTNode) new_if_statement)
.setLength(calculateEndOffset(new_if_statement) - start);
if_statement = new_if_statement; if_statement = new_if_statement;
} else }
} else {
((ASTNode) new_if_statement)
.setLength(calculateEndOffset(new_if_statement) - start);
if_statement = new_if_statement; if_statement = new_if_statement;
}
break if_loop; break if_loop;
} }
cleanupLastToken();
((ASTNode) if_statement).setLength(lastToken.getEndOffset() - start);
return if_statement; return if_statement;
} }
@ -1811,7 +1819,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
protected IASTStatement parseCompoundStatement() throws EndOfFileException, protected IASTStatement parseCompoundStatement() throws EndOfFileException,
BacktrackException { BacktrackException {
IASTCompoundStatement compound = compoundStatement(); IASTCompoundStatement compound = compoundStatement();
cleanupLastToken();
return compound; return compound;
} }
@ -1824,7 +1832,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
BacktrackException { BacktrackException {
int startOffset = consume(IToken.t_default).getOffset(); int startOffset = consume(IToken.t_default).getOffset();
int lastOffset = consume(IToken.tCOLON).getEndOffset(); int lastOffset = consume(IToken.tCOLON).getEndOffset();
cleanupLastToken();
IASTDefaultStatement df = createDefaultStatement(); IASTDefaultStatement df = createDefaultStatement();
((ASTNode) df).setOffsetAndLength(startOffset, lastOffset - startOffset); ((ASTNode) df).setOffsetAndLength(startOffset, lastOffset - startOffset);
return df; return df;
@ -1840,7 +1848,7 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
int startOffset = consume(IToken.t_case).getOffset(); int startOffset = consume(IToken.t_case).getOffset();
IASTExpression case_exp = constantExpression(); IASTExpression case_exp = constantExpression();
int lastOffset = consume(IToken.tCOLON).getEndOffset(); int lastOffset = consume(IToken.tCOLON).getEndOffset();
cleanupLastToken();
IASTCaseStatement cs = createCaseStatement(); IASTCaseStatement cs = createCaseStatement();
((ASTNode) cs).setOffsetAndLength(startOffset, lastOffset - startOffset); ((ASTNode) cs).setOffsetAndLength(startOffset, lastOffset - startOffset);
cs.setExpression(case_exp); cs.setExpression(case_exp);
@ -1849,4 +1857,28 @@ public abstract class AbstractGNUSourceCodeParser implements ISourceCodeParser {
return cs; return cs;
} }
/**
* @param declSpec
* @param declarators
* @return
*/
protected int figureEndOffset(IASTDeclSpecifier declSpec, List declarators) {
if (declarators.isEmpty())
return calculateEndOffset(declSpec);
return calculateEndOffset((IASTDeclarator) declarators.get(declarators
.size() - 1));
}
/**
* @param declSpecifier
* @param declarator
* @return
*/
protected int figureEndOffset(IASTDeclSpecifier declSpecifier,
IASTDeclarator declarator) {
if (declarator == null)
return calculateEndOffset(declSpecifier);
return calculateEndOffset(declarator);
}
} }

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

@ -221,10 +221,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
.setPropertyInParent(IASTInitializerExpression.INITIALIZER_EXPRESSION); .setPropertyInParent(IASTInitializerExpression.INITIALIZER_EXPRESSION);
return result; return result;
} catch (BacktrackException b) { } catch (BacktrackException b) {
// do nothing throwBacktrack(b);
} }
int endOffset = (lastToken != null) ? lastToken.getEndOffset() : 0;
throwBacktrack(startingOffset, endOffset - startingOffset);
return null; return null;
} }
@ -401,7 +399,6 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
return asmDeclaration(); return asmDeclaration();
default: default:
IASTDeclaration d = simpleDeclaration(); IASTDeclaration d = simpleDeclaration();
cleanupLastToken();
return d; return d;
} }
@ -481,15 +478,15 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
s.setParent(funcDefinition); s.setParent(funcDefinition);
s.setPropertyInParent(IASTFunctionDefinition.FUNCTION_BODY); s.setPropertyInParent(IASTFunctionDefinition.FUNCTION_BODY);
} }
((ASTNode) funcDefinition).setLength(lastToken.getEndOffset() ((ASTNode) funcDefinition).setLength(calculateEndOffset(s)
- firstOffset); - firstOffset);
return funcDefinition; return funcDefinition;
} }
IASTSimpleDeclaration simpleDeclaration = createSimpleDeclaration(); IASTSimpleDeclaration simpleDeclaration = createSimpleDeclaration();
((ASTNode) simpleDeclaration).setOffsetAndLength(firstOffset, lastToken
.getEndOffset() ((ASTNode) simpleDeclaration).setOffsetAndLength(firstOffset,
- firstOffset); figureEndOffset(declSpec, declarators) - firstOffset);
simpleDeclaration.setDeclSpecifier(declSpec); simpleDeclaration.setDeclSpecifier(declSpec);
declSpec.setParent(simpleDeclaration); declSpec.setParent(simpleDeclaration);
declSpec.setPropertyInParent(IASTSimpleDeclaration.DECL_SPECIFIER); declSpec.setPropertyInParent(IASTSimpleDeclaration.DECL_SPECIFIER);
@ -558,13 +555,13 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
failParseWithErrorHandling(); failParseWithErrorHandling();
} catch (EndOfFileException e) { } catch (EndOfFileException e) {
// As expected // As expected
if( translationUnit.getDeclarations().length != 0 ) if (translationUnit.getDeclarations().length != 0) {
{ CASTNode d = (CASTNode) translationUnit.getDeclarations()[translationUnit
CASTNode d = (CASTNode) translationUnit.getDeclarations()[ translationUnit.getDeclarations().length - 1 ]; .getDeclarations().length - 1];
((CASTNode) translationUnit).setLength( d.getOffset() + d.getLength() ); ((CASTNode) translationUnit).setLength(d.getOffset()
} + d.getLength());
else } else
((CASTNode)translationUnit).setLength( 0 ); ((CASTNode) translationUnit).setLength(0);
break; break;
} catch (BacktrackException b) { } catch (BacktrackException b) {
try { try {
@ -708,7 +705,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
break; break;
} }
firstExpression = buildBinaryExpression(operator, firstExpression = buildBinaryExpression(operator,
firstExpression, secondExpression, lastToken.getEndOffset()); firstExpression, secondExpression,
calculateEndOffset(secondExpression));
break; break;
default: default:
return firstExpression; return firstExpression;
@ -743,7 +741,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
break; break;
} }
firstExpression = buildBinaryExpression(operator, firstExpression = buildBinaryExpression(operator,
firstExpression, secondExpression, lastToken.getEndOffset()); firstExpression, secondExpression,
calculateEndOffset(secondExpression));
break; break;
default: default:
return firstExpression; return firstExpression;
@ -775,7 +774,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
return buildTypeIdUnaryExpression(IASTCastExpression.op_cast, return buildTypeIdUnaryExpression(IASTCastExpression.op_cast,
typeId, castExpression, startingOffset, calculateEndOffset(castExpression)); typeId, castExpression, startingOffset,
calculateEndOffset(castExpression));
} catch (BacktrackException b) { } catch (BacktrackException b) {
} }
} }
@ -821,15 +821,16 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
backup(mark); backup(mark);
typeId = null; typeId = null;
unaryExpression = unaryExpression(); unaryExpression = unaryExpression();
lastOffset = calculateEndOffset(unaryExpression);
} }
} else { } else {
unaryExpression = unaryExpression(); unaryExpression = unaryExpression();
lastOffset = lastToken.getEndOffset(); lastOffset = calculateEndOffset(unaryExpression);
} }
mark = null; mark = null;
if (typeId == null && unaryExpression != null) if (typeId == null && unaryExpression != null)
return buildUnaryExpression(IASTUnaryExpression.op_sizeof, return buildUnaryExpression(IASTUnaryExpression.op_sizeof,
unaryExpression, startingOffset, lastToken.getEndOffset()); unaryExpression, startingOffset, lastOffset);
return buildTypeIdExpression(IASTTypeIdExpression.op_sizeof, return buildTypeIdExpression(IASTTypeIdExpression.op_sizeof,
typeId, startingOffset, lastOffset); typeId, startingOffset, lastOffset);
@ -858,7 +859,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
int startingOffset, int endingOffset) { int startingOffset, int endingOffset) {
IASTTypeIdExpression result = createTypeIdExpression(); IASTTypeIdExpression result = createTypeIdExpression();
result.setOperator(op); result.setOperator(op);
((ASTNode) result).setOffsetAndLength(startingOffset, endingOffset - startingOffset); ((ASTNode) result).setOffsetAndLength(startingOffset, endingOffset
- startingOffset);
((ASTNode) result).setLength(endingOffset - startingOffset); ((ASTNode) result).setLength(endingOffset - startingOffset);
result.setTypeId(typeId); result.setTypeId(typeId);
typeId.setParent(result); typeId.setParent(result);
@ -891,7 +893,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
IASTTypeId t = typeId(false); IASTTypeId t = typeId(false);
int lastOffset = consume(IToken.tRPAREN).getEndOffset(); int lastOffset = consume(IToken.tRPAREN).getEndOffset();
IASTInitializer i = cInitializerClause(Collections.EMPTY_LIST); IASTInitializer i = cInitializerClause(Collections.EMPTY_LIST);
firstExpression = buildTypeIdInitializerExpression(t, i, offset, lastOffset); firstExpression = buildTypeIdInitializerExpression(t, i, offset,
lastOffset);
break; break;
} catch (BacktrackException bt) { } catch (BacktrackException bt) {
backup(m); backup(m);
@ -911,8 +914,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
int last = consume(IToken.tRBRACKET).getEndOffset(); int last = consume(IToken.tRBRACKET).getEndOffset();
IASTArraySubscriptExpression s = createArraySubscriptExpression(); IASTArraySubscriptExpression s = createArraySubscriptExpression();
((ASTNode) s).setOffsetAndLength(((ASTNode) firstExpression) ((ASTNode) s).setOffsetAndLength(((ASTNode) firstExpression)
.getOffset(), last - ((ASTNode) firstExpression) .getOffset(), last
.getOffset()); - ((ASTNode) firstExpression).getOffset());
s.setArrayExpression(firstExpression); s.setArrayExpression(firstExpression);
firstExpression.setParent(s); firstExpression.setParent(s);
firstExpression firstExpression
@ -931,8 +934,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
last = consume(IToken.tRPAREN).getEndOffset(); last = consume(IToken.tRPAREN).getEndOffset();
IASTFunctionCallExpression f = createFunctionCallExpression(); IASTFunctionCallExpression f = createFunctionCallExpression();
((ASTNode) f).setOffsetAndLength(((ASTNode) firstExpression) ((ASTNode) f).setOffsetAndLength(((ASTNode) firstExpression)
.getOffset(), last - ((ASTNode) firstExpression) .getOffset(), last
.getOffset()); - ((ASTNode) firstExpression).getOffset());
f.setFunctionNameExpression(firstExpression); f.setFunctionNameExpression(firstExpression);
firstExpression.setParent(f); firstExpression.setParent(f);
firstExpression firstExpression
@ -950,13 +953,13 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
int offset = consume(IToken.tINCR).getEndOffset(); int offset = consume(IToken.tINCR).getEndOffset();
firstExpression = buildUnaryExpression( firstExpression = buildUnaryExpression(
IASTUnaryExpression.op_postFixIncr, firstExpression, IASTUnaryExpression.op_postFixIncr, firstExpression,
((CASTNode)firstExpression).getOffset(), offset); ((CASTNode) firstExpression).getOffset(), offset);
break; break;
case IToken.tDECR: case IToken.tDECR:
offset = consume().getEndOffset(); offset = consume().getEndOffset();
firstExpression = buildUnaryExpression( firstExpression = buildUnaryExpression(
IASTUnaryExpression.op_postFixDecr, firstExpression, IASTUnaryExpression.op_postFixDecr, firstExpression,
((CASTNode)firstExpression).getOffset(), offset); ((CASTNode) firstExpression).getOffset(), offset);
break; break;
case IToken.tDOT: case IToken.tDOT:
// member access // member access
@ -964,7 +967,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
IASTName name = createName(identifier()); IASTName name = createName(identifier());
IASTFieldReference result = createFieldReference(); IASTFieldReference result = createFieldReference();
((ASTNode) result).setOffsetAndLength( ((ASTNode) result).setOffsetAndLength(
((ASTNode) firstExpression).getOffset(), lastToken.getEndOffset() - ((ASTNode) firstExpression).getOffset()); ((ASTNode) firstExpression).getOffset(),
calculateEndOffset(name)
- ((ASTNode) firstExpression).getOffset());
result.setFieldOwner(firstExpression); result.setFieldOwner(firstExpression);
result.setIsPointerDereference(false); result.setIsPointerDereference(false);
firstExpression.setParent(result); firstExpression.setParent(result);
@ -981,7 +986,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
name = createName(identifier()); name = createName(identifier());
result = createFieldReference(); result = createFieldReference();
((ASTNode) result).setOffsetAndLength( ((ASTNode) result).setOffsetAndLength(
((ASTNode) firstExpression).getOffset(), lastToken.getEndOffset() - ((ASTNode) firstExpression).getOffset()); ((ASTNode) firstExpression).getOffset(),
calculateEndOffset(name)
- ((ASTNode) firstExpression).getOffset());
result.setFieldOwner(firstExpression); result.setFieldOwner(firstExpression);
result.setIsPointerDereference(true); result.setIsPointerDereference(true);
firstExpression.setParent(result); firstExpression.setParent(result);
@ -1016,7 +1023,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
* @param t * @param t
* @param i * @param i
* @param offset * @param offset
* @param lastOffset TODO * @param lastOffset
* TODO
* @return * @return
*/ */
protected ICASTTypeIdInitializerExpression buildTypeIdInitializerExpression( protected ICASTTypeIdInitializerExpression buildTypeIdInitializerExpression(
@ -1062,14 +1070,18 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
literalExpression literalExpression
.setKind(IASTLiteralExpression.lk_integer_constant); .setKind(IASTLiteralExpression.lk_integer_constant);
literalExpression.setValue(t.getImage()); literalExpression.setValue(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 = createLiteralExpression(); literalExpression = createLiteralExpression();
literalExpression.setKind(IASTLiteralExpression.lk_float_constant); literalExpression.setKind(IASTLiteralExpression.lk_float_constant);
literalExpression.setValue(t.getImage()); literalExpression.setValue(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:
case IToken.tLSTRING: case IToken.tLSTRING:
@ -1077,7 +1089,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
literalExpression = createLiteralExpression(); literalExpression = createLiteralExpression();
literalExpression.setKind(IASTLiteralExpression.lk_string_literal); literalExpression.setKind(IASTLiteralExpression.lk_string_literal);
literalExpression.setValue(t.getImage()); literalExpression.setValue(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:
case IToken.tLCHAR: case IToken.tLCHAR:
@ -1085,7 +1099,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
literalExpression = createLiteralExpression(); literalExpression = createLiteralExpression();
literalExpression.setKind(IASTLiteralExpression.lk_char_constant); literalExpression.setKind(IASTLiteralExpression.lk_char_constant);
literalExpression.setValue(t.getImage()); literalExpression.setValue(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.tLPAREN: case IToken.tLPAREN:
t = consume(); t = consume();
@ -1137,20 +1153,20 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
declSpecifier = declSpecifierSeq(false); declSpecifier = declSpecifierSeq(false);
declarator = declarator(); declarator = declarator();
} catch (BacktrackException bt) { } catch (BacktrackException bt) {
int endingOffset = lastToken == null ? 0 : lastToken.getEndOffset();
backup(mark); backup(mark);
throwBacktrack(startingOffset, endingOffset - startingOffset); throwBacktrack(bt);
} }
if (declarator == null || declarator.getName().toString() != null) //$NON-NLS-1$ if (declarator == null || declarator.getName().toString() != null) //$NON-NLS-1$
{ {
int endingOffset = lastToken == null ? 0 : lastToken.getEndOffset();
backup(mark); backup(mark);
throwBacktrack(startingOffset, endingOffset - startingOffset); throwBacktrack(startingOffset, figureEndOffset(declSpecifier,
declarator)
- startingOffset);
} }
IASTTypeId result = createTypeId(); IASTTypeId result = createTypeId();
int length = (lastToken != null ) ? lastToken.getEndOffset() - startingOffset : 0; ((ASTNode) result).setOffsetAndLength(startingOffset, figureEndOffset(
((ASTNode) result).setOffsetAndLength(startingOffset, length); declSpecifier, declarator));
result.setDeclSpecifier(declSpecifier); result.setDeclSpecifier(declSpecifier);
declSpecifier.setParent(result); declSpecifier.setParent(result);
@ -1185,6 +1201,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
throws EndOfFileException, BacktrackException { throws EndOfFileException, BacktrackException {
for (;;) { for (;;) {
IToken mark = mark(); IToken mark = mark();
IToken last = null;
boolean isConst = false, isVolatile = false, isRestrict = false; boolean isConst = false, isVolatile = false, isRestrict = false;
@ -1193,21 +1210,21 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
break; break;
} }
consume(IToken.tSTAR); last = consume(IToken.tSTAR);
int startOffset = mark.getOffset(); int startOffset = mark.getOffset();
for (;;) { for (;;) {
IToken t = LA(1); IToken t = LA(1);
switch (LT(1)) { switch (LT(1)) {
case IToken.t_const: case IToken.t_const:
consume(IToken.t_const); last = consume(IToken.t_const);
isConst = true; isConst = true;
break; break;
case IToken.t_volatile: case IToken.t_volatile:
consume(IToken.t_volatile); last = consume(IToken.t_volatile);
isVolatile = true; isVolatile = true;
break; break;
case IToken.t_restrict: case IToken.t_restrict:
consume(IToken.t_restrict); last = consume(IToken.t_restrict);
isRestrict = true; isRestrict = true;
break; break;
} }
@ -1217,7 +1234,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
IASTPointerOperator po = createPointer(); IASTPointerOperator po = createPointer();
((ASTNode) po).setOffsetAndLength(startOffset, lastToken.getEndOffset() - startOffset); ((ASTNode) po).setOffsetAndLength(startOffset, last.getEndOffset()
- startOffset);
((ICASTPointer) po).setConst(isConst); ((ICASTPointer) po).setConst(isConst);
((ICASTPointer) po).setVolatile(isVolatile); ((ICASTPointer) po).setVolatile(isVolatile);
((ICASTPointer) po).setRestrict(isRestrict); ((ICASTPointer) po).setRestrict(isRestrict);
@ -1246,77 +1264,79 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
IASTCompositeTypeSpecifier structSpec = null; IASTCompositeTypeSpecifier structSpec = null;
IASTElaboratedTypeSpecifier elabSpec = null; IASTElaboratedTypeSpecifier elabSpec = null;
IASTEnumerationSpecifier enumSpec = null; IASTEnumerationSpecifier enumSpec = null;
IASTExpression typeofExpression = null;
boolean isTypedef = false; boolean isTypedef = false;
IToken last = null;
declSpecifiers: for (;;) { declSpecifiers: for (;;) {
switch (LT(1)) { switch (LT(1)) {
//Storage Class Specifiers //Storage Class Specifiers
case IToken.t_auto: case IToken.t_auto:
consume(); last = consume();
storageClass = IASTDeclSpecifier.sc_auto; storageClass = IASTDeclSpecifier.sc_auto;
break; break;
case IToken.t_register: case IToken.t_register:
storageClass = IASTDeclSpecifier.sc_register; storageClass = IASTDeclSpecifier.sc_register;
consume(); last = consume();
break; break;
case IToken.t_static: case IToken.t_static:
storageClass = IASTDeclSpecifier.sc_static; storageClass = IASTDeclSpecifier.sc_static;
consume(); last = consume();
break; break;
case IToken.t_extern: case IToken.t_extern:
storageClass = IASTDeclSpecifier.sc_extern; storageClass = IASTDeclSpecifier.sc_extern;
consume(); last = consume();
break; break;
case IToken.t_typedef: case IToken.t_typedef:
isTypedef = true; isTypedef = true;
storageClass = IASTDeclSpecifier.sc_typedef; storageClass = IASTDeclSpecifier.sc_typedef;
consume(); last = consume();
break; break;
//Function Specifier //Function Specifier
case IToken.t_inline: case IToken.t_inline:
isInline = true; isInline = true;
consume(); last = consume();
break; break;
//Type Qualifiers //Type Qualifiers
case IToken.t_const: case IToken.t_const:
isConst = true; isConst = true;
consume(); last = consume();
break; break;
case IToken.t_volatile: case IToken.t_volatile:
isVolatile = true; isVolatile = true;
consume(); last = consume();
break; break;
case IToken.t_restrict: case IToken.t_restrict:
isRestrict = true; isRestrict = true;
consume(); last = consume();
break; break;
//Type Specifiers //Type Specifiers
case IToken.t_void: case IToken.t_void:
flags.setEncounteredRawType(true); flags.setEncounteredRawType(true);
consume(); last = consume();
simpleType = IASTSimpleDeclSpecifier.t_void; simpleType = IASTSimpleDeclSpecifier.t_void;
break; break;
case IToken.t_char: case IToken.t_char:
flags.setEncounteredRawType(true); flags.setEncounteredRawType(true);
consume(); last = consume();
simpleType = IASTSimpleDeclSpecifier.t_char; simpleType = IASTSimpleDeclSpecifier.t_char;
break; break;
case IToken.t_short: case IToken.t_short:
flags.setEncounteredRawType(true); flags.setEncounteredRawType(true);
consume(); last = consume();
isShort = true; isShort = true;
break; break;
case IToken.t_int: case IToken.t_int:
flags.setEncounteredRawType(true); flags.setEncounteredRawType(true);
consume(); last = consume();
simpleType = IASTSimpleDeclSpecifier.t_int; simpleType = IASTSimpleDeclSpecifier.t_int;
break; break;
case IToken.t_long: case IToken.t_long:
flags.setEncounteredRawType(true); flags.setEncounteredRawType(true);
consume(); last = consume();
if (isLong) { if (isLong) {
isLongLong = true; isLongLong = true;
isLong = false; isLong = false;
@ -1325,35 +1345,35 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
break; break;
case IToken.t_float: case IToken.t_float:
flags.setEncounteredRawType(true); flags.setEncounteredRawType(true);
consume(); last = consume();
simpleType = IASTSimpleDeclSpecifier.t_float; simpleType = IASTSimpleDeclSpecifier.t_float;
break; break;
case IToken.t_double: case IToken.t_double:
flags.setEncounteredRawType(true); flags.setEncounteredRawType(true);
consume(); last = consume();
simpleType = IASTSimpleDeclSpecifier.t_double; simpleType = IASTSimpleDeclSpecifier.t_double;
break; break;
case IToken.t_signed: case IToken.t_signed:
flags.setEncounteredRawType(true); flags.setEncounteredRawType(true);
consume(); last = consume();
isSigned = true; isSigned = true;
break; break;
case IToken.t_unsigned: case IToken.t_unsigned:
flags.setEncounteredRawType(true); flags.setEncounteredRawType(true);
consume(); last = consume();
isUnsigned = true; isUnsigned = true;
break; break;
case IToken.t__Bool: case IToken.t__Bool:
flags.setEncounteredRawType(true); flags.setEncounteredRawType(true);
consume(); last = consume();
simpleType = ICASTSimpleDeclSpecifier.t_Bool; simpleType = ICASTSimpleDeclSpecifier.t_Bool;
break; break;
case IToken.t__Complex: case IToken.t__Complex:
consume(IToken.t__Complex); last = consume(IToken.t__Complex);
simpleType = ICASTSimpleDeclSpecifier.t_Complex; simpleType = ICASTSimpleDeclSpecifier.t_Complex;
break; break;
case IToken.t__Imaginary: case IToken.t__Imaginary:
consume(IToken.t__Imaginary); last = consume(IToken.t__Imaginary);
simpleType = ICASTSimpleDeclSpecifier.t_Imaginary; simpleType = ICASTSimpleDeclSpecifier.t_Imaginary;
break; break;
@ -1379,6 +1399,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
identifier = identifier(); identifier = identifier();
last = identifier;
isIdentifier = true; isIdentifier = true;
flags.setEncounteredTypename(true); flags.setEncounteredTypename(true);
break; break;
@ -1406,8 +1427,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
default: default:
if (supportTypeOfUnaries && LT(1) == IGCCToken.t_typeof) { if (supportTypeOfUnaries && LT(1) == IGCCToken.t_typeof) {
Object expression = unaryTypeofExpression(); typeofExpression = unaryTypeofExpression();
if (expression != null) { if (typeofExpression != null) {
flags.setEncounteredTypename(true); flags.setEncounteredTypename(true);
} }
} }
@ -1416,7 +1437,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
if (structSpec != null) { if (structSpec != null) {
((ASTNode) structSpec).setOffsetAndLength(startingOffset, lastToken.getEndOffset() - startingOffset); ((ASTNode) structSpec).setOffsetAndLength(startingOffset,
calculateEndOffset(structSpec) - startingOffset);
structSpec.setConst(isConst); structSpec.setConst(isConst);
((ICASTCompositeTypeSpecifier) structSpec).setRestrict(isRestrict); ((ICASTCompositeTypeSpecifier) structSpec).setRestrict(isRestrict);
structSpec.setVolatile(isVolatile); structSpec.setVolatile(isVolatile);
@ -1427,7 +1449,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
if (enumSpec != null) { if (enumSpec != null) {
((ASTNode) enumSpec).setOffsetAndLength(startingOffset, lastToken.getEndOffset() - startingOffset); ((ASTNode) enumSpec).setOffsetAndLength(startingOffset,
calculateEndOffset(enumSpec) - startingOffset);
enumSpec.setConst(isConst); enumSpec.setConst(isConst);
((CASTEnumerationSpecifier) enumSpec).setRestrict(isRestrict); ((CASTEnumerationSpecifier) enumSpec).setRestrict(isRestrict);
enumSpec.setVolatile(isVolatile); enumSpec.setVolatile(isVolatile);
@ -1437,7 +1460,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
if (elabSpec != null) { if (elabSpec != null) {
((ASTNode) elabSpec).setOffsetAndLength(startingOffset, lastToken.getEndOffset() - startingOffset); ((ASTNode) elabSpec).setOffsetAndLength(startingOffset,
calculateEndOffset(elabSpec) - startingOffset);
elabSpec.setConst(isConst); elabSpec.setConst(isConst);
((CASTElaboratedTypeSpecifier) elabSpec).setRestrict(isRestrict); ((CASTElaboratedTypeSpecifier) elabSpec).setRestrict(isRestrict);
elabSpec.setVolatile(isVolatile); elabSpec.setVolatile(isVolatile);
@ -1454,7 +1478,9 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
declSpec.setInline(isInline); declSpec.setInline(isInline);
declSpec.setStorageClass(storageClass); declSpec.setStorageClass(storageClass);
((ASTNode) declSpec).setOffsetAndLength(startingOffset, lastToken.getEndOffset() - startingOffset); ((ASTNode) declSpec).setOffsetAndLength(startingOffset, last
.getEndOffset()
- startingOffset);
IASTName name = createName(identifier); IASTName name = createName(identifier);
declSpec.setName(name); declSpec.setName(name);
name.setParent(declSpec); name.setParent(declSpec);
@ -1474,8 +1500,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
declSpec.setUnsigned(isUnsigned); declSpec.setUnsigned(isUnsigned);
declSpec.setSigned(isSigned); declSpec.setSigned(isSigned);
declSpec.setShort(isShort); declSpec.setShort(isShort);
int length = ( lastToken != null ) ? lastToken.getEndOffset() - startingOffset : 0 ; ((ASTNode) declSpec).setOffsetAndLength(startingOffset,
((ASTNode) declSpec).setOffsetAndLength(startingOffset, length ); (last != null) ? last.getEndOffset() - startingOffset : 0);
return declSpec; return declSpec;
} }
@ -1541,7 +1567,6 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
consume(IToken.tLBRACE); consume(IToken.tLBRACE);
cleanupLastToken();
IASTName name = null; IASTName name = null;
if (nameToken != null) if (nameToken != null)
@ -1583,7 +1608,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
} }
// consume the } // consume the }
int endOffset = consume(IToken.tRBRACE).getEndOffset(); int endOffset = consume(IToken.tRBRACE).getEndOffset();
((CASTNode)result).setLength( endOffset - classKey.getOffset() ); ((CASTNode) result).setLength(endOffset - classKey.getOffset());
return result; return result;
} }
@ -1690,27 +1715,26 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
// parameterDeclarationClause // parameterDeclarationClause
// d.setIsFunction(true); // d.setIsFunction(true);
// TODO need to create a temporary scope object here // TODO need to create a temporary scope object here
consume(IToken.tLPAREN); IToken last = consume(IToken.tLPAREN);
isFunction = true; isFunction = true;
boolean seenParameter = false; boolean seenParameter = false;
parameterDeclarationLoop: for (;;) { parameterDeclarationLoop: for (;;) {
switch (LT(1)) { switch (LT(1)) {
case IToken.tRPAREN: case IToken.tRPAREN:
consume(); last = consume();
break parameterDeclarationLoop; break parameterDeclarationLoop;
case IToken.tELLIPSIS: case IToken.tELLIPSIS:
consume(); last = consume();
encounteredVarArgs = true; encounteredVarArgs = true;
break; break;
case IToken.tCOMMA: case IToken.tCOMMA:
consume(); last = consume();
seenParameter = false; seenParameter = false;
break; break;
default: default:
int endOffset = (lastToken != null) ? lastToken
.getEndOffset() : 0;
if (seenParameter) if (seenParameter)
throwBacktrack(startingOffset, endOffset throwBacktrack(startingOffset, last
.getEndOffset()
- startingOffset); - startingOffset);
IASTParameterDeclaration pd = parameterDeclaration(); IASTParameterDeclaration pd = parameterDeclaration();
if (parameters == Collections.EMPTY_LIST) if (parameters == Collections.EMPTY_LIST)
@ -1811,7 +1835,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
*/ */
protected IASTName createName(IToken t) { protected IASTName createName(IToken t) {
IASTName n = new CASTName(t.getCharImage()); IASTName n = new CASTName(t.getCharImage());
((ASTNode) n).setOffsetAndLength(t.getOffset(), t.getEndOffset() - t.getOffset()); ((ASTNode) n).setOffsetAndLength(t.getOffset(), t.getEndOffset()
- t.getOffset());
return n; return n;
} }
@ -1870,7 +1895,7 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
else else
exp = constantExpression(); exp = constantExpression();
} }
consume(IToken.tRBRACKET); int lastOffset = consume(IToken.tRBRACKET).getEndOffset();
IASTArrayModifier arrayMod = null; IASTArrayModifier arrayMod = null;
if (!(isStatic || isRestrict || isConst || isVolatile)) if (!(isStatic || isRestrict || isConst || isVolatile))
@ -1884,7 +1909,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
temp.setVariableSized(isVarSized); temp.setVariableSized(isVarSized);
arrayMod = temp; arrayMod = temp;
} }
((ASTNode) arrayMod).setOffsetAndLength(startOffset, lastToken.getEndOffset() - startOffset); ((ASTNode) arrayMod).setOffsetAndLength(startOffset, lastOffset
- startOffset);
if (exp != null) { if (exp != null) {
arrayMod.setConstantExpression(exp); arrayMod.setConstantExpression(exp);
exp.setParent(arrayMod); exp.setParent(arrayMod);
@ -1918,20 +1944,21 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
if (LT(1) != IToken.tSEMI) if (LT(1) != IToken.tSEMI)
declarator = initDeclarator(); declarator = initDeclarator();
if (current == LA(1)) { if (current == LA(1))
int endOffset = (lastToken != null) ? lastToken.getEndOffset() : 0; throwBacktrack(current.getOffset(), figureEndOffset(declSpec,
throwBacktrack(current.getOffset(), endOffset - current.getOffset()); declarator)
} - current.getOffset());
IASTParameterDeclaration result = createParameterDeclaration(); IASTParameterDeclaration result = createParameterDeclaration();
((ASTNode) result).setOffsetAndLength(startingOffset, lastToken.getEndOffset() - startingOffset); ((ASTNode) result).setOffsetAndLength(startingOffset, figureEndOffset(
declSpec, declarator)
- startingOffset);
result.setDeclSpecifier(declSpec); result.setDeclSpecifier(declSpec);
declSpec.setParent(result); declSpec.setParent(result);
declSpec.setPropertyInParent(IASTParameterDeclaration.DECL_SPECIFIER); declSpec.setPropertyInParent(IASTParameterDeclaration.DECL_SPECIFIER);
result.setDeclarator(declarator); result.setDeclarator(declarator);
declarator.setParent(result); declarator.setParent(result);
declarator.setPropertyInParent(IASTParameterDeclaration.DECLARATOR); declarator.setPropertyInParent(IASTParameterDeclaration.DECLARATOR);
return result; return result;
} }
@ -1951,7 +1978,8 @@ public class GNUCSourceParser extends AbstractGNUSourceCodeParser {
try { try {
IASTExpression e = expression(); IASTExpression e = expression();
consume(IToken.tSEMI); consume(IToken.tSEMI);
//TODO is this a problem? Should we wrap this in an expression statement? //TODO is this a problem? Should we wrap this in an expression
// statement?
return e; return e;
} catch (BacktrackException bt) { } catch (BacktrackException bt) {
backup(mark); backup(mark);

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

File diff suppressed because it is too large Load diff