From 8342cee582d9fe06574e19e6f67199e070aa578f Mon Sep 17 00:00:00 2001 From: Mike Kucera Date: Thu, 21 Feb 2008 22:08:49 +0000 Subject: replaced constants in ICPPASTOperatorName with new OverloadableOperator enum --- .../cdt/core/parser/tests/ast2/AST2CPPTests.java | 9 +- .../cdt/core/dom/ast/cpp/ICPPASTOperatorName.java | 93 +----------- .../parser/cpp/CPPASTCompositeTypeSpecifier.java | 12 +- .../core/dom/parser/cpp/CPPASTFieldReference.java | 3 +- .../core/dom/parser/cpp/CPPASTOperatorName.java | 162 +-------------------- .../core/dom/parser/cpp/CPPASTTranslationUnit.java | 9 +- .../core/dom/parser/cpp/CPPClassScope.java | 4 +- .../internal/core/dom/parser/cpp/CPPSemantics.java | 6 +- .../core/dom/parser/cpp/GNUCPPSourceParser.java | 37 ++--- .../core/dom/parser/cpp/OverloadableOperator.java | 138 ++++++++++++++++++ .../core/parser/token/OperatorTokenDuple.java | 68 +++------ 11 files changed, 211 insertions(+), 330 deletions(-) create mode 100644 core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/OverloadableOperator.java diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPTests.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPTests.java index be9019aba2d..c1341a23673 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPTests.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPTests.java @@ -107,6 +107,7 @@ import org.eclipse.cdt.core.parser.ParserLanguage; import org.eclipse.cdt.core.parser.util.CharArrayUtils; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPSemantics; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPVisitor; +import org.eclipse.cdt.internal.core.dom.parser.cpp.OverloadableOperator; import org.eclipse.cdt.internal.core.parser.ParserException; /** @@ -1450,7 +1451,7 @@ public class AST2CPPTests extends AST2BaseTest { assertNotNull(methods); int count=0; for(int i=0; i=FIRST_CHAR_AFTER_OPERATOR && name.indexOf(LBRACKET, FIRST_CHAR_AFTER_OPERATOR) >=FIRST_CHAR_AFTER_OPERATOR && name.indexOf(RBRACKET, FIRST_CHAR_AFTER_OPERATOR) >=FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_NEW_ARRAY; - } else if (name.indexOf(OP_DELETE, FIRST_CHAR_AFTER_OPERATOR) >=FIRST_CHAR_AFTER_OPERATOR && name.indexOf(LBRACKET, FIRST_CHAR_AFTER_OPERATOR) >=FIRST_CHAR_AFTER_OPERATOR && name.indexOf(RBRACKET, FIRST_CHAR_AFTER_OPERATOR) >=FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_DELETE_ARRAY; - } else if (name.indexOf(OP_NEW, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_NEW; - } else if (name.indexOf(OP_DELETE, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_DELETE; - } else if (name.indexOf(OP_PLUS_ASSIGN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_PLUS_ASSIGN; - } else if (name.indexOf(OP_MINUS_ASSIGN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_MINUS_ASSIGN; - } else if (name.indexOf(OP_STAR_ASSIGN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_STAR_ASSIGN; - } else if (name.indexOf(OP_DIV_ASSIGN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_DIV_ASSIGN; - } else if (name.indexOf(OP_MOD_ASSIGN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_MOD_ASSIGN; - } else if (name.indexOf(OP_XOR_ASSIGN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_XOR_ASSIGN; - } else if (name.indexOf(OP_AMPER_ASSIGN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_AMPER_ASSIGN; - } else if (name.indexOf(OP_BITOR_ASSIGN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_BITOR_ASSIGN; - } else if (name.indexOf(OP_SHIFTR_ASSIGN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_SHIFTR_ASSIGN; - } else if (name.indexOf(OP_SHIFTL_ASSIGN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_SHIFTL_ASSIGN; - } else if (name.indexOf(OP_SHIFTL, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_SHIFTL; - } else if (name.indexOf(OP_SHIFTR, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_SHIFTR; - } else if (name.indexOf(OP_EQUAL, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_EQUAL; - } else if (name.indexOf(OP_NOTEQUAL, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_NOTEQUAL; - } else if (name.indexOf(OP_LTEQUAL, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_LTEQUAL; - } else if (name.indexOf(OP_GTEQUAL, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_GTEQUAL; - } else if (name.indexOf(OP_ASSIGN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_ASSIGN; - } else if (name.indexOf(OP_AND, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_AND; - } else if (name.indexOf(OP_OR, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_OR; - } else if (name.indexOf(OP_INCR, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_INCR; - } else if (name.indexOf(OP_DECR, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_DECR; - } else if (name.indexOf(OP_COMMA, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_COMMA; - } else if (name.indexOf(OP_ARROWSTAR, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_ARROWSTAR; - } else if (name.indexOf(OP_ARROW, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_ARROW; - } else if (name.indexOf(LPAREN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR && name.indexOf(RPAREN, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_PAREN; - } else if (name.indexOf(LBRACKET, FIRST_CHAR_AFTER_OPERATOR) >=FIRST_CHAR_AFTER_OPERATOR && name.indexOf(RBRACKET, FIRST_CHAR_AFTER_OPERATOR) >=FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_BRACKET; - } else if (name.indexOf(OP_PLUS, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_PLUS; - } else if (name.indexOf(OP_MINUS, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_MINUS; - } else if (name.indexOf(OP_STAR, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_STAR; - } else if (name.indexOf(OP_DIV, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_DIV; - } else if (name.indexOf(OP_MOD, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_MOD; - } else if (name.indexOf(OP_XOR, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_XOR; - } else if (name.indexOf(OP_AMPER, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_AMPER; - } else if (name.indexOf(OP_BITOR, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_BITOR; - } else if (name.indexOf(OP_COMPL, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_COMPL; - } else if (name.indexOf(OP_NOT, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_NOT; - } else if (name.indexOf(OP_LT, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_LT; - } else if (name.indexOf(OP_GT, FIRST_CHAR_AFTER_OPERATOR) >= FIRST_CHAR_AFTER_OPERATOR) { - return OPERATOR_GT; - } - - return name.toCharArray(); - } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTTranslationUnit.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTTranslationUnit.java index c826b8ae766..c4d157f07be 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTTranslationUnit.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTTranslationUnit.java @@ -53,7 +53,6 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCatchHandler; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTConstructorChainInitializer; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTFunctionDeclarator; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTFunctionTryBlockDeclarator; -import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTOperatorName; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTranslationUnit; import org.eclipse.cdt.core.dom.ast.cpp.ICPPBasicType; import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespace; @@ -142,14 +141,14 @@ public class CPPASTTranslationUnit extends CPPASTNode implements ICPPASTTranslat IFunctionType newFunctionType = new CPPFunctionType(cpp_void_p, newParms); IParameter[] newTheParms = new IParameter[1]; newTheParms[0] = new CPPBuiltinParameter(newParms[0]); - temp = new CPPImplicitFunction(ICPPASTOperatorName.OPERATOR_NEW, theScope, newFunctionType, newTheParms, false); + temp = new CPPImplicitFunction(OverloadableOperator.NEW.toCharArray(), theScope, newFunctionType, newTheParms, false); try { ASTInternal.addBinding(theScope, temp); } catch (DOMException de) {} // void * operator new[] (std::size_t); temp = null; - temp = new CPPImplicitFunction(ICPPASTOperatorName.OPERATOR_NEW_ARRAY, theScope, newFunctionType, newTheParms, false); + temp = new CPPImplicitFunction(OverloadableOperator.NEW_ARRAY.toCharArray(), theScope, newFunctionType, newTheParms, false); try { ASTInternal.addBinding(theScope, temp); } catch (DOMException de) {} @@ -161,14 +160,14 @@ public class CPPASTTranslationUnit extends CPPASTNode implements ICPPASTTranslat IFunctionType deleteFunctionType = new CPPFunctionType(cpp_void, deleteParms); IParameter[] deleteTheParms = new IParameter[1]; deleteTheParms[0] = new CPPBuiltinParameter(deleteParms[0]); - temp = new CPPImplicitFunction(ICPPASTOperatorName.OPERATOR_DELETE, theScope, deleteFunctionType, deleteTheParms, false); + temp = new CPPImplicitFunction(OverloadableOperator.DELETE.toCharArray(), theScope, deleteFunctionType, deleteTheParms, false); try { ASTInternal.addBinding(theScope, temp); } catch (DOMException de) {} // void operator delete[](void*); temp = null; - temp = new CPPImplicitFunction(ICPPASTOperatorName.OPERATOR_DELETE_ARRAY, theScope, deleteFunctionType, deleteTheParms, false); + temp = new CPPImplicitFunction(OverloadableOperator.DELETE_ARRAY.toCharArray(), theScope, deleteFunctionType, deleteTheParms, false); try { ASTInternal.addBinding(theScope, temp); } catch (DOMException de) {} diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassScope.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassScope.java index 04c938fc7a8..b02dc2419b1 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassScope.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassScope.java @@ -121,7 +121,7 @@ public class CPPClassScope extends CPPScope implements ICPPClassScope { if( !ia.hasUserDeclaredCopyAssignmentOperator() ) { //copy assignment operator: A& operator = ( const A & ) IType refType = new CPPReferenceType( clsType ); - ICPPMethod m = new CPPImplicitMethod( this, ICPPASTOperatorName.OPERATOR_ASSIGN, refType, ps ); + ICPPMethod m = new CPPImplicitMethod( this, OverloadableOperator.ASSIGN.toCharArray(), refType, ps ); implicits[i++]=m; addBinding( m ); } @@ -483,7 +483,7 @@ class ImplicitsAnalysis { dcltor = ((IASTFunctionDefinition)members[i]).getDeclarator(); } if( !(dcltor instanceof ICPPASTFunctionDeclarator) || - !CharArrayUtils.equals( dcltor.getName().toCharArray(), ICPPASTOperatorName.OPERATOR_ASSIGN ) ) + !CharArrayUtils.equals( dcltor.getName().toCharArray(), OverloadableOperator.ASSIGN.toCharArray() ) ) { continue; } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPSemantics.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPSemantics.java index bda2979901a..3f5ad847a9b 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPSemantics.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPSemantics.java @@ -3368,17 +3368,17 @@ public class CPPSemantics { LookupData data = null; if( exp instanceof IASTUnaryExpression) { - astName.setName( ICPPASTOperatorName.OPERATOR_STAR ); + astName.setName( OverloadableOperator.STAR.toCharArray() ); data = new LookupData( astName ); data.forceQualified = true; data.functionParameters = IASTExpression.EMPTY_EXPRESSION_ARRAY; } else if( exp instanceof IASTArraySubscriptExpression ){ - astName.setName( ICPPASTOperatorName.OPERATOR_BRACKET ); + astName.setName( OverloadableOperator.BRACKET.toCharArray() ); data = new LookupData( astName ); data.forceQualified = true; data.functionParameters = new IASTExpression [] { ((IASTArraySubscriptExpression)exp).getSubscriptExpression() }; } else if( exp instanceof IASTFieldReference ){ - astName.setName( ICPPASTOperatorName.OPERATOR_ARROW ); + astName.setName( OverloadableOperator.ARROW.toCharArray() ); data = new LookupData( astName ); data.forceQualified = true; data.functionParameters = IASTExpression.EMPTY_EXPRESSION_ARRAY; diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java index 09af7466058..f24c498e592 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java @@ -396,8 +396,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { case IToken.t_operator: IToken l = LA(1); backup(mark); - throwBacktrack(first.getOffset(), l.getEndOffset() - - first.getOffset()); + throwBacktrack(first.getOffset(), l.getEndOffset() - first.getOffset()); case IToken.tIDENTIFIER: case IToken.tCOMPLETION: case IToken.tEOC: @@ -461,14 +460,16 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { TemplateParameterManager templateArgs) throws BacktrackException, EndOfFileException { // we know this is an operator + IToken operatorToken = consume(); IToken toSend = null; IASTTypeId typeId = null; - if (LA(1).isOperator() || LT(1) == IToken.tLPAREN - || LT(1) == IToken.tLBRACKET) { - if ((LT(1) == IToken.t_new || LT(1) == IToken.t_delete) - && LT(2) == IToken.tLBRACKET && LT(3) == IToken.tRBRACKET) { - consume(); // new or delete + OverloadableOperator op = null; + if (LA(1).isOperator() || LT(1) == IToken.tLPAREN || LT(1) == IToken.tLBRACKET) { + if ((LT(1) == IToken.t_new || LT(1) == IToken.t_delete) && + LT(2) == IToken.tLBRACKET && LT(3) == IToken.tRBRACKET) { + op = LT(1) == IToken.t_new ? OverloadableOperator.NEW_ARRAY : OverloadableOperator.DELETE_ARRAY; + consume(); // new or delete consume(); // lbracket toSend = consume(); // rbracket // vector new and delete operators @@ -476,15 +477,17 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { // operator () consume(); // "(" toSend = consume(); // ")" + op = OverloadableOperator.PAREN; } else if (LT(1) == IToken.tLBRACKET && LT(2) == IToken.tRBRACKET) { consume(); // "[" toSend = consume(); // "]" - } else if (LA(1).isOperator()) - toSend = consume(); + op = OverloadableOperator.BRACKET; + } else if (LA(1).isOperator()) { + toSend = consume(); + op = OverloadableOperator.valueOf(toSend); + } else - throwBacktrack(operatorToken.getOffset(), - toSend != null ? toSend.getEndOffset() - - operatorToken.getOffset() : 0); + throwBacktrack(operatorToken.getOffset(), 0); // toSend must be null } else { // must be a conversion function IToken t = LA(1); @@ -516,13 +519,13 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { toSend, (hasTemplateId ? templateArgs .getTemplateArgumentsList() : null)); - OperatorTokenDuple operator = new OperatorTokenDuple(duple); + OperatorTokenDuple operatorDuple = new OperatorTokenDuple(duple, op); if (typeId != null) { // if it's a conversion operator - operator.setConversionOperator(true); - operator.setTypeId(typeId); + operatorDuple.setConversionOperator(true); + operatorDuple.setTypeId(typeId); } - return createName(operator); + return createName(operatorDuple); } finally { if (grabbedNewInstance) TemplateParameterManager.returnInstance(templateArgs); @@ -2653,7 +2656,7 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { IASTTypeId typeId = duple.getTypeId(); ((CPPASTConversionName) aName).setTypeId(typeId); } else { - aName = new CPPASTOperatorName(name.toCharArray()); + aName = new CPPASTOperatorName(duple.getOperator()); } if (name instanceof ICPPASTTemplateId) { diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/OverloadableOperator.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/OverloadableOperator.java new file mode 100644 index 00000000000..d8be7be8438 --- /dev/null +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/OverloadableOperator.java @@ -0,0 +1,138 @@ +/******************************************************************************* + * Copyright (c) 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.internal.core.dom.parser.cpp; + +import org.eclipse.cdt.core.parser.IToken; + +/** + * Enumeration of all the overloadable operators in C++. + * + * Note: toString() has not been overridden, use toCharArray() to get + * a character representation of the operator. + * + * @author Mike Kucera + */ +@SuppressWarnings("nls") +public enum OverloadableOperator { + + GT(">"), + LT("<"), + NOT("!"), + BITCOMPLEMENT("~"), + BITOR("|"), + AMPER("&"), + XOR("^"), + MOD("%"), + DIV("/"), + STAR("*"), + PLUS("+"), + BRACKET("[]"), + PAREN("()"), + ARROW("->"), + ARROWSTAR("->*"), + COMMA(","), + MINUS("-"), + DECR("--"), + INCR("++"), + OR("||"), + AND("&&"), + ASSIGN("="), + GTEQUAL(">="), + LTEQUAL("<="), + NOTEQUAL("!="), + EQUAL("=="), + SHIFTR(">>"), + SHIFTL("<<"), + SHIFTLASSIGN("<<="), + SHIFTR_ASSIGN(">>="), + BITORASSIGN("|="), + AMPERASSIGN("&="), + XORASSIGN("^="), + MODASSIGN("%="), + DIVASSIGN("/="), + STARASSIGN("*="), + MINUSASSIGN("-="), + PLUSASSIGN("+="), + NEW("new"), + DELETE_ARRAY("delete[]"), + DELETE("delete"), + NEW_ARRAY("new[]"); + + + private final char[] rep; + + private OverloadableOperator(String rep) { + this.rep = ("operator " + rep).toCharArray(); + } + + public char[] toCharArray() { + return rep; + } + + /** + * Returns the OverloadableOperator constant that corresponds to the + * given token. Only works for operators that consist of one token. + * + * @throws NullPointerException if token is null + */ + public static OverloadableOperator valueOf(IToken token) { + switch(token.getType()) { + case IToken.t_delete: return DELETE; + case IToken.t_new: return NEW; + case IToken.tAMPER: return AMPER; + case IToken.tAMPERASSIGN: return AMPERASSIGN; + case IToken.tARROW: return ARROW; + case IToken.tARROWSTAR: return ARROWSTAR; + case IToken.tBITOR: return BITOR; + case IToken.tBITORASSIGN: return BITORASSIGN; + case IToken.tBITCOMPLEMENT: return BITCOMPLEMENT; + case IToken.tSHIFTL: return SHIFTL; + case IToken.tSHIFTLASSIGN: return SHIFTLASSIGN; + case IToken.tSHIFTR: return SHIFTR; + case IToken.tSHIFTRASSIGN: return SHIFTR_ASSIGN; + case IToken.tXOR: return XOR; + case IToken.tXORASSIGN: return XORASSIGN; + + // logical operations + case IToken.tNOT: return NOT; + case IToken.tAND: return AND; + case IToken.tOR: return OR; + + // arithmetic + case IToken.tDECR: return DECR; + case IToken.tINCR: return INCR; + case IToken.tDIV: return DIV; + case IToken.tDIVASSIGN: return DIVASSIGN; + case IToken.tMINUS: return MINUS; + case IToken.tMINUSASSIGN: return MINUSASSIGN; + case IToken.tMOD: return MOD; + case IToken.tMODASSIGN: return MODASSIGN; + case IToken.tPLUS: return PLUS; + case IToken.tPLUSASSIGN: return PLUSASSIGN; + case IToken.tSTAR: return STAR; + case IToken.tSTARASSIGN: return STARASSIGN; + + // comparison + case IToken.tEQUAL: return EQUAL; + case IToken.tNOTEQUAL: return NOTEQUAL; + case IToken.tGT: return GT; + case IToken.tGTEQUAL: return GTEQUAL; + case IToken.tLT: return LT; + case IToken.tLTEQUAL: return LTEQUAL; + + // other + case IToken.tASSIGN: return ASSIGN; + case IToken.tCOMMA: return COMMA; + } + + return null; + } +} diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/token/OperatorTokenDuple.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/token/OperatorTokenDuple.java index 66debc44fc7..d95fe326b1e 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/token/OperatorTokenDuple.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/token/OperatorTokenDuple.java @@ -16,6 +16,7 @@ import java.util.List; import org.eclipse.cdt.core.dom.ast.IASTTypeId; import org.eclipse.cdt.core.parser.IToken; import org.eclipse.cdt.core.parser.ITokenDuple; +import org.eclipse.cdt.internal.core.dom.parser.cpp.OverloadableOperator; /** * This class is used by the GNUCPPSourceParser as an intermediate determinant of whether a @@ -28,13 +29,15 @@ public class OperatorTokenDuple implements ITokenDuple { private ITokenDuple token = null; private IASTTypeId typeId = null; private boolean isConversionOperator=false; + private OverloadableOperator op = null; /** * Simple constructor. token is wrapped by this class. * @param token */ - public OperatorTokenDuple(ITokenDuple token) { + public OperatorTokenDuple(ITokenDuple token, OverloadableOperator op) { this.token=token; + this.op = op; } // below are functions used by GNUCPPSourceParser, see IOperatorTokenDuple @@ -64,94 +67,67 @@ public class OperatorTokenDuple implements ITokenDuple { this.typeId = typeId; } + public OverloadableOperator getOperator() { + return op; + } + // below are ITokenDuple functions - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#getFirstToken() - */ public IToken getFirstToken() { return token.getFirstToken(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#getLastToken() - */ + public IToken getLastToken() { return token.getLastToken(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#getTemplateIdArgLists() - */ + public List[] getTemplateIdArgLists() { return token.getTemplateIdArgLists(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#getLastSegment() - */ + public ITokenDuple getLastSegment() { return token.getLastSegment(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#getLeadingSegments() - */ + public ITokenDuple getLeadingSegments() { return token.getLeadingSegments(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#getSegmentCount() - */ + public int getSegmentCount() { return token.getSegmentCount(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#iterator() - */ + public Iterator iterator() { return token.iterator(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#toCharArray() - */ + public char[] toCharArray() { return token.toCharArray(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#length() - */ + public int length() { return token.length(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#getToken(int) - */ + public IToken getToken(int index) { return token.getToken(index); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#getSegments() - */ + public ITokenDuple[] getSegments() { return token.getSegments(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#getStartOffset() - */ + public int getStartOffset() { return token.getStartOffset(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#getEndOffset() - */ + public int getEndOffset() { return token.getEndOffset(); } - /* (non-Javadoc) - * @see org.eclipse.cdt.core.parser.ITokenDuple#extractNameFromTemplateId() - */ + public char[] extractNameFromTemplateId() { return token.extractNameFromTemplateId(); } - /* (non-Javadoc) - * @see java.lang.Object#toString() - */ + public String toString() { return token.toString(); } -- cgit v1.2.3