mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-04-29 19:45:01 +02:00
Code Issues Wiki Activity

Uses new template arguments for the instantiation algorithms, bug 242668.

Browse source
This commit is contained in:
Markus Schorn 2008-10-28 15:19:35 +00:00
parent 935103d5a5
commit d1dc55e8c7
23 changed files with 339 additions and 716 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPSpecFailingTest.java
View file

@ -95,15 +95,6 @@ public class AST2CPPSpecFailingTest extends AST2SpecBaseTest {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<int I, int J, class T> class X { };
// template<int I, int J> class X<I, J, int> { }; // #1
// template<int I> class X<I, I, int> { }; // #2
// template<int I, int J> void f(X<I, J, int>); // #A
// template<int I> void f(X<I, I, int>); // #B
public void _test14_5_4_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <int I, int J> A<I+J> f(A<I>, A<J>); // #1
// template <int K, int L> A<K+L> f(A<K>, A<L>); // same as #1
// template <int I, int J> A<I-J> f(A<I>, A<J>); // different from #1

20
core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPSpecTest.java
View file

@ -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<int()> x; // typeid
// S<int(1)> 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<int I, int J, class T> class X { };
// template<int I, int J> class X<I, J, int> { }; // #1
// template<int I> class X<I, I, int> { }; // #2
// template<int I, int J> void f(X<I, J, int>); // #A
// template<int I> void f(X<I, I, int>); // #B
public void test14_5_4_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// // primary template
// template<class T, int I> struct A {
// void f();

32
core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2TemplateTests.java
View file

@ -764,30 +764,6 @@ public class AST2TemplateTests extends AST2BaseTest {
assertSame(g1, g2);
}
// template <class T, class U = T > 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 T, class U = T > 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<int> aint; // should be an error
public void _testTypeArgumentToNonTypeParameter() throws Exception {
public void testTypeArgumentToNonTypeParameter() throws Exception {
BindingAssertionHelper ba= new BindingAssertionHelper(getAboveComment(), true);
ba.assertProblem("A<int>", 6);
}

42
core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2UtilTests.java
View file

@ -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, ExpressionEvaluator.getNumber("1".toCharArray()));
assertEquals(1, ExpressionEvaluator.getNumber("01".toCharArray()));
assertEquals(1, ExpressionEvaluator.getNumber("0x1".toCharArray()));
assertEquals(1, CPPVisitor.parseIntegral("+1").intValue());
assertEquals(1, CPPVisitor.parseIntegral("+01").intValue());
assertEquals(1, CPPVisitor.parseIntegral("+0x1").intValue());
assertEquals(10, ExpressionEvaluator.getNumber("10".toCharArray()));
assertEquals(8, ExpressionEvaluator.getNumber("010".toCharArray()));
assertEquals(16, ExpressionEvaluator.getNumber("0x10".toCharArray()));
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(-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()));
}
}

58
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/Value.java
View file

@ -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) {
@ -76,16 +77,31 @@ 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 <code>null</code> 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;
}

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

@ -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<IASTNode>();
fNodes= new ArrayList<IASTNode>(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);
}
}

6
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassTemplatePartialSpecialization.java
View file

@ -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)

3
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassTemplateSpecialization.java
View file

@ -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;
}
}

10
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPDeferredFunctionInstance.java
View file

@ -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 ];

3
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPFunctionTemplateSpecialization.java
View file

@ -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;
}
}

2
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateArgument.java
View file

@ -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());
}

2
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateDefinition.java
View file

@ -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;
}
}

2
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateTemplateParameter.java
View file

@ -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;
}
}

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

@ -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;
}
}

21
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPSemantics.java
View file

@ -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) {

573
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPTemplates.java
View file

@ -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;
}
}
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 (!argIsParameter(arg, param)) {
map.put(param, arg);
}
actualArgs[i] = arg;
if (CPPTemplates.isDependentArgument(arg)) {
argsContainDependentType = true;
}
}
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;
}
@ -1285,37 +1284,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
* @return an array of template arguments, currently modeled as IType objects. The
@ -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<IFunction> templates,
static protected IFunction[] selectTemplateFunctions(ObjectSet<IFunction> 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;
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);
}
}

99
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPVisitor.java
View file

@ -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;
}
@ -2336,89 +2320,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 <code>declarator</code> nests within, or
* <code>declarator</code> itself.

17
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/Conversions.java
View file

@ -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) {

31
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/IndexCPPSignatureUtil.java
View file

@ -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));
}
@ -123,24 +110,6 @@ public class IndexCPPSignatureUtil {
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('<');

2
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/scanner/ExpressionEvaluator.java
View file

@ -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);
}

47
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPBasicType.java
View file

@ -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;
}

53
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPFunctionTemplate.java
View file

@ -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);
}

3
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPUnknownClassInstance.java
View file

@ -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;
}
}