diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPSpecFailingTest.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPSpecFailingTest.java index 19b3f79e665..f4b300fdf51 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPSpecFailingTest.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPSpecFailingTest.java @@ -95,15 +95,6 @@ public class AST2CPPSpecFailingTest extends AST2SpecBaseTest { parse(getAboveComment(), ParserLanguage.CPP, true, 0); } - // template class X { }; - // template class X { }; // #1 - // template class X { }; // #2 - // template void f(X); // #A - // template void f(X); // #B - public void _test14_5_4_2s2() throws Exception { - parse(getAboveComment(), ParserLanguage.CPP, true, 0); - } - // template A f(A, A); // #1 // template A f(A, A); // same as #1 // template A f(A, A); // different from #1 diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPSpecTest.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPSpecTest.java index b093de6cda3..923da43d6af 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPSpecTest.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPSpecTest.java @@ -18,10 +18,12 @@ import org.eclipse.cdt.core.dom.ast.IASTDeclaration; import org.eclipse.cdt.core.dom.ast.IASTExpression; import org.eclipse.cdt.core.dom.ast.IASTExpressionList; import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition; +import org.eclipse.cdt.core.dom.ast.IASTName; import org.eclipse.cdt.core.dom.ast.IASTProblemDeclaration; import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit; import org.eclipse.cdt.core.dom.ast.IASTTypeId; import org.eclipse.cdt.core.dom.ast.IFunction; +import org.eclipse.cdt.core.dom.ast.IProblemBinding; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTNewExpression; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateId; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTUsingDeclaration; @@ -1765,16 +1767,17 @@ public class AST2CPPSpecTest extends AST2SpecBaseTest { // S x; // typeid // S y; // expression (illformed) public void test8_2s4() throws Exception { - //test is only for syntax, semantics are not checked here. - IASTTranslationUnit tu= parse(getAboveComment(), ParserLanguage.CPP, true, 0); + IASTTranslationUnit tu= parse(getAboveComment(), ParserLanguage.CPP, true, 1); CPPNameCollector col = new CPPNameCollector(); tu.accept(col); assertInstance(col.getName(4), ICPPASTTemplateId.class); assertInstance(((ICPPASTTemplateId)col.getName(4)).getTemplateArguments()[0], IASTTypeId.class); - assertInstance(col.getName(7), ICPPASTTemplateId.class); - assertInstance(((ICPPASTTemplateId)col.getName(7)).getTemplateArguments()[0], IASTExpression.class); + final IASTName S_int_1 = col.getName(7); + assertInstance(S_int_1, ICPPASTTemplateId.class); + assertInstance(((ICPPASTTemplateId)S_int_1).getTemplateArguments()[0], IASTExpression.class); + assertInstance(S_int_1.getBinding(), IProblemBinding.class); } // void foo() @@ -4674,6 +4677,15 @@ public class AST2CPPSpecTest extends AST2SpecBaseTest { parse(getAboveComment(), ParserLanguage.CPP, true, 1); } + // template class X { }; + // template class X { }; // #1 + // template class X { }; // #2 + // template void f(X); // #A + // template void f(X); // #B + public void test14_5_4_2s2() throws Exception { + parse(getAboveComment(), ParserLanguage.CPP, true, 0); + } + // // primary template // template struct A { // void f(); diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2TemplateTests.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2TemplateTests.java index 084870852ba..3e6d75652f2 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2TemplateTests.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2TemplateTests.java @@ -764,30 +764,6 @@ public class AST2TemplateTests extends AST2BaseTest { assertSame(g1, g2); } - // template U f(T); - // void g() { - // f(1); - // } - public void testBug76951_1() throws Exception { - IASTTranslationUnit tu = parse(getAboveComment(), ParserLanguage.CPP); - CPPNameCollector col = new CPPNameCollector(); - tu.accept(col); - - ICPPTemplateParameter T = (ICPPTemplateParameter) col.getName(0).resolveBinding(); - ICPPTemplateParameter T2 = (ICPPTemplateParameter) col.getName(2).resolveBinding(); - assertSame(T, T2); - - ICPPFunctionTemplate f1 = (ICPPFunctionTemplate) col.getName(4).resolveBinding(); - ICPPFunction f2 = (ICPPFunction) col.getName(8).resolveBinding(); - - assertTrue(f2 instanceof ICPPTemplateInstance); - assertSame(((ICPPTemplateInstance)f2).getTemplateDefinition(), f1); - - IFunctionType ft = f2.getType(); - assertTrue(ft.getReturnType() instanceof IBasicType); - assertEquals(((IBasicType)ft.getReturnType()).getType(), IBasicType.t_int); - } - // template class A { // U u; // }; @@ -2891,7 +2867,7 @@ public class AST2TemplateTests extends AST2BaseTest { ICPPVariable _256= ba.assertNonProblem("_256=0x100", 4, ICPPVariable.class); IQualifierType qt1= assertInstance(_256.getType(), IQualifierType.class); ICPPBasicType bt1= assertInstance(qt1.getType(), ICPPBasicType.class); - assertEquals(256, CPPVisitor.parseIntegral(bt1.getValue().toString()).intValue()); + assertEquals(256, _256.getInitialValue().numericalValue().intValue()); ICPPVariable t= ba.assertNonProblem("t;", 1, ICPPVariable.class); ICPPTemplateInstance ci1= assertInstance(t.getType(), ICPPTemplateInstance.class, ICPPClassType.class); @@ -2902,7 +2878,7 @@ public class AST2TemplateTests extends AST2BaseTest { // non-type arguments are currently modelled as a type with attached expression ICPPBasicType bt0= assertInstance(args1.getAt(0), ICPPBasicType.class); assertEquals(bt0.getType(), IBasicType.t_int); - assertEquals(256, CPPVisitor.parseIntegral(bt0.getValue().toString()).intValue()); + assertEquals(256, ci1.getTemplateArguments()[0].getNonTypeValue().numericalValue().intValue()); ICPPTemplateInstance ct= ba.assertNonProblem("C<_256> ", 7, ICPPTemplateInstance.class, ICPPClassType.class); ObjectMap args= ct.getArgumentMap(); @@ -2912,7 +2888,7 @@ public class AST2TemplateTests extends AST2BaseTest { // non-type arguments are currently modelled as a type with attached expression ICPPBasicType bt= assertInstance(args.getAt(0), ICPPBasicType.class); assertEquals(bt.getType(), IBasicType.t_int); - assertEquals(256, CPPVisitor.parseIntegral(bt.getValue().toString()).intValue()); + assertEquals(256, ct.getTemplateArguments()[0].getNonTypeValue().numericalValue().intValue()); ba.assertNonProblem("foo(t)", 3); ba.assertNonProblem("bar(t)", 3); @@ -2939,7 +2915,7 @@ public class AST2TemplateTests extends AST2BaseTest { // class A {}; // // A aint; // should be an error - public void _testTypeArgumentToNonTypeParameter() throws Exception { + public void testTypeArgumentToNonTypeParameter() throws Exception { BindingAssertionHelper ba= new BindingAssertionHelper(getAboveComment(), true); ba.assertProblem("A", 6); } diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2UtilTests.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2UtilTests.java index 5cf7fc84f20..083e76a1c11 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2UtilTests.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2UtilTests.java @@ -22,7 +22,7 @@ import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit; import org.eclipse.cdt.core.dom.ast.IASTTypeIdExpression; import org.eclipse.cdt.core.dom.ast.IFunction; import org.eclipse.cdt.core.parser.ParserLanguage; -import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor; +import org.eclipse.cdt.internal.core.parser.scanner.ExpressionEvaluator; /** * @author dsteffle @@ -166,33 +166,23 @@ public class AST2UtilTests extends AST2BaseTest { } public void testParseIntegral() throws Exception { - assertEquals(0, CPPVisitor.parseIntegral("0").intValue()); - assertEquals(0, CPPVisitor.parseIntegral("+0").intValue()); - assertEquals(0, CPPVisitor.parseIntegral("-0").intValue()); - assertEquals(0, CPPVisitor.parseIntegral("0x0").intValue()); - assertEquals(0, CPPVisitor.parseIntegral("00").intValue()); - assertEquals(0, CPPVisitor.parseIntegral("000").intValue()); - assertEquals(0, CPPVisitor.parseIntegral("0L").intValue()); - assertEquals(0, CPPVisitor.parseIntegral("0LL").intValue()); + assertEquals(0, ExpressionEvaluator.getNumber("0".toCharArray())); + assertEquals(0, ExpressionEvaluator.getNumber("0x0".toCharArray())); + assertEquals(0, ExpressionEvaluator.getNumber("00".toCharArray())); + assertEquals(0, ExpressionEvaluator.getNumber("000".toCharArray())); + assertEquals(0, ExpressionEvaluator.getNumber("0L".toCharArray())); + assertEquals(0, ExpressionEvaluator.getNumber("0LL".toCharArray())); - assertEquals(1, CPPVisitor.parseIntegral("1").intValue()); - assertEquals(1, CPPVisitor.parseIntegral("01").intValue()); - assertEquals(1, CPPVisitor.parseIntegral("0x1").intValue()); - - assertEquals(1, CPPVisitor.parseIntegral("+1").intValue()); - assertEquals(1, CPPVisitor.parseIntegral("+01").intValue()); - assertEquals(1, CPPVisitor.parseIntegral("+0x1").intValue()); - - assertEquals(-1, CPPVisitor.parseIntegral("-1").intValue()); - assertEquals(-1, CPPVisitor.parseIntegral("-01").intValue()); - assertEquals(-1, CPPVisitor.parseIntegral("-0x1").intValue()); - - assertEquals(-10, CPPVisitor.parseIntegral("-10").intValue()); - assertEquals(-8, CPPVisitor.parseIntegral("-010").intValue()); - assertEquals(-16, CPPVisitor.parseIntegral("-0x10").intValue()); + assertEquals(1, ExpressionEvaluator.getNumber("1".toCharArray())); + assertEquals(1, ExpressionEvaluator.getNumber("01".toCharArray())); + assertEquals(1, ExpressionEvaluator.getNumber("0x1".toCharArray())); + + assertEquals(10, ExpressionEvaluator.getNumber("10".toCharArray())); + assertEquals(8, ExpressionEvaluator.getNumber("010".toCharArray())); + assertEquals(16, ExpressionEvaluator.getNumber("0x10".toCharArray())); - assertEquals(-10, CPPVisitor.parseIntegral("-10LLL").intValue()); - assertEquals(-8, CPPVisitor.parseIntegral("-010LLL").intValue()); - assertEquals(-16, CPPVisitor.parseIntegral("-0x10LLL").intValue()); + assertEquals(10, ExpressionEvaluator.getNumber("10LLL".toCharArray())); + assertEquals(8, ExpressionEvaluator.getNumber("010LLL".toCharArray())); + assertEquals(16, ExpressionEvaluator.getNumber("0x10LLL".toCharArray())); } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/Value.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/Value.java index 80b296162aa..711c664d534 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/Value.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/Value.java @@ -20,11 +20,11 @@ import org.eclipse.cdt.core.dom.ast.IASTExpression; import org.eclipse.cdt.core.dom.ast.IASTIdExpression; import org.eclipse.cdt.core.dom.ast.IASTLiteralExpression; import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression; -import org.eclipse.cdt.core.dom.ast.IBasicType; import org.eclipse.cdt.core.dom.ast.IBinding; import org.eclipse.cdt.core.dom.ast.IEnumerator; import org.eclipse.cdt.core.dom.ast.IValue; import org.eclipse.cdt.core.dom.ast.IVariable; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTLiteralExpression; import org.eclipse.cdt.core.dom.ast.cpp.ICPPBinding; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateNonTypeParameter; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter; @@ -46,6 +46,7 @@ public class Value implements IValue { private static class UnknownValueException extends Exception {} private static UnknownValueException UNKNOWN_EX= new UnknownValueException(); + private static int sUnique=0; private final String fValue; private Value(String rep) { @@ -75,17 +76,32 @@ public class Value implements IValue { } return fValue.equals(((IValue) obj).getCanonicalRepresentation()); } + + @Override + public String toString() { + return fValue; + } + /** + * Creates a value representing the given number. + */ public static IValue create(long value) { if (value >=0 && value < TYPICAL.length) return TYPICAL[(int) value]; return new Value(String.valueOf(value)); } + /** + * Creates a value representing the given template parameter. + */ public static IValue create(ICPPTemplateNonTypeParameter tntp) { return new Value(evaluate(tntp)); } + /** + * Tests whether the value is a template parameter, returns the parameter position of the + * parameter, or null if it is not a template parameter. + */ public static int isTemplateParameter(IValue tval) { final String rep= tval.getCanonicalRepresentation(); if (rep.indexOf('#') == 0 && rep.indexOf(',') == -1) { @@ -97,6 +113,17 @@ public class Value implements IValue { return -1; } + /** + * Tests whether the value depends on a template parameter. + */ + public static boolean isDependentValue(IValue nonTypeValue) { + final String rep= nonTypeValue.getCanonicalRepresentation(); + return rep.indexOf('#') >= 0; + } + + /** + * Creates the value for an expression. + */ public static IValue create(IASTExpression expr, int maxRecursionDepth) { try { Object obj= evaluate(expr, maxRecursionDepth); @@ -108,6 +135,9 @@ public class Value implements IValue { return UNKNOWN; } + /** + * Creates a value off its canonical representation. + */ public static IValue fromCanonicalRepresentation(String rep) { if (rep.equals(UNKNOWN.getCanonicalRepresentation())) return UNKNOWN; @@ -119,6 +149,13 @@ public class Value implements IValue { return new Value(rep); } + /** + * Creates a unique value needed during template instantiation. + */ + public static IValue unique() { + return new Value("@" + (++sUnique)); //$NON-NLS-1$ + } + /** * Computes the canonical representation of the value of the expression. Returns a {@code Long} for * numerical values or a {@code String}, otherwise. @@ -189,14 +226,29 @@ public class Value implements IValue { } } if (e instanceof IASTLiteralExpression) { - if (e.getExpressionType() instanceof IBasicType) { + IASTLiteralExpression litEx= (IASTLiteralExpression) e; + switch (litEx.getKind()) { + case ICPPASTLiteralExpression.lk_false: + return "0"; + case ICPPASTLiteralExpression.lk_true: + return "1"; + case IASTLiteralExpression.lk_integer_constant: try { return ExpressionEvaluator.getNumber(e.toString().toCharArray()); } catch (EvalException e1) { throw UNKNOWN_EX; } + case IASTLiteralExpression.lk_char_constant: + try { + final char[] image= e.toString().toCharArray(); + if (image.length > 1) + if (image[0] == 'L') + return ExpressionEvaluator.getChar(image, 2); + return ExpressionEvaluator.getChar(image, 1); + } catch (EvalException e1) { + throw UNKNOWN_EX; + } } - return e.toString(); } throw UNKNOWN_EX; } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAmbiguousTemplateArgument.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAmbiguousTemplateArgument.java index 93c7cbed273..0a043e2a3b3 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAmbiguousTemplateArgument.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAmbiguousTemplateArgument.java @@ -18,6 +18,7 @@ import org.eclipse.cdt.core.dom.ast.IASTIdExpression; import org.eclipse.cdt.core.dom.ast.IASTNode; import org.eclipse.cdt.core.dom.ast.IASTTypeId; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTAmbiguousTemplateArgument; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateId; import org.eclipse.cdt.internal.core.parser.ParserMessages; /** @@ -34,7 +35,7 @@ public class CPPASTAmbiguousTemplateArgument extends CPPASTAmbiguity implements * in the future */ public CPPASTAmbiguousTemplateArgument(IASTNode... nodes) { - fNodes= new ArrayList(); + fNodes= new ArrayList(2); for(IASTNode node : nodes) { if(node instanceof IASTTypeId || node instanceof IASTIdExpression) { fNodes.add(node); @@ -62,7 +63,7 @@ public class CPPASTAmbiguousTemplateArgument extends CPPASTAmbiguity implements private void addNode(IASTNode node) { fNodes.add(node); node.setParent(this); - node.setPropertyInParent(CPPASTTemplateId.TEMPLATE_ID_ARGUMENT); + node.setPropertyInParent(ICPPASTTemplateId.TEMPLATE_ID_ARGUMENT); } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassTemplatePartialSpecialization.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassTemplatePartialSpecialization.java index e88af3b2660..914bbbc8363 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassTemplatePartialSpecialization.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassTemplatePartialSpecialization.java @@ -36,14 +36,10 @@ public class CPPClassTemplatePartialSpecialization extends CPPClassTemplate } public ICPPTemplateArgument[] getTemplateArguments() { - createArguments(); - return arguments; - } - - private void createArguments() { if (arguments == null) { arguments= CPPTemplates.createTemplateArgumentArray((ICPPASTTemplateId) getTemplateName()); } + return arguments; } /* (non-Javadoc) diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassTemplateSpecialization.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassTemplateSpecialization.java index 451e4452f9c..9f15c151bae 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassTemplateSpecialization.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassTemplateSpecialization.java @@ -21,7 +21,6 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameterMap; import org.eclipse.cdt.core.parser.util.ObjectMap; -import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPTemplates; /** * Represents a specialization of a class-template @@ -62,7 +61,7 @@ public class CPPClassTemplateSpecialization extends CPPClassSpecialization ICPPTemplateArgument[] args = (ICPPTemplateArgument[]) instances.keyAt(i); if (args.length == arguments.length) { for (int j=0; j < args.length; j++) { - if (!CPPTemplates.isSameTemplateArgument(args[j], arguments[j])) { + if (!args[j].isSameValue(arguments[j])) { continue loop; } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPDeferredFunctionInstance.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPDeferredFunctionInstance.java index 9044d4c7b7e..601ead3f614 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPDeferredFunctionInstance.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPDeferredFunctionInstance.java @@ -39,7 +39,6 @@ public class CPPDeferredFunctionInstance extends CPPUnknownBinding implements IC private ICPPTemplateArgument[] fArguments; private ICPPFunctionTemplate fFunctionTemplate; - private ICPPTemplateParameterMap fArgmap; private IParameter [] fParameters; private IFunctionType fFunctionType; @@ -59,15 +58,11 @@ public class CPPDeferredFunctionInstance extends CPPUnknownBinding implements IC @Deprecated public ObjectMap getArgumentMap() { - return CPPTemplates.getArgumentMap(fFunctionTemplate, getTemplateParameterMap()); + return ObjectMap.EMPTY_MAP; } public ICPPTemplateParameterMap getTemplateParameterMap() { - // mstodo- deferred function instance and tpmap - if (fArgmap == null) { - fArgmap= CPPTemplates.createParameterMap(fFunctionTemplate, getTemplateArguments()); - } - return fArgmap; + return CPPTemplateParameterMap.EMPTY; } @Deprecated @@ -80,7 +75,6 @@ public class CPPDeferredFunctionInstance extends CPPUnknownBinding implements IC } public IParameter[] getParameters() throws DOMException { - // mstodo- deferred function instance and tpmap if( fParameters == null ){ IParameter [] params = ((ICPPFunction)getTemplateDefinition()).getParameters(); fParameters = new IParameter[ params.length ]; diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPFunctionTemplateSpecialization.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPFunctionTemplateSpecialization.java index 14508f7ead7..253c8005f16 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPFunctionTemplateSpecialization.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPFunctionTemplateSpecialization.java @@ -20,7 +20,6 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameterMap; import org.eclipse.cdt.core.parser.util.ObjectMap; -import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPTemplates; /** * The specialization of a friend function template in the context of a class specialization. @@ -51,7 +50,7 @@ public class CPPFunctionTemplateSpecialization extends CPPFunctionSpecialization ICPPTemplateArgument[] args = (ICPPTemplateArgument[]) instances.keyAt(i); if (args.length == arguments.length) { for (int j=0; j < args.length; j++) { - if (!CPPTemplates.isSameTemplateArgument(args[j], arguments[j])) { + if (!args[j].isSameValue(arguments[j])) { continue loop; } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateArgument.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateArgument.java index cdd288e9dd3..c21ca1e75ab 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateArgument.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateArgument.java @@ -56,7 +56,7 @@ public class CPPTemplateArgument implements ICPPTemplateArgument { public boolean isSameValue(ICPPTemplateArgument arg) { if (fValue != null) { - return fValue.equals(arg.getNonTypeValue()) && fType.equals(arg.getTypeOfNonTypeValue()); + return fValue.equals(arg.getNonTypeValue()); } return fType.isSameType(arg.getTypeValue()); } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateDefinition.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateDefinition.java index b5cd7a6ab67..fe2ec1837b9 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateDefinition.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateDefinition.java @@ -110,7 +110,7 @@ public abstract class CPPTemplateDefinition extends PlatformObject implements IC ICPPTemplateArgument[] args = (ICPPTemplateArgument[]) instances.keyAt(i); if (args.length == arguments.length) { for (int j=0; j < args.length; j++) { - if (!CPPTemplates.isSameTemplateArgument(args[j], arguments[j])) { + if (!args[j].isSameValue(arguments[j])) { continue loop; } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateTemplateParameter.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateTemplateParameter.java index 078f08e3f1c..9c76aed036e 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateTemplateParameter.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateTemplateParameter.java @@ -198,7 +198,7 @@ public class CPPTemplateTemplateParameter extends CPPTemplateParameter implement ICPPTemplateArgument[] args = (ICPPTemplateArgument[]) instances.keyAt(i); if (args.length == arguments.length) { for (int j=0; j < args.length; j++) { - if (!CPPTemplates.isSameTemplateArgument(args[j], arguments[j])) { + if (!args[j].isSameValue(arguments[j])) { continue loop; } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPUnknownClassInstance.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPUnknownClassInstance.java index e4ccec643be..81372de71a8 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPUnknownClassInstance.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPUnknownClassInstance.java @@ -19,9 +19,8 @@ import org.eclipse.cdt.core.dom.ast.IType; import org.eclipse.cdt.core.dom.ast.ITypedef; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateArgument; import org.eclipse.cdt.core.parser.util.CharArrayUtils; -import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPTemplates; -/* +/** * Represents a partially instantiated C++ class template, declaration of which is not yet available. * * @author Sergey Prigogin @@ -65,7 +64,7 @@ public class CPPUnknownClassInstance extends CPPUnknownClass implements ICPPUnkn return false; for (int i= 0; i < lhsArgs.length; i++) { - if (!CPPTemplates.isSameTemplateArgument(lhsArgs[i],rhsArgs[i])) + if (!lhsArgs[i].isSameValue(rhsArgs[i])) return false; } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPSemantics.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPSemantics.java index 637ca1ff1bc..b4624f595f6 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPSemantics.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPSemantics.java @@ -67,6 +67,7 @@ import org.eclipse.cdt.core.dom.ast.IProblemBinding; import org.eclipse.cdt.core.dom.ast.IQualifierType; import org.eclipse.cdt.core.dom.ast.IScope; import org.eclipse.cdt.core.dom.ast.IType; +import org.eclipse.cdt.core.dom.ast.IValue; import org.eclipse.cdt.core.dom.ast.IVariable; import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier.IASTEnumerator; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCatchHandler; @@ -131,6 +132,7 @@ import org.eclipse.cdt.internal.core.dom.parser.ASTInternal; import org.eclipse.cdt.internal.core.dom.parser.ASTNode; import org.eclipse.cdt.internal.core.dom.parser.IASTInternalScope; import org.eclipse.cdt.internal.core.dom.parser.ProblemBinding; +import org.eclipse.cdt.internal.core.dom.parser.Value; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTFieldReference; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTIdExpression; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTName; @@ -323,7 +325,10 @@ public class CPPSemantics { for (int i = 0; useOriginal && i < pars.length; i++) { ICPPTemplateParameter par= pars[i]; if (par instanceof ICPPTemplateNonTypeParameter) { - // mstodo change this + IValue val= args[i].getNonTypeValue(); + if (val == null || par.getParameterPosition() != Value.isTemplateParameter(val)) { + useOriginal= false; + } } else { if (!((IType) par).isSameType(args[i].getTypeValue())) { useOriginal= false; @@ -337,20 +342,6 @@ public class CPPSemantics { } catch (DOMException e) { } } - // mstodo+ remove -// final ObjectMap argMap = deferred.getArgumentMap(); -// if (argMap != null) { -// for (int i = 0; useOriginal && i < argMap.size(); i++) { -// final Object key = argMap.keyAt(i); -// if (!key.equals(argMap.getAt(i))) { -// // bug 231868 non type parameters are modeled via their type :-( -// if (key instanceof ICPPTemplateNonTypeParameter == false) { -// useOriginal= false; -// break; -// } -// } -// } -// } } } if (name.getParent() instanceof ICPPASTTemplateId) { diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPTemplates.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPTemplates.java index 5bdf0a08c9f..e56e0edc762 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPTemplates.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPTemplates.java @@ -13,12 +13,10 @@ *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.parser.cpp.semantics; -import java.math.BigInteger; import java.util.ArrayList; import java.util.Collections; import java.util.List; -import org.eclipse.cdt.core.CCorePlugin; import org.eclipse.cdt.core.dom.ast.DOMException; import org.eclipse.cdt.core.dom.ast.IASTCompositeTypeSpecifier; import org.eclipse.cdt.core.dom.ast.IASTDeclSpecifier; @@ -27,8 +25,6 @@ import org.eclipse.cdt.core.dom.ast.IASTDeclarator; import org.eclipse.cdt.core.dom.ast.IASTElaboratedTypeSpecifier; import org.eclipse.cdt.core.dom.ast.IASTExpression; import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition; -import org.eclipse.cdt.core.dom.ast.IASTIdExpression; -import org.eclipse.cdt.core.dom.ast.IASTLiteralExpression; import org.eclipse.cdt.core.dom.ast.IASTName; import org.eclipse.cdt.core.dom.ast.IASTNode; import org.eclipse.cdt.core.dom.ast.IASTParameterDeclaration; @@ -62,7 +58,6 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateId; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateParameter; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateSpecialization; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplatedTypeTemplateParameter; -import org.eclipse.cdt.core.dom.ast.cpp.ICPPBasicType; import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassSpecialization; import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplate; import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplatePartialSpecialization; @@ -96,7 +91,6 @@ import org.eclipse.cdt.internal.core.dom.parser.ASTInternal; import org.eclipse.cdt.internal.core.dom.parser.ITypeContainer; import org.eclipse.cdt.internal.core.dom.parser.ProblemBinding; import org.eclipse.cdt.internal.core.dom.parser.Value; -import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTLiteralExpression; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPBasicType; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassInstance; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassSpecialization; @@ -186,8 +180,7 @@ public class CPPTemplates { int numParams = params.length; for (int i = 0; i < numParams; i++) { final ICPPTemplateParameter param = params[i]; - // mstodo check non-type parameters, also - if (param instanceof IType && tpMap.getArgument(param) == null) + if (tpMap.getArgument(param) == null) return null; } @@ -231,37 +224,45 @@ public class CPPTemplates { arg= instantiateArgument(defaultArg, map, null); } - if (CPPTemplates.matchTemplateParameterAndArgument(param, getArgument(arg), map)) { - if (!param.equals(getArgument(arg))) { - map.put(param, arg); - } - actualArgs[i] = arg; - if (CPPTemplates.isDependentArgument(arg)) { - argsContainDependentType = true; - } - } else { + arg= CPPTemplates.matchTemplateParameterAndArgument(param, arg, map); + if (arg == null) return null; + + if (!argIsParameter(arg, param)) { + map.put(param, arg); + } + actualArgs[i] = arg; + if (CPPTemplates.isDependentArgument(arg)) { + argsContainDependentType = true; } - } - - ICPPTemplateInstance instance= getInstance(template, arguments); - // we do not correctly distinguish between type and non-type parameters, this works - // around getting the wrong instance when providing a value rather than a type. - if (instance != null) { - if (argsContainDependentType || !(instance instanceof ICPPDeferredClassInstance)) - return instance; } if (argsContainDependentType) { return deferredInstance(template, actualArgs); } + ICPPTemplateInstance instance= getInstance(template, arguments); + if (instance != null) { + return instance; + } + IBinding owner= template.getOwner(); instance = CPPTemplates.createInstance(owner, template, map, actualArgs); addInstance(template, actualArgs, instance); return instance; } + private static boolean argIsParameter(ICPPTemplateArgument arg, ICPPTemplateParameter param) { + if (param instanceof ICPPTemplateNonTypeParameter) { + return arg.isNonTypeValue() && Value.isTemplateParameter(arg.getNonTypeValue()) == param.getParameterPosition(); + } + if (param instanceof IType) { + return arg.isTypeValue() && ((IType) param).isSameType(arg.getTypeValue()); + } + assert false; + return false; + } + /** * Obtains a cached instance from the template. */ @@ -311,10 +312,7 @@ public class CPPTemplates { args[i] = new CPPTemplateArgument((IType) tp); } else if (tp instanceof ICPPTemplateNonTypeParameter) { final ICPPTemplateNonTypeParameter nttp = (ICPPTemplateNonTypeParameter) tp; - // mstodo for now stick to the type - args[i]= new CPPTemplateArgument(nttp.getType()); - - // args[i] = new CPPTemplateArgument(Value.create(nttp), nttp.getType()); + args[i] = new CPPTemplateArgument(Value.create(nttp), nttp.getType()); } else { assert false; } @@ -572,7 +570,7 @@ public class CPPTemplates { ICPPTemplateArgument[] args= createTemplateArgumentArray(id); CPPTemplateParameterMap tpMap = new CPPTemplateParameterMap(templateParams.length); if (templateParams.length != args.length) { - return null; //TODO problem + return null; // mstodo problem or use default args? } for (int i = 0; i < templateParams.length; i++) { tpMap.put(templateParams[i], args[i]); @@ -723,7 +721,7 @@ public class CPPTemplates { if (!deduceTemplateParameterMapFromFunctionParameters(tmpl, functionParameters, map)) continue; } catch (DOMException e) { - continue; // mstodo potential failure + continue; } ICPPTemplateParameter[] params = null; @@ -747,11 +745,12 @@ public class CPPTemplates { if (arg == null) { map.put(param, deducedArg); arg = deducedArg; - } else if (!CPPTemplates.isSameTemplateArgument(deducedArg, arg)) { + } else if (!deducedArg.isSameValue(arg)) { continue outer; } } - if (arg == null || !matchTemplateParameterAndArgument(param, getArgument(arg), map)) { + arg= matchTemplateParameterAndArgument(param, arg, map); + if (arg == null) { continue outer; } } @@ -766,8 +765,7 @@ public class CPPTemplates { } /** - * return Object[] of { ObjectMap, IType[] } - * @throws DOMException + * Deduce arguments for a template function from the template id + the template function parameters. */ static protected ICPPTemplateArgument[] deduceTemplateFunctionArguments(ICPPFunctionTemplate primaryTemplate, IASTParameterDeclaration[] ps, ICPPASTTemplateId id, CPPTemplateParameterMap map) throws DOMException { @@ -797,11 +795,12 @@ public class CPPTemplates { if (arg == null) { map.put(param, deducedArg); arg = deducedArg; - } else if (!CPPTemplates.isSameTemplateArgument(deducedArg, arg)) { + } else if (!deducedArg.isSameValue(arg)) { return null; } } - if (arg == null || !matchTemplateParameterAndArgument(param, getArgument(arg), map)) + arg= matchTemplateParameterAndArgument(param, arg, map); + if (arg == null) return null; result[i] = arg; @@ -1264,7 +1263,7 @@ public class CPPTemplates { if (args.length == specArgs.length) { result= true; for (int i=0; i < args.length; i++) { - if (!isSameTemplateArgument(specArgs[i], args[i])) { + if (!specArgs[i].isSameValue(args[i])) { result= false; break; } @@ -1284,37 +1283,6 @@ public class CPPTemplates { return result; } - - /** - * @param argA may be null - * @param argB may be null - * @return whether the two specified template arguments are the same - * @deprecated use {@link ICPPTemplateArgument#isSameValue(ICPPTemplateArgument)} - */ - @Deprecated - public static final boolean isSameTemplateArgument(IType argA, IType argB) { - if (argA == argB) - return true; - - // special case treatment for non-type integral parameters - if (argA instanceof ICPPBasicType && argB instanceof ICPPBasicType) { - try { - IASTExpression eA= ((ICPPBasicType) argA).getValue(); - IASTExpression eB= ((ICPPBasicType) argB).getValue(); - if (eA != null && eB != null) { - // TODO - we should normalize template arguments - // rather than check their original expressions - // are equivalent. - return isNonTypeArgumentConvertible(argA, argB) && expressionsEquivalent(eA, eB); - } - } catch (DOMException de) { - CCorePlugin.log(de); - return false; - } - } - - return argA != null && argB != null && argA.isSameType(argB); - } /** * @param id the template id containing the template arguments @@ -1328,23 +1296,20 @@ public class CPPTemplates { result = new ICPPTemplateArgument[params.length]; for (int i = 0; i < params.length; i++) { IASTNode param= params[i]; - /* - * id-expression's which resolve to const variables can be - * modeled by the type of the initialized expression (which - * will include its value) - */ - if (param instanceof IASTIdExpression) { - param= CPPVisitor.reverseConstantPropagationLookup((IASTIdExpression)param); - } - IType type= CPPVisitor.createType(param); // prevent null pointer exception when the type cannot be determined // happens when templates with still ambiguous template-ids are accessed during - // resolution of other ambiguities. + // resolution of other template-id ambiguities. + // mstodo: fix by introducing partially resolved template parameters if (type == null) type= new CPPBasicType(-1, 0); - - result[i]= new CPPTemplateArgument(type); + + if (param instanceof IASTExpression) { + IValue value= Value.create((IASTExpression) param, Value.MAX_RECURSION_DEPTH); + result[i]= new CPPTemplateArgument(value, type); + } else { + result[i]= new CPPTemplateArgument(type); + } } } return result; @@ -1381,8 +1346,7 @@ public class CPPTemplates { return result; } - static protected IFunction[] selectTemplateFunctions( - ObjectSet templates, + static protected IFunction[] selectTemplateFunctions(ObjectSet templates, Object[] functionArguments, IASTName name) { if (templates == null || templates.size() == 0) @@ -1420,47 +1384,24 @@ public class CPPTemplates { } int numTemplateParams = templateParams.length; - IType[] instanceArgs = null; + ICPPTemplateArgument[] instanceArgs = null; for (int i = 0; i < numTemplateParams; i++) { - IType arg = (i < numTemplateArgs && templateArguments != null) ? getArgument(templateArguments[i]) : null; - IType mapped = getArgument(map.getArgument(templateParams[i])); + ICPPTemplateArgument arg = (i < numTemplateArgs && templateArguments != null) ? templateArguments[i] : null; + ICPPTemplateArgument mapped = map.getArgument(templateParams[i]); if (arg != null && mapped != null) { - if (arg.isSameType(mapped)) // compare as IType: 'mapped' is not a template argument - instanceArgs = (IType[]) ArrayUtil.append(IType.class, instanceArgs, arg); + if (arg.isSameValue(mapped)) + instanceArgs = (ICPPTemplateArgument[]) ArrayUtil.append(ICPPTemplateArgument.class, instanceArgs, arg); else continue outer; } else if (arg == null && mapped == null) { - IType def = null; - try { - if (templateParams[i] instanceof ICPPTemplateTypeParameter) { - def = ((ICPPTemplateTypeParameter) templateParams[i]).getDefault(); - } else if (templateParams[i] instanceof ICPPTemplateTemplateParameter) { - def = ((ICPPTemplateTemplateParameter) templateParams[i]).getDefault(); - } else if (templateParams[i] instanceof ICPPTemplateNonTypeParameter) { - def = CPPVisitor.getExpressionType(((ICPPTemplateNonTypeParameter) templateParams[i]).getDefault()); - } - } catch (DOMException e) { - continue outer; - } - if (def != null) { - if (def instanceof ICPPTemplateParameter) { - for (int j = 0; j < i; j++) { - if (templateParams[j] == def && instanceArgs != null) { - def = instanceArgs[j]; - } - } - } - instanceArgs = (IType[]) ArrayUtil.append(IType.class, instanceArgs, def); - } else { - continue outer; - } + continue outer; } else { - instanceArgs = (IType[]) ArrayUtil.append(IType.class, instanceArgs, (arg != null) ? arg : mapped); + instanceArgs = (ICPPTemplateArgument[]) ArrayUtil.append(ICPPTemplateArgument.class, instanceArgs, (arg != null) ? arg : mapped); } } - instanceArgs= (IType[]) ArrayUtil.trim(IType.class, instanceArgs); - IBinding temp= instantiate(template, convert(instanceArgs)); + instanceArgs= (ICPPTemplateArgument[]) ArrayUtil.trim(ICPPTemplateArgument.class, instanceArgs); + IBinding temp= instantiate(template, instanceArgs); if (temp instanceof IFunction) { instances = (IFunction[]) ArrayUtil.append(IFunction.class, instances, temp); } @@ -1526,20 +1467,19 @@ public class CPPTemplates { if (p.isNonTypeValue()) { IValue tval= p.getNonTypeValue(); - IValue sval= a.getNonTypeValue(); - if (tval.equals(sval)) - return true; - - int parPos= Value.isTemplateParameter(tval); - if (parPos == -1) - return false; - ICPPTemplateArgument old= map.getArgument(parPos); - if (old == null) { - map.put(parPos, a); - return true; + int parPos= Value.isTemplateParameter(tval); + if (parPos >= 0) { + ICPPTemplateArgument old= map.getArgument(parPos); + if (old == null) { + map.put(parPos, a); + return true; + } + return old.isSameValue(a); } - return old.isSameValue(a); + + IValue sval= a.getNonTypeValue(); + return tval.equals(sval); } return deduceTemplateParameterMap(p.getTypeValue(), a.getTypeValue(), map); @@ -1603,138 +1543,98 @@ public class CPPTemplates { return result; } - private static boolean expressionsEquivalent(IASTExpression e1, IASTExpression e2) { - if (e1 == null) - return true; - - e1= CPPVisitor.reverseConstantPropagationLookup(e1); - e2= CPPVisitor.reverseConstantPropagationLookup(e2); - - if (e1 instanceof IASTLiteralExpression && e2 instanceof IASTLiteralExpression) { - IType t1= e1.getExpressionType(); - IType t2= e2.getExpressionType(); - try { - if (t1 instanceof ICPPBasicType && t2 instanceof ICPPBasicType) { - BigInteger i1= CPPVisitor.parseIntegral(e1.toString()); - BigInteger i2= CPPVisitor.parseIntegral(e2.toString()); - return i1.equals(i2); - } - } catch (NumberFormatException nfe) { - /* fall through */ - } - return e1.toString().equals(e2.toString()); - } - return false; - } - private static boolean deduceTemplateParameterMap(IType p, IType a, CPPTemplateParameterMap map) throws DOMException { boolean pIsAReferenceType = (p instanceof ICPPReferenceType); p = getParameterTypeForDeduction(p); a = getArgumentTypeForDeduction(a, pIsAReferenceType); - if (p instanceof IBasicType) { - if (a instanceof IBasicType) { - IBasicType pbt= (IBasicType) p; - IBasicType abt= (IBasicType) a; - - // non-type argument comparison - if (pbt.getValue() != null && abt.getValue() != null) { - return isNonTypeArgumentConvertible(p, a) - && expressionsEquivalent(pbt.getValue(), abt.getValue()); - } - - // type argument comparison + while (p != null) { + while (a instanceof ITypedef) + a = ((ITypedef) a).getType(); + if (p instanceof IBasicType) { return p.isSameType(a); - } - } else { - while (p != null) { - while (a instanceof ITypedef) - a = ((ITypedef) a).getType(); - if (p instanceof IBasicType) { - return p.isSameType(a); - } else if (p instanceof ICPPPointerToMemberType) { - if (!(a instanceof ICPPPointerToMemberType)) - return false; - if (!deduceTemplateParameterMap(((ICPPPointerToMemberType) p).getMemberOfClass(), ((ICPPPointerToMemberType) a).getMemberOfClass(), - map)) { - return false; - } - p = ((ICPPPointerToMemberType) p).getType(); - a = ((ICPPPointerToMemberType) a).getType(); - } else if (p instanceof IPointerType) { - if (!(a instanceof IPointerType)) { - return false; - } - p = ((IPointerType) p).getType(); - a = ((IPointerType) a).getType(); - } else if (p instanceof IQualifierType) { - if (a instanceof IQualifierType) { - a = ((IQualifierType) a).getType(); //TODO a = strip qualifiers from p out of a - } - p = ((IQualifierType) p).getType(); - } else if (p instanceof IFunctionType) { - if (!(a instanceof IFunctionType)) - return false; - if (!deduceTemplateParameterMap(((IFunctionType) p).getReturnType(), ((IFunctionType) a).getReturnType(), - map)) { - return false; - } - IType[] pParams = ((IFunctionType) p).getParameterTypes(); - IType[] aParams = ((IFunctionType) a).getParameterTypes(); - if (pParams.length != aParams.length) - return false; - for (int i = 0; i < pParams.length; i++) { - if (!deduceTemplateParameterMap(pParams[i], aParams[i], map)) - return false; - } - return true; - } else if (p instanceof ICPPTemplateParameter) { - ICPPTemplateArgument current= map.getArgument((ICPPTemplateParameter) p); - if (current != null) { - if (current.isNonTypeValue()) - return false; - return current.getTypeValue().isSameType(a); - } - if (a == null) - return false; - map.put((ICPPTemplateParameter)p, new CPPTemplateArgument(a)); - return true; - } else if (p instanceof ICPPTemplateInstance) { - if (!(a instanceof ICPPTemplateInstance)) - return false; - ICPPTemplateInstance pInst = (ICPPTemplateInstance) p; - ICPPTemplateInstance aInst = (ICPPTemplateInstance) a; - - ICPPTemplateArgument[] pArgs = pInst.getTemplateArguments(); - pArgs= pArgs == null ? ICPPTemplateArgument.EMPTY_ARGUMENTS : pArgs; // aftodo - unnecessary? - - ICPPTemplateParameterMap aMap = aInst.getTemplateParameterMap(); - if (aMap != null && !(aInst.getTemplateDefinition() instanceof ICPPClassTemplatePartialSpecialization)) { - ICPPTemplateParameter[] aParams = aInst.getTemplateDefinition().getTemplateParameters(); - if (pArgs.length != aParams.length) - return false; - for (int i = 0; i < pArgs.length; i++) { - ICPPTemplateArgument t = aMap.getArgument(aParams[i]); - if (t == null || !deduceTemplateParameterMap(pArgs[i], t, map)) - return false; - } - } else { - ICPPTemplateArgument[] aArgs = aInst.getTemplateArguments(); - aArgs= aArgs == null ? ICPPTemplateArgument.EMPTY_ARGUMENTS : aArgs; // aftodo - unnecessary? - - if (aArgs.length != pArgs.length) - return false; - for (int i = 0; i < pArgs.length; i++) { - if (!deduceTemplateParameterMap(pArgs[i], aArgs[i], map)) - return false; - } - } - return true; - } else if (p instanceof ICPPUnknownBinding) { - return true; // An unknown type may match anything. - } else { - return p.isSameType(a); + } else if (p instanceof ICPPPointerToMemberType) { + if (!(a instanceof ICPPPointerToMemberType)) + return false; + if (!deduceTemplateParameterMap(((ICPPPointerToMemberType) p).getMemberOfClass(), ((ICPPPointerToMemberType) a).getMemberOfClass(), + map)) { + return false; } + p = ((ICPPPointerToMemberType) p).getType(); + a = ((ICPPPointerToMemberType) a).getType(); + } else if (p instanceof IPointerType) { + if (!(a instanceof IPointerType)) { + return false; + } + p = ((IPointerType) p).getType(); + a = ((IPointerType) a).getType(); + } else if (p instanceof IQualifierType) { + if (a instanceof IQualifierType) { + a = ((IQualifierType) a).getType(); //TODO a = strip qualifiers from p out of a + } + p = ((IQualifierType) p).getType(); + } else if (p instanceof IFunctionType) { + if (!(a instanceof IFunctionType)) + return false; + if (!deduceTemplateParameterMap(((IFunctionType) p).getReturnType(), ((IFunctionType) a).getReturnType(), + map)) { + return false; + } + IType[] pParams = ((IFunctionType) p).getParameterTypes(); + IType[] aParams = ((IFunctionType) a).getParameterTypes(); + if (pParams.length != aParams.length) + return false; + for (int i = 0; i < pParams.length; i++) { + if (!deduceTemplateParameterMap(pParams[i], aParams[i], map)) + return false; + } + return true; + } else if (p instanceof ICPPTemplateParameter) { + ICPPTemplateArgument current= map.getArgument((ICPPTemplateParameter) p); + if (current != null) { + if (current.isNonTypeValue()) + return false; + return current.getTypeValue().isSameType(a); + } + if (a == null) + return false; + map.put((ICPPTemplateParameter)p, new CPPTemplateArgument(a)); + return true; + } else if (p instanceof ICPPTemplateInstance) { + if (!(a instanceof ICPPTemplateInstance)) + return false; + ICPPTemplateInstance pInst = (ICPPTemplateInstance) p; + ICPPTemplateInstance aInst = (ICPPTemplateInstance) a; + + ICPPTemplateArgument[] pArgs = pInst.getTemplateArguments(); + pArgs= pArgs == null ? ICPPTemplateArgument.EMPTY_ARGUMENTS : pArgs; // aftodo - unnecessary? + + ICPPTemplateParameterMap aMap = aInst.getTemplateParameterMap(); + if (aMap != null && !(aInst.getTemplateDefinition() instanceof ICPPClassTemplatePartialSpecialization)) { + ICPPTemplateParameter[] aParams = aInst.getTemplateDefinition().getTemplateParameters(); + if (pArgs.length != aParams.length) + return false; + for (int i = 0; i < pArgs.length; i++) { + ICPPTemplateArgument t = aMap.getArgument(aParams[i]); + if (t == null || !deduceTemplateParameterMap(pArgs[i], t, map)) + return false; + } + } else { + ICPPTemplateArgument[] aArgs = aInst.getTemplateArguments(); + aArgs= aArgs == null ? ICPPTemplateArgument.EMPTY_ARGUMENTS : aArgs; // aftodo - unnecessary? + + if (aArgs.length != pArgs.length) + return false; + for (int i = 0; i < pArgs.length; i++) { + if (!deduceTemplateParameterMap(pArgs[i], aArgs[i], map)) + return false; + } + } + return true; + } else if (p instanceof ICPPUnknownBinding) { + return true; // An unknown type may match anything. + } else { + return p.isSameType(a); } } @@ -1754,24 +1654,17 @@ public class CPPTemplates { * for each occurrence of that parameter in the function parameter list * @throws DOMException */ - static private IType[] createArgsForFunctionTemplateOrdering(ICPPFunctionTemplate template) + static private ICPPTemplateArgument[] createArgsForFunctionTemplateOrdering(ICPPFunctionTemplate template) throws DOMException{ ICPPTemplateParameter[] paramList = template.getTemplateParameters(); int size = paramList.length; - IType[] args = new IType[size]; + ICPPTemplateArgument[] args = new ICPPTemplateArgument[size]; for (int i = 0; i < size; i++) { ICPPTemplateParameter param = paramList[i]; if (param instanceof ICPPTemplateNonTypeParameter) { - IType t = ((ICPPTemplateNonTypeParameter) param).getType(); - if (t instanceof CPPBasicType) { - CPPASTLiteralExpression exp = new CPPASTLiteralExpression(); - exp.setValue(String.valueOf(i)); - CPPBasicType temp = (CPPBasicType) t.clone(); - temp.setFromExpression(exp); // mstodo- is that necessary?? - args[i] = temp; - } + args[i]= new CPPTemplateArgument(Value.unique(), ((ICPPTemplateNonTypeParameter) param).getType()); } else { - args[i] = new CPPBasicType(-1, 0); + args[i] = new CPPTemplateArgument(new CPPBasicType(-1, 0)); } } return args; @@ -1784,14 +1677,14 @@ public class CPPTemplates { CPPTemplateParameterMap m1= new CPPTemplateParameterMap(2); CPPTemplateParameterMap m2= new CPPTemplateParameterMap(2); - IType[] args = createArgsForFunctionTemplateOrdering(f1); - IBinding function = instantiate(f1, convert(args)); + ICPPTemplateArgument[] args = createArgsForFunctionTemplateOrdering(f1); + IBinding function = instantiate(f1, args); if (function instanceof ICPPFunction) if (!deduceTemplateParameterMapFromFunctionParameters(f2, ((ICPPFunction) function).getType().getParameterTypes(), m1)) m1= null; args = createArgsForFunctionTemplateOrdering(f2); - function = instantiate(f2, convert(args)); + function = instantiate(f2, args); if (function instanceof ICPPFunction) if (!deduceTemplateParameterMapFromFunctionParameters(f1, ((ICPPFunction) function).getType().getParameterTypes(), m2)) m2= null; @@ -1951,69 +1844,89 @@ public class CPPTemplates { } } - static private boolean isValidArgument(ICPPTemplateParameter param, IType argument) { + static private boolean isValidArgument(ICPPTemplateParameter param, ICPPTemplateArgument argument) { + IType t= argument.getTypeValue(); try { - while (argument instanceof ITypeContainer) { - argument = ((ITypeContainer) argument).getType(); + while (t instanceof ITypeContainer) { + t = ((ITypeContainer) t).getType(); } } catch (DOMException e) { return false; } - return !(argument instanceof IProblemBinding); + return !(t instanceof IProblemBinding); } - static protected boolean matchTemplateParameterAndArgument(ICPPTemplateParameter param, IType argument, - CPPTemplateParameterMap map) { - if (!isValidArgument(param, argument)) { - return false; + static protected ICPPTemplateArgument matchTemplateParameterAndArgument(ICPPTemplateParameter param, + ICPPTemplateArgument arg, CPPTemplateParameterMap map) { + if (arg == null || !isValidArgument(param, arg)) { + return null; } if (param instanceof ICPPTemplateTypeParameter) { - return true; - } + IType t= arg.getTypeValue(); + if (t != null && ! (t instanceof ICPPTemplateDefinition)) + return arg; + return null; + } + if (param instanceof ICPPTemplateTemplateParameter) { - if (!(argument instanceof ICPPTemplateDefinition)) - return false; + IType t= arg.getTypeValue(); + if (!(t instanceof ICPPTemplateDefinition)) + return null; ICPPTemplateParameter[] pParams = null; ICPPTemplateParameter[] aParams = null; try { pParams = ((ICPPTemplateTemplateParameter) param).getTemplateParameters(); - aParams = ((ICPPTemplateDefinition) argument).getTemplateParameters(); + aParams = ((ICPPTemplateDefinition) t).getTemplateParameters(); } catch (DOMException e) { - return false; + return null; } int size = pParams.length; if (aParams.length != size) { - return false; + return null; } for (int i = 0; i < size; i++) { - if ((pParams[i] instanceof ICPPTemplateTypeParameter && !(aParams[i] instanceof ICPPTemplateTypeParameter)) || - (pParams[i] instanceof ICPPTemplateTemplateParameter && !(aParams[i] instanceof ICPPTemplateTemplateParameter)) || - (pParams[i] instanceof ICPPTemplateNonTypeParameter && !(aParams[i] instanceof ICPPTemplateNonTypeParameter))) { - return false; + final ICPPTemplateParameter pParam = pParams[i]; + final ICPPTemplateParameter aParam = aParams[i]; + boolean pb= pParam instanceof ICPPTemplateTypeParameter; + boolean ab= aParam instanceof ICPPTemplateTypeParameter; + if (pb != ab) + return null; + if (!pb) { + pb= pParam instanceof ICPPTemplateNonTypeParameter; + ab= aParam instanceof ICPPTemplateNonTypeParameter; + if (pb != ab) + return null; + assert pParam instanceof ICPPTemplateTemplateParameter; // no other choice left + assert aParam instanceof ICPPTemplateTemplateParameter; // no other choice left } } - return true; - } + return arg; + } if (param instanceof ICPPTemplateNonTypeParameter) { + if (!arg.isNonTypeValue()) + return null; + IType argType= arg.getTypeOfNonTypeValue(); try { IType pType = ((ICPPTemplateNonTypeParameter) param).getType(); if (map != null && pType != null) { pType= instantiateType(pType, map, null); } - if (!isNonTypeArgumentConvertible(pType, argument)) { - return false; + if (isNonTypeArgumentConvertible(pType, argType)) { + return new CPPTemplateArgument(arg.getNonTypeValue(), pType); } + return null; + } catch (DOMException e) { - return false; + return null; } - return true; } - return false; + assert false; + return null; } /** @@ -2043,8 +1956,7 @@ public class CPPTemplates { if (arg.isTypeValue()) return isDependentType(arg.getTypeValue()); - // mstodo dependent values - return false; + return Value.isDependentValue(arg.getNonTypeValue()); } public static boolean isDependentType(IType t) { // mstodo needs to be extended @@ -2087,7 +1999,7 @@ public class CPPTemplates { if (unknown instanceof ICPPUnknownClassInstance) { ICPPUnknownClassInstance ucli= (ICPPUnknownClassInstance) unknown; final ICPPTemplateArgument[] arguments = ucli.getArguments(); - ICPPTemplateArgument[] newArgs = convert(CPPTemplates.instantiateTypes(getArguments(arguments), tpMap, within)); + ICPPTemplateArgument[] newArgs = CPPTemplates.instantiateArguments(arguments, tpMap, within); if (!t.equals(owner) && newArgs != arguments) { result= new CPPUnknownClassInstance((ICPPUnknownBinding) t, ucli.getUnknownName(), newArgs); } @@ -2113,8 +2025,8 @@ public class CPPTemplates { } } if (unknown instanceof ICPPUnknownClassInstance && result instanceof ICPPTemplateDefinition) { - IType[] newArgs = CPPTemplates.instantiateTypes(getArguments(((ICPPUnknownClassInstance) unknown).getArguments()), tpMap, within); - result = instantiate((ICPPTemplateDefinition) result, convert(newArgs)); + ICPPTemplateArgument[] newArgs = CPPTemplates.instantiateArguments(((ICPPUnknownClassInstance) unknown).getArguments(), tpMap, within); + result = instantiate((ICPPTemplateDefinition) result, newArgs); } } } @@ -2158,21 +2070,13 @@ public class CPPTemplates { return false; for (int i = 0; i < m1.length; i++) { - if (!isSameTemplateArgument(m1[i], m2[i])) + if (!m1[i].isSameValue(m2[i])) return false; } return true; } - public static boolean isSameTemplateArgument(final ICPPTemplateArgument a1, final ICPPTemplateArgument a2) { - // backwards compatibility, mstodo remove - if (a1.isTypeValue() && a2.isTypeValue()) - return isSameTemplateArgument(a1.getTypeValue(), a2.getTypeValue()); - - return a1.isSameValue(a2); - } - public static ICPPTemplateParameterMap createParameterMap(ICPPTemplateDefinition tdef, ICPPTemplateArgument[] args) { try { ICPPTemplateParameter[] tpars= tdef.getTemplateParameters(); @@ -2194,26 +2098,18 @@ public class CPPTemplates { public static IType[] getArguments(ICPPTemplateArgument[] arguments) { IType[] types= new IType[arguments.length]; for (int i = 0; i < types.length; i++) { - types[i]= getArgument(arguments[i]); + final ICPPTemplateArgument arg= arguments[i]; + if (arg == null) { + types[i]= null; + } else if (arg.isNonTypeValue()) { + types[i]= arg.getTypeOfNonTypeValue(); + } else { + types[i]= arg.getTypeValue(); + } } return types; } - - /** - * @deprecated for backwards compatibility, only. - */ - @Deprecated - public static IType getArgument(ICPPTemplateArgument arg) { - if (arg == null) - return null; - if (arg.isNonTypeValue()) { - return arg.getTypeOfNonTypeValue(); - } - return arg.getTypeValue(); - } - - /** * @deprecated for backwards compatibility, only. */ @@ -2257,45 +2153,4 @@ public class CPPTemplates { } return ObjectMap.EMPTY_MAP; } - - /** - * mstodo for intermediate use only. - * @deprecated - */ - @Deprecated - public static CPPTemplateParameterMap convert(ObjectMap tpMap) { - CPPTemplateParameterMap tpmap= new CPPTemplateParameterMap(tpMap.size()); - Object[] tps= tpMap.keyArray(); - for (Object tp : tps) { - if (tp instanceof ICPPTemplateParameter) { - IType t= (IType) tpMap.get(tp); - tpmap.put((ICPPTemplateParameter) tp, new CPPTemplateArgument(t)); - } - } - return tpmap; - } - - /** - * mstodo for intermediate use only. - * @deprecated - */ - @Deprecated - public static ICPPTemplateArgument[] convert(IType[] args) { - ICPPTemplateArgument[] targs= new ICPPTemplateArgument[args.length]; - for (int i = 0; i < targs.length; i++) { - targs[i]= convert(args[i]); - } - return targs; - } - - /** - * mstodo for intermediate use only. - * @deprecated - */ - @Deprecated - private static CPPTemplateArgument convert(IType arg) { - if (arg == null) - return null; - return new CPPTemplateArgument(arg); - } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPVisitor.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPVisitor.java index 13b747d36de..e38a8eca76c 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPVisitor.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPVisitor.java @@ -16,9 +16,6 @@ package org.eclipse.cdt.internal.core.dom.parser.cpp.semantics; import static org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.SemanticUtil.getUltimateType; import static org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.SemanticUtil.getUltimateTypeUptoPointers; -import java.math.BigInteger; - -import org.eclipse.cdt.core.CCorePlugin; import org.eclipse.cdt.core.dom.ast.ASTNodeProperty; import org.eclipse.cdt.core.dom.ast.DOMException; import org.eclipse.cdt.core.dom.ast.IASTArrayDeclarator; @@ -139,14 +136,12 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateNonTypeParameter; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateScope; import org.eclipse.cdt.core.dom.ast.cpp.ICPPUsingDeclaration; -import org.eclipse.cdt.core.dom.ast.cpp.ICPPVariable; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier; import org.eclipse.cdt.core.dom.ast.gnu.IGNUASTCompoundStatementExpression; import org.eclipse.cdt.core.dom.ast.gnu.cpp.IGPPASTPointer; import org.eclipse.cdt.core.dom.ast.gnu.cpp.IGPPASTPointerToMember; import org.eclipse.cdt.core.dom.ast.gnu.cpp.IGPPASTSimpleDeclSpecifier; import org.eclipse.cdt.core.index.IIndexBinding; -import org.eclipse.cdt.core.parser.Keywords; import org.eclipse.cdt.core.parser.util.ArrayUtil; import org.eclipse.cdt.core.parser.util.CharArrayUtils; import org.eclipse.cdt.internal.core.dom.parser.ASTInternal; @@ -1590,17 +1585,6 @@ public class CPPVisitor { if (nested != null) { return createType(type, nested); } - - // Currently, CPPBasicType objects are also used to represent non-type template argument - // values. We must ensure the initializer expression is attached to the type if available. - // mstodo- can be removed - if (declarator.getInitializer() instanceof IASTInitializerExpression) { - IType utype= getUltimateTypeUptoPointers(baseType); - if (utype instanceof CPPBasicType) { - ((CPPBasicType)utype).setFromExpression(((IASTInitializerExpression) declarator.getInitializer()).getExpression()); - } - } - return type; } @@ -2335,89 +2319,6 @@ public class CPPVisitor { } return false; } - - /** - * @param integral - * @return the (non-null) integer value of the specified literal - * @throws NumberFormatException - */ - /* - * Currently unsigned (U,u) is stripped and ignored. - */ - public static BigInteger parseIntegral(String integral) { - int radix= 10; - if (integral.length() == 3 - && integral.charAt(0) == '\'' - && integral.charAt(2) == '\'') { - String lo= Long.toString(Character.getNumericValue(integral.charAt(1))); - return new BigInteger(lo); - } else if (Keywords.TRUE.equals(integral)) { - return BigInteger.ONE; - } else if (Keywords.FALSE.equals(integral)) { - return BigInteger.ZERO; - } - - int start=0; - int end= integral.length(); - - boolean negate= integral.charAt(start) == '-'; - if (negate || integral.charAt(start) == '+') { - start++; - } - - if (start < integral.length() && integral.charAt(start) == '0') { - if (start + 1 < integral.length()) { - if (integral.charAt(start + 1) == 'x') { - start += 2; - radix= 16; - } else { - radix= 8; - } - } - } - - for (end--; end > 0; end--) { - final char c= integral.charAt(end); - if (c != 'L' && c!='l' && c!='U' && c!='u') { - break; - } - } - - integral= integral.substring(start, end+1); - - BigInteger result= new BigInteger(integral, radix); - return negate ? result.negate() : result; - } - - /** - * @param e1 - * @return the first non id-expression by following values assigned to basic types. - * @deprecated mstodo- remove - */ - @Deprecated - public static final IASTExpression reverseConstantPropagationLookup(IASTExpression e1) { - try { - for (int i= 0; e1 instanceof IASTIdExpression && i < 8; i++) { - IBinding b1= ((IASTIdExpression)e1).getName().resolveBinding(); - if (b1 instanceof ICPPVariable) { - ICPPVariable var= (ICPPVariable) b1; - IType t1= SemanticUtil.getUltimateTypeViaTypedefs(var.getType()); - if (t1 instanceof IQualifierType) { - IQualifierType qt= (IQualifierType) t1; - if (qt.isConst()) { - t1= SemanticUtil.getUltimateTypeViaTypedefs(qt.getType()); - if (t1 instanceof ICPPBasicType) { - e1= ((ICPPBasicType) t1).getValue(); - } - } - } - } - } - } catch (DOMException de) { - CCorePlugin.log(de); - } - return e1; - } /** * Returns the outermost declarator the given declarator nests within, or diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/Conversions.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/Conversions.java index 14e32dc1cf3..f3d0045faf3 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/Conversions.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/Conversions.java @@ -42,6 +42,7 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateTemplateParameter; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateTypeParameter; import org.eclipse.cdt.internal.core.dom.parser.ITypeContainer; +import org.eclipse.cdt.internal.core.dom.parser.Value; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPBasicType; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPPointerType; import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPDeferredClassInstance; @@ -742,17 +743,11 @@ public class Conversions { if (src instanceof CPPBasicType && trg instanceof IPointerType) { //4.10-1 an integral constant expression of integer type that evaluates to 0 can be converted to a pointer type IASTExpression exp = ((CPPBasicType)src).getCreatedFromExpression(); - // mstodo- improve by checking evaluation - if (exp instanceof IASTLiteralExpression && - ((IASTLiteralExpression)exp).getKind() == IASTLiteralExpression.lk_integer_constant) { - try { - String val = exp.toString().toLowerCase().replace('u', '0'); - val.replace('l', '0'); - if (Integer.decode(val).intValue() == 0) { - cost.rank = Cost.CONVERSION_RANK; - cost.conversion = 1; - } - } catch(NumberFormatException e) { + if (exp != null) { + Long val= Value.create(exp, Value.MAX_RECURSION_DEPTH).numericalValue(); + if (val != null && val == 0) { + cost.rank = Cost.CONVERSION_RANK; + cost.conversion = 1; } } } else if (sPrev instanceof IPointerType) { diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/IndexCPPSignatureUtil.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/IndexCPPSignatureUtil.java index 64693ae2484..c60303bc624 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/IndexCPPSignatureUtil.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/IndexCPPSignatureUtil.java @@ -12,7 +12,6 @@ *******************************************************************************/ package org.eclipse.cdt.internal.core.index; -import java.math.BigInteger; import java.util.ArrayList; import java.util.Collections; import java.util.List; @@ -20,19 +19,15 @@ import java.util.List; import org.eclipse.cdt.core.CCorePlugin; import org.eclipse.cdt.core.dom.ast.ASTTypeUtil; import org.eclipse.cdt.core.dom.ast.DOMException; -import org.eclipse.cdt.core.dom.ast.IASTExpression; -import org.eclipse.cdt.core.dom.ast.IASTLiteralExpression; import org.eclipse.cdt.core.dom.ast.IBasicType; import org.eclipse.cdt.core.dom.ast.IBinding; import org.eclipse.cdt.core.dom.ast.IFunction; import org.eclipse.cdt.core.dom.ast.IFunctionType; import org.eclipse.cdt.core.dom.ast.IType; -import org.eclipse.cdt.core.dom.ast.cpp.ICPPBasicType; import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplatePartialSpecialization; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateArgument; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter; -import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor; import org.eclipse.core.runtime.CoreException; /** @@ -106,14 +101,6 @@ public class IndexCPPSignatureUtil { } } buffer.append(((ICPPTemplateParameter)type).getName()); - } else if (type instanceof ICPPBasicType){ - // mstodo remove - IASTExpression expr= ((ICPPBasicType) type).getValue(); - if (expr != null) { - buffer.append(getValueString(expr)); - } else { - buffer.append(ASTTypeUtil.getType(type)); - } } else { buffer.append(ASTTypeUtil.getType(type)); } @@ -122,25 +109,7 @@ public class IndexCPPSignatureUtil { buffer.append('>'); return buffer.toString(); } - - private static String getValueString(IASTExpression e) { - e= CPPVisitor.reverseConstantPropagationLookup(e); - if (e instanceof IASTLiteralExpression) { - IType t1= e.getExpressionType(); - try { - if(t1 instanceof ICPPBasicType) { - BigInteger i1= CPPVisitor.parseIntegral(e.toString()); - return i1.toString(); - } - } catch(NumberFormatException nfe) { - /* fall through */ - } - return e.toString(); - } - return "?"; //$NON-NLS-1$ - } - private static void appendTemplateArgs(ICPPTemplateArgument[] values, StringBuilder buffer) { boolean needcomma= false; buffer.append('<'); diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/scanner/ExpressionEvaluator.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/scanner/ExpressionEvaluator.java index 65059db1b11..546e0b69461 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/scanner/ExpressionEvaluator.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/scanner/ExpressionEvaluator.java @@ -377,7 +377,7 @@ public class ExpressionEvaluator { return getNumber(image, 0, image.length, 10, IProblem.SCANNER_BAD_DECIMAL_FORMAT); } - private long getChar(char[] tokenImage, int i) throws EvalException { + public static long getChar(char[] tokenImage, int i) throws EvalException { if (i>=tokenImage.length) { throw new EvalException(IProblem.SCANNER_BAD_CHARACTER, tokenImage); } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPBasicType.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPBasicType.java index 4d7e029ef30..fe3db146083 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPBasicType.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPBasicType.java @@ -16,15 +16,10 @@ import org.eclipse.cdt.core.CCorePlugin; import org.eclipse.cdt.core.dom.ast.ASTTypeUtil; import org.eclipse.cdt.core.dom.ast.DOMException; import org.eclipse.cdt.core.dom.ast.IASTExpression; -import org.eclipse.cdt.core.dom.ast.IASTLiteralExpression; import org.eclipse.cdt.core.dom.ast.IBasicType; import org.eclipse.cdt.core.dom.ast.IType; import org.eclipse.cdt.core.dom.ast.ITypedef; -import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTLiteralExpression; import org.eclipse.cdt.core.dom.ast.cpp.ICPPBasicType; -import org.eclipse.cdt.core.parser.Keywords; -import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTLiteralExpression; -import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor; import org.eclipse.cdt.internal.core.index.IIndexCPPBindingConstants; import org.eclipse.cdt.internal.core.index.IIndexType; import org.eclipse.cdt.internal.core.pdom.PDOM; @@ -39,11 +34,9 @@ class PDOMCPPBasicType extends PDOMNode implements ICPPBasicType, IIndexType { private static final int TYPE_ID = PDOMNode.RECORD_SIZE + 0; // short private static final int QUALIFIER_FLAGS = PDOMNode.RECORD_SIZE + 2; // short - private static final int INTEGRAL = PDOMNode.RECORD_SIZE + 4; // int - private static final int INTERNAL_FLAGS = PDOMNode.RECORD_SIZE + 8; // byte @SuppressWarnings("hiding") - private static final int RECORD_SIZE = PDOMNode.RECORD_SIZE + 9; + private static final int RECORD_SIZE = PDOMNode.RECORD_SIZE + 4; protected short fFlags= -1; @@ -61,19 +54,6 @@ class PDOMCPPBasicType extends PDOMNode implements ICPPBasicType, IIndexType { fFlags= flags; Database db = pdom.getDB(); db.putShort(record + TYPE_ID, getTypeCode(type)); - try { - if(type.getValue() != null) { - IASTExpression e= CPPVisitor.reverseConstantPropagationLookup(type.getValue()); - if(e != null) { - db.putInt(record + INTEGRAL, CPPVisitor.parseIntegral(e.toString()).intValue()); - db.putByte(record + INTERNAL_FLAGS, (byte)1); - } - } - } catch(DOMException de) { - CCorePlugin.log(de); - } catch(NumberFormatException nfe) { - /* fall-through */ - } db.putShort(record + QUALIFIER_FLAGS, flags); } @@ -123,31 +103,6 @@ class PDOMCPPBasicType extends PDOMNode implements ICPPBasicType, IIndexType { @Deprecated public IASTExpression getValue() throws DOMException { - // mstodo remove implementation - try { - /* - * If the expression was an integral we can emulate what would - * have been returned in a limited way. - */ - if(pdom.getDB().getByte(record + INTERNAL_FLAGS) != 0) { - int integral= pdom.getDB().getInt(record + INTEGRAL); - String literal= Integer.toString(integral); - int type= getType(); - if(type == t_char) { - return new CPPASTLiteralExpression(IASTLiteralExpression.lk_char_constant, literal); - } else if(type == t_int) { - return new CPPASTLiteralExpression(IASTLiteralExpression.lk_integer_constant, literal); - } else if(type == t_bool) { - if(integral == 0) { - return new CPPASTLiteralExpression(ICPPASTLiteralExpression.lk_false, Keywords.FALSE); - } else { - return new CPPASTLiteralExpression(ICPPASTLiteralExpression.lk_true, Keywords.TRUE); - } - } - } - } catch(CoreException ce) { - CCorePlugin.log(ce); - } return null; } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPFunctionTemplate.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPFunctionTemplate.java index 97e59b1c05a..d816c084a0d 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPFunctionTemplate.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPFunctionTemplate.java @@ -18,24 +18,16 @@ import org.eclipse.cdt.core.CCorePlugin; import org.eclipse.cdt.core.dom.IPDOMNode; import org.eclipse.cdt.core.dom.IPDOMVisitor; import org.eclipse.cdt.core.dom.ast.DOMException; -import org.eclipse.cdt.core.dom.ast.EScopeKind; -import org.eclipse.cdt.core.dom.ast.IASTName; import org.eclipse.cdt.core.dom.ast.IBinding; import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction; import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunctionTemplate; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateArgument; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter; -import org.eclipse.cdt.core.index.IIndexBinding; -import org.eclipse.cdt.core.index.IIndexFileSet; -import org.eclipse.cdt.core.parser.util.ArrayUtil; import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInstanceCache; -import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPSemantics; import org.eclipse.cdt.internal.core.index.IIndexCPPBindingConstants; -import org.eclipse.cdt.internal.core.index.IIndexScope; import org.eclipse.cdt.internal.core.pdom.PDOM; import org.eclipse.cdt.internal.core.pdom.db.PDOMNodeLinkedList; -import org.eclipse.cdt.internal.core.pdom.dom.BindingCollector; import org.eclipse.cdt.internal.core.pdom.dom.IPDOMMemberOwner; import org.eclipse.cdt.internal.core.pdom.dom.PDOMLinkage; import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode; @@ -45,7 +37,7 @@ import org.eclipse.core.runtime.CoreException; * @author Bryan Wilkinson */ class PDOMCPPFunctionTemplate extends PDOMCPPFunction - implements ICPPFunctionTemplate, ICPPInstanceCache, IPDOMMemberOwner, IIndexScope { + implements ICPPFunctionTemplate, ICPPInstanceCache, IPDOMMemberOwner { private static final int TEMPLATE_PARAMS = PDOMCPPFunction.RECORD_SIZE + 0; @@ -64,10 +56,6 @@ class PDOMCPPFunctionTemplate extends PDOMCPPFunction super(pdom, bindingRecord); } - public EScopeKind getKind() { - return EScopeKind.eLocal; - } - @Override public void update(PDOMLinkage linkage, IBinding name) { // no support for updating templates, yet. @@ -125,45 +113,6 @@ class PDOMCPPFunctionTemplate extends PDOMCPPFunction list.accept(visitor); } - public IBinding[] find(String name) throws DOMException { - return CPPSemantics.findBindings( this, name, false ); - } - - @Override - public IBinding getBinding(IASTName name, boolean resolve, IIndexFileSet fileSet) - throws DOMException { - try { - BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray()); - PDOMNodeLinkedList list = new PDOMNodeLinkedList(pdom, record + TEMPLATE_PARAMS, getLinkageImpl()); - list.accept(visitor); - - return CPPSemantics.resolveAmbiguities(name, visitor.getBindings()); - } catch (CoreException e) { - CCorePlugin.log(e); - } - return null; - } - - @Override - public IBinding[] getBindings(IASTName name, boolean resolve, boolean prefixLookup, IIndexFileSet fileSet) - throws DOMException { - IBinding[] result = null; - try { - BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray(), null, - prefixLookup, !prefixLookup); - PDOMNodeLinkedList list = new PDOMNodeLinkedList(pdom, record + TEMPLATE_PARAMS, getLinkageImpl()); - list.accept(visitor); - result = (IBinding[]) ArrayUtil.addAll(IBinding.class, result, visitor.getBindings()); - } catch (CoreException e) { - CCorePlugin.log(e); - } - return (IBinding[]) ArrayUtil.trim(IBinding.class, result); - } - - public IIndexBinding getScopeBinding() { - return this; - } - public ICPPTemplateInstance getInstance(ICPPTemplateArgument[] arguments) { return PDOMInstanceCache.getCache(this).getInstance(arguments); } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPUnknownClassInstance.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPUnknownClassInstance.java index 98f38c5c2d4..c1325567380 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPUnknownClassInstance.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPUnknownClassInstance.java @@ -20,7 +20,6 @@ import org.eclipse.cdt.core.dom.ast.ITypedef; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateArgument; import org.eclipse.cdt.core.parser.util.CharArrayUtils; import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownClassInstance; -import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPTemplates; import org.eclipse.cdt.internal.core.index.IIndexCPPBindingConstants; import org.eclipse.cdt.internal.core.pdom.PDOM; import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode; @@ -104,7 +103,7 @@ class PDOMCPPUnknownClassInstance extends PDOMCPPUnknownClassType implements ICP return false; for (int i= 0; i < lhsArgs.length; i++) { - if (!CPPTemplates.isSameTemplateArgument(lhsArgs[i], rhsArgs[i])) + if (!lhsArgs[i].isSameValue(rhsArgs[i])) return false; } }