From 65003d3ab2d6860f679ef7855e4d4b543e1256c6 Mon Sep 17 00:00:00 2001 From: Doug Schaefer Date: Thu, 7 Aug 2003 14:46:58 +0000 Subject: [PATCH] Patch for Andrew Niefer: Core: - refactor symbol table function names to start with lower case letters - added better constructor support : - IDerivableContainerSymbol.addConstructor - IDerivableContainerSymbol.lookupConstructor - IDerivableContainerSymbol.getConstructors - implicit user-defined conversion sequences now only use constructors not marked explicit - user-defined conversion sequences are now only applied at most once (12.3-4 in spec) - changed ParserSymbolTableException.r_Unspecified to r_InternalError which is thrown on internal symbol table inconsistancies (likely from bugs rather than semantic problems with the parsed code) Core.tests: - updated tests to reflect function name refactoring - added ParserSymbolTableTest.testConstructors --- core/org.eclipse.cdt.core.tests/ChangeLog | 4 + .../parser/tests/ParserSymbolTableTest.java | 308 ++++++++++-------- core/org.eclipse.cdt.core/parser/ChangeLog | 10 + .../ast/complete/CompleteParseASTFactory.java | 16 +- .../core/parser/pst/IContainerSymbol.java | 18 +- .../parser/pst/IDerivableContainerSymbol.java | 5 + .../core/parser/pst/ParserSymbolTable.java | 275 ++++++++++------ .../pst/ParserSymbolTableException.java | 3 +- .../internal/core/parser/pst/TypeInfo.java | 27 +- 9 files changed, 403 insertions(+), 263 deletions(-) diff --git a/core/org.eclipse.cdt.core.tests/ChangeLog b/core/org.eclipse.cdt.core.tests/ChangeLog index c65d4a3086b..09484b458fe 100644 --- a/core/org.eclipse.cdt.core.tests/ChangeLog +++ b/core/org.eclipse.cdt.core.tests/ChangeLog @@ -1,3 +1,7 @@ +2003-08-05 Andrew Niefer + - refactoring Parser Symbol Table function names + - added ParserSymbolTableTest.testConstructors() + 2003-08-01 Andrew Niefer Added resources/search/header.h Added ClassDeclarationPatternTests.testHeadersVisitedTwice() diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ParserSymbolTableTest.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ParserSymbolTableTest.java index a171c215045..a82ffcec3e7 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ParserSymbolTableTest.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ParserSymbolTableTest.java @@ -90,7 +90,7 @@ public class ParserSymbolTableTest extends TestCase { ISymbol x = table.new Declaration( "x" ); table.getCompilationUnit().addSymbol( x ); - ISymbol look = table.getCompilationUnit().Lookup( "x" ); + ISymbol look = table.getCompilationUnit().lookup( "x" ); assertEquals( x, look ); } @@ -98,7 +98,7 @@ public class ParserSymbolTableTest extends TestCase { public void testLookupNonExistant() throws Exception{ newTable(); - ISymbol look = table.getCompilationUnit().Lookup("boo"); + ISymbol look = table.getCompilationUnit().lookup("boo"); assertEquals( look, null ); } @@ -113,7 +113,7 @@ public class ParserSymbolTableTest extends TestCase { table.getCompilationUnit().addSymbol( x ); - ISymbol look = table.getCompilationUnit().Lookup( "x" ); + ISymbol look = table.getCompilationUnit().lookup( "x" ); assertEquals( look.getASTExtension(), extension ); } @@ -134,16 +134,16 @@ public class ParserSymbolTableTest extends TestCase { firstClass.setType( TypeInfo.t_class ); table.getCompilationUnit().addSymbol( firstClass ); - ISymbol look = firstClass.Lookup( "x" ); + ISymbol look = firstClass.lookup( "x" ); assertEquals( look, firstX ); ISymbol secondX = table.newSymbol("x"); firstClass.addSymbol( secondX ); - look = firstClass.Lookup( "x" ); + look = firstClass.lookup( "x" ); assertEquals( look, secondX ); - look = table.getCompilationUnit().Lookup( "x" ); + look = table.getCompilationUnit().lookup( "x" ); assertEquals( look, firstX ); } @@ -162,7 +162,7 @@ public class ParserSymbolTableTest extends TestCase { decl.setType( TypeInfo.t_class ); table.getCompilationUnit().addSymbol( decl ); - ISymbol look = decl.Lookup( "x" ); + ISymbol look = decl.lookup( "x" ); assertEquals( x, look ); } @@ -189,7 +189,7 @@ public class ParserSymbolTableTest extends TestCase { table.getCompilationUnit().addSymbol( parent ); table.getCompilationUnit().addSymbol( class1 ); - ISymbol look = class1.Lookup( "x" ); + ISymbol look = class1.lookup( "x" ); assertEquals( look, decl ); } @@ -208,14 +208,14 @@ public class ParserSymbolTableTest extends TestCase { IDerivableContainerSymbol parent2 = table.newDerivableContainerSymbol("parent2"); table.getCompilationUnit().addSymbol( parent2 ); - IDerivableContainerSymbol class1 = (IDerivableContainerSymbol) table.getCompilationUnit().Lookup( "class" ); + IDerivableContainerSymbol class1 = (IDerivableContainerSymbol) table.getCompilationUnit().lookup( "class" ); class1.addParent( parent2 ); ISymbol decl = table.new Declaration("x"); parent2.addSymbol( decl ); try{ - class1.Lookup( "x" ); + class1.lookup( "x" ); assertTrue( false ); } catch ( ParserSymbolTableException e ){ @@ -241,7 +241,7 @@ public class ParserSymbolTableTest extends TestCase { a.addParent( b ); try{ - ISymbol look = a.Lookup("foo"); + ISymbol look = a.lookup("foo"); assertTrue( false ); } catch ( ParserSymbolTableException e) { assertEquals( e.reason, ParserSymbolTableException.r_CircularInheritance ); @@ -285,7 +285,7 @@ public class ParserSymbolTableTest extends TestCase { compUnit.addSymbol( a ); compUnit.addSymbol( b ); - ISymbol look = decl.Lookup( "x" ); + ISymbol look = decl.lookup( "x" ); assertEquals( look, x ); } @@ -306,8 +306,8 @@ public class ParserSymbolTableTest extends TestCase { IContainerSymbol compUnit = table.getCompilationUnit(); - IDerivableContainerSymbol cls = (IDerivableContainerSymbol) compUnit.Lookup("class"); - IDerivableContainerSymbol c = (IDerivableContainerSymbol) compUnit.Lookup("C"); + IDerivableContainerSymbol cls = (IDerivableContainerSymbol) compUnit.lookup("class"); + IDerivableContainerSymbol c = (IDerivableContainerSymbol) compUnit.lookup("C"); IDerivableContainerSymbol d = table.newDerivableContainerSymbol("D"); d.addParent( c ); @@ -316,7 +316,7 @@ public class ParserSymbolTableTest extends TestCase { compUnit.addSymbol( d ); try{ - cls.Lookup( "x" ); + cls.lookup( "x" ); assertTrue( false ); } catch( ParserSymbolTableException e){ @@ -375,7 +375,7 @@ public class ParserSymbolTableTest extends TestCase { c.addParent( d ); try{ - a.Lookup( "enumerator" ); + a.lookup( "enumerator" ); assertTrue( true ); } catch ( ParserSymbolTableException e){ @@ -383,7 +383,7 @@ public class ParserSymbolTableTest extends TestCase { } try{ - a.Lookup( "static" ); + a.lookup( "static" ); assertTrue( true ); } catch ( ParserSymbolTableException e){ @@ -391,7 +391,7 @@ public class ParserSymbolTableTest extends TestCase { } try{ - a.Lookup( "x" ); + a.lookup( "x" ); assertTrue( false ); } catch ( ParserSymbolTableException e){ @@ -436,11 +436,11 @@ public class ParserSymbolTableTest extends TestCase { table.getCompilationUnit().addSymbol( a ); table.getCompilationUnit().addSymbol( b ); - ISymbol look = a.ElaboratedLookup( TypeInfo.t_class, "class" ); + ISymbol look = a.elaboratedLookup( TypeInfo.t_class, "class" ); assertEquals( look, cls ); - look = a.ElaboratedLookup( TypeInfo.t_struct, "struct" ); + look = a.elaboratedLookup( TypeInfo.t_struct, "struct" ); assertEquals( look, struct ); - look = a.ElaboratedLookup( TypeInfo.t_union, "union" ); + look = a.elaboratedLookup( TypeInfo.t_union, "union" ); assertEquals( look, union ); } @@ -465,19 +465,19 @@ public class ParserSymbolTableTest extends TestCase { A.addSymbol(member); //at time of "A a;" - ISymbol look = compUnit.Lookup("A"); + ISymbol look = compUnit.lookup("A"); assertEquals( look, A ); ISymbol a = table.newSymbol("a"); a.setTypeSymbol( look ); compUnit.addSymbol( a ); //later "a.member" - look = compUnit.Lookup("a"); + look = compUnit.lookup("a"); assertEquals( look, a ); IContainerSymbol type = (IContainerSymbol) look.getTypeSymbol(); assertEquals( type, A ); - look = type.Lookup("member"); + look = type.lookup("member"); assertEquals( look, member ); } @@ -512,10 +512,10 @@ public class ParserSymbolTableTest extends TestCase { f.setType( TypeInfo.t_function ); compUnit.addSymbol( f ); - ISymbol look = f.ElaboratedLookup( TypeInfo.t_struct, "stat" ); + ISymbol look = f.elaboratedLookup( TypeInfo.t_struct, "stat" ); assertEquals( look, struct ); - look = f.Lookup( "stat" ); + look = f.lookup( "stat" ); assertEquals( look, function ); } @@ -571,7 +571,7 @@ public class ParserSymbolTableTest extends TestCase { ISymbol nsC_i = table.newSymbol("i"); nsC.addSymbol( nsC_i ); - ISymbol look = nsB.Lookup("C"); + ISymbol look = nsB.lookup("C"); assertEquals( look, nsC ); nsB.addUsingDirective( nsC ); @@ -580,18 +580,18 @@ public class ParserSymbolTableTest extends TestCase { nsB.addSymbol( f1 ); - look = f1.Lookup( "i" ); + look = f1.lookup( "i" ); assertEquals( look, nsC_i ); //C::i visible and hides A::i IContainerSymbol nsD = table.newContainerSymbol("D"); nsD.setType( TypeInfo.t_namespace ); nsA.addSymbol( nsD ); - look = nsD.Lookup("B"); + look = nsD.lookup("B"); assertEquals( look, nsB ); nsD.addUsingDirective( nsB ); - look = nsD.Lookup("C"); + look = nsD.lookup("C"); assertEquals( look, nsC ); nsD.addUsingDirective( nsC ); @@ -601,7 +601,7 @@ public class ParserSymbolTableTest extends TestCase { try { - look = f2.Lookup( "i" ); + look = f2.lookup( "i" ); assertTrue( false ); } catch ( ParserSymbolTableException e ) @@ -614,14 +614,14 @@ public class ParserSymbolTableTest extends TestCase { f3.setType( TypeInfo.t_function ); nsA.addSymbol( f3 ); - look = f3.Lookup("i"); + look = f3.lookup("i"); assertEquals( look, nsA_i ); //uses A::i IParameterizedSymbol f4 = table.newParameterizedSymbol("f4"); f4.setType( TypeInfo.t_function ); table.getCompilationUnit().addSymbol( f4 ); - look = f4.Lookup("i"); + look = f4.lookup("i"); assertEquals( look, null );//neither i is visible here. } /** @@ -675,7 +675,7 @@ public class ParserSymbolTableTest extends TestCase { ISymbol look = null; try { - look = f.Lookup( "i" ); + look = f.lookup( "i" ); assertTrue( false ); } catch ( ParserSymbolTableException e ) @@ -684,8 +684,8 @@ public class ParserSymbolTableTest extends TestCase { assertEquals( e.reason, ParserSymbolTableException.r_Ambiguous ); } - look = f.LookupNestedNameSpecifier("N"); - look = ((IContainerSymbol) look).QualifiedLookup("i"); //ok + look = f.lookupNestedNameSpecifier("N"); + look = ((IContainerSymbol) look).qualifiedLookup("i"); //ok assertEquals( look, nsN_i ); } @@ -745,9 +745,9 @@ public class ParserSymbolTableTest extends TestCase { f.setType(TypeInfo.t_function); compUnit.addSymbol( f ); - ISymbol look = f.LookupNestedNameSpecifier("BC"); + ISymbol look = f.lookupNestedNameSpecifier("BC"); assertEquals( look, nsBC ); - look = ((IContainerSymbol)look).QualifiedLookup("a"); + look = ((IContainerSymbol)look).qualifiedLookup("a"); assertEquals( look, a ); } @@ -800,18 +800,18 @@ public class ParserSymbolTableTest extends TestCase { IParameterizedSymbol f = table.newParameterizedSymbol("f"); compUnit.addSymbol(f); - IContainerSymbol lookA = f.LookupNestedNameSpecifier("A"); - ISymbol look = lookA.QualifiedLookup("a"); + IContainerSymbol lookA = f.lookupNestedNameSpecifier("A"); + ISymbol look = lookA.qualifiedLookup("a"); assertEquals( look, a ); - look = lookA.QualifiedLookup("b"); + look = lookA.qualifiedLookup("b"); assertEquals( look, b ); - IContainerSymbol lookB = f.LookupNestedNameSpecifier("B"); - look = lookB.QualifiedLookup("a"); + IContainerSymbol lookB = f.lookupNestedNameSpecifier("B"); + look = lookB.qualifiedLookup("a"); assertEquals( look, a ); - look = lookB.QualifiedLookup("b"); + look = lookB.qualifiedLookup("b"); assertEquals( look, b ); } @@ -858,7 +858,7 @@ public class ParserSymbolTableTest extends TestCase { f.addUsingDirective(nsA); f.addUsingDirective(nsB); - ISymbol look = f.Lookup("i"); + ISymbol look = f.lookup("i"); assertEquals( look, null ); } @@ -920,26 +920,26 @@ public class ParserSymbolTableTest extends TestCase { nsC.setType( TypeInfo.t_namespace); compUnit.addSymbol( nsC ); - ISymbol look = nsC.Lookup("A"); + ISymbol look = nsC.lookup("A"); assertEquals( look, nsA ); nsC.addUsingDirective( nsA ); - look = nsC.Lookup("B"); + look = nsC.lookup("B"); assertEquals( look, nsB ); nsC.addUsingDirective( nsB ); //lookup C::x - look = nsC.LookupNestedNameSpecifier("C"); + look = nsC.lookupNestedNameSpecifier("C"); assertEquals( look, nsC ); - look = ((IContainerSymbol)look).QualifiedLookup( "x" ); + look = ((IContainerSymbol)look).qualifiedLookup( "x" ); assertEquals( look, intX ); //lookup C::y - look = nsC.LookupNestedNameSpecifier("C"); + look = nsC.lookupNestedNameSpecifier("C"); assertEquals( look, nsC ); try{ - look = ((IContainerSymbol)look).QualifiedLookup( "y" ); + look = ((IContainerSymbol)look).qualifiedLookup( "y" ); assertTrue(false); } catch ( ParserSymbolTableException e ) { assertEquals( e.reason, ParserSymbolTableException.r_Ambiguous ); @@ -979,14 +979,14 @@ public class ParserSymbolTableTest extends TestCase { nsA.addUsingDirective( nsB ); - IContainerSymbol lookA = compUnit.LookupNestedNameSpecifier( "A" ); + IContainerSymbol lookA = compUnit.lookupNestedNameSpecifier( "A" ); assertEquals( nsA, lookA ); - ISymbol look = lookA.LookupMemberForDefinition( "f1" ); + ISymbol look = lookA.lookupMemberForDefinition( "f1" ); assertEquals( look, null ); //but notice if you wanted to do A::f1 as a function call, it is ok - look = lookA.QualifiedLookup( "f1" ); + look = lookA.qualifiedLookup( "f1" ); assertEquals( look, f1 ); } @@ -1049,13 +1049,13 @@ public class ParserSymbolTableTest extends TestCase { IDerivableContainerSymbol D = table.newDerivableContainerSymbol( "D" ); D.setType( TypeInfo.t_struct ); - ISymbol look = compUnit.Lookup( "B" ); + ISymbol look = compUnit.lookup( "B" ); assertEquals( look, B ); D.addParent( B ); compUnit.addSymbol( D ); - IContainerSymbol lookB = D.LookupNestedNameSpecifier("B"); + IContainerSymbol lookB = D.lookupNestedNameSpecifier("B"); assertEquals( lookB, B ); D.addUsingDeclaration( "f", lookB ); @@ -1064,7 +1064,7 @@ public class ParserSymbolTableTest extends TestCase { //TBD anonymous union //D.addUsingDeclaration( "x", lookB ); - look = D.LookupNestedNameSpecifier("C"); + look = D.lookupNestedNameSpecifier("C"); assertEquals( look, C ); try{ @@ -1115,12 +1115,12 @@ public class ParserSymbolTableTest extends TestCase { f1.addParameter( TypeInfo.t_int, 0, null, false ); A.addSymbol( f1 ); - ISymbol look = compUnit.LookupNestedNameSpecifier("A"); + ISymbol look = compUnit.lookupNestedNameSpecifier("A"); assertEquals( look, A ); IParameterizedSymbol usingF = (IParameterizedSymbol) compUnit.addUsingDeclaration( "f", A ); - look = compUnit.Lookup("A"); + look = compUnit.lookup("A"); assertEquals( look, A ); IParameterizedSymbol f2 = table.newParameterizedSymbol("f"); @@ -1138,7 +1138,7 @@ public class ParserSymbolTableTest extends TestCase { TypeInfo param = new TypeInfo( TypeInfo.t_char, 0, null ); paramList.add( param ); - look = foo.UnqualifiedFunctionLookup( "f", paramList ); + look = foo.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, usingF ); assertTrue( usingF.hasSameParameters( f1 ) ); @@ -1147,11 +1147,11 @@ public class ParserSymbolTableTest extends TestCase { bar.addParameter( TypeInfo.t_char, 0, null, false ); compUnit.addSymbol( bar ); - look = bar.LookupNestedNameSpecifier( "A" ); + look = bar.lookupNestedNameSpecifier( "A" ); assertEquals( look, A ); bar.addUsingDeclaration( "f", A ); - look = bar.UnqualifiedFunctionLookup( "f", paramList ); + look = bar.unqualifiedFunctionLookup( "f", paramList ); assertTrue( look != null ); assertTrue( ((IParameterizedSymbol) look).hasSameParameters( f2 ) ); } @@ -1178,7 +1178,7 @@ public class ParserSymbolTableTest extends TestCase { table.getCompilationUnit().addSymbol( cls ); cls.addSymbol( fn ); - ISymbol look = fn.Lookup("this"); + ISymbol look = fn.lookup("this"); assertTrue( look != null ); assertEquals( look.getType(), TypeInfo.t_type ); @@ -1212,7 +1212,7 @@ public class ParserSymbolTableTest extends TestCase { enumerator.setType( TypeInfo.t_enumerator ); enumeration.addSymbol( enumerator ); - ISymbol look = cls.Lookup( "enumerator" ); + ISymbol look = cls.lookup( "enumerator" ); assertEquals( look, enumerator ); assertEquals( look.getContainingSymbol(), cls ); assertEquals( look.getTypeSymbol(), enumeration ); @@ -1250,15 +1250,15 @@ public class ParserSymbolTableTest extends TestCase { f.setType( TypeInfo.t_function ); f.setReturnType( table.newSymbol( "", TypeInfo.t_void ) ); - ISymbol look = NS.Lookup( "T" ); + ISymbol look = NS.lookup( "T" ); assertEquals( look, T ); f.addParameter( look, null, false ); NS.addSymbol( f ); - look = compUnit.LookupNestedNameSpecifier( "NS" ); + look = compUnit.lookupNestedNameSpecifier( "NS" ); assertEquals( look, NS ); - look = NS.QualifiedLookup( "T" ); + look = NS.qualifiedLookup( "T" ); assertEquals( look, T ); ISymbol param = table.newSymbol("parm"); @@ -1272,12 +1272,12 @@ public class ParserSymbolTableTest extends TestCase { compUnit.addSymbol( main ); LinkedList paramList = new LinkedList(); - look = main.Lookup( "parm" ); + look = main.lookup( "parm" ); assertEquals( look, param ); TypeInfo p = new TypeInfo( TypeInfo.t_type, 0, look ); paramList.add( p ); - look = main.UnqualifiedFunctionLookup( "f", paramList ); + look = main.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f ); } @@ -1325,7 +1325,7 @@ public class ParserSymbolTableTest extends TestCase { compUnit.addSymbol( NS2 ); - ISymbol look = NS2.Lookup( "NS1" ); + ISymbol look = NS2.lookup( "NS1" ); assertEquals( look, NS1 ); NS2.addUsingDirective( NS1 ); @@ -1341,16 +1341,16 @@ public class ParserSymbolTableTest extends TestCase { IDerivableContainerSymbol A = table.newDerivableContainerSymbol( "A" ); A.setType( TypeInfo.t_class ); - look = compUnit.LookupNestedNameSpecifier( "NS2" ); + look = compUnit.lookupNestedNameSpecifier( "NS2" ); assertEquals( look, NS2 ); - look = NS2.QualifiedLookup( "B" ); + look = NS2.qualifiedLookup( "B" ); assertEquals( look, B ); A.addParent( B ); compUnit.addSymbol( A ); - look = compUnit.Lookup( "A" ); + look = compUnit.lookup( "A" ); assertEquals( look, A ); ISymbol a = table.newSymbol( "a" ); a.setType( TypeInfo.t_type ); @@ -1358,12 +1358,12 @@ public class ParserSymbolTableTest extends TestCase { compUnit.addSymbol( a ); LinkedList paramList = new LinkedList(); - look = compUnit.Lookup( "a" ); + look = compUnit.lookup( "a" ); assertEquals( look, a ); TypeInfo param = new TypeInfo( look.getType(), 0, look, new PtrOp( PtrOp.t_reference ), false ); paramList.add( param ); - look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f2 ); } @@ -1417,7 +1417,7 @@ public class ParserSymbolTableTest extends TestCase { f3.addParameter( C, new PtrOp( PtrOp.t_pointer ), false ); C.addSymbol( f3 ); - ISymbol look = compUnit.Lookup("C"); + ISymbol look = compUnit.lookup("C"); assertEquals( look, C ); ISymbol c = table.newSymbol("c"); @@ -1426,7 +1426,7 @@ public class ParserSymbolTableTest extends TestCase { c.addPtrOperator( new PtrOp( PtrOp.t_pointer, false, false ) ); compUnit.addSymbol( c ); - look = compUnit.Lookup( "c" ); + look = compUnit.lookup( "c" ); assertEquals( look, c ); assertEquals( look.getTypeSymbol(), C ); @@ -1437,15 +1437,15 @@ public class ParserSymbolTableTest extends TestCase { TypeInfo p3 = new TypeInfo( TypeInfo.t_type, 0, c ); paramList.add( p1 ); - look = C.MemberFunctionLookup( "foo", paramList ); + look = C.memberFunctionLookup( "foo", paramList ); assertEquals( look, f1 ); paramList.add( p2 ); - look = C.MemberFunctionLookup( "foo", paramList ); + look = C.memberFunctionLookup( "foo", paramList ); assertEquals( look, f2 ); paramList.add( p3 ); - look = C.MemberFunctionLookup( "foo", paramList ); + look = C.memberFunctionLookup( "foo", paramList ); assertEquals( look, f3 ); } @@ -1480,22 +1480,22 @@ public class ParserSymbolTableTest extends TestCase { TypeInfo p1 = new TypeInfo( TypeInfo.t_int, 0, null ); paramList.add( p1 ); - ISymbol look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + ISymbol look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f1 ); paramList.clear(); TypeInfo p2 = new TypeInfo( TypeInfo.t_char, 0, null ); paramList.add( p2 ); - look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f2 ); paramList.clear(); TypeInfo p3 = new TypeInfo( TypeInfo.t_bool, 0, null ); paramList.add( p3 ); - look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f1 ); - look = compUnit.UnqualifiedFunctionLookup( "f", null ); + look = compUnit.unqualifiedFunctionLookup( "f", null ); assertEquals( look, f2 ); } @@ -1558,13 +1558,13 @@ public class ParserSymbolTableTest extends TestCase { LinkedList paramList = new LinkedList(); TypeInfo p1 = new TypeInfo( TypeInfo.t_type, 0, a ); paramList.add( p1 ); - ISymbol look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + ISymbol look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f1 ); paramList.clear(); TypeInfo p2 = new TypeInfo( TypeInfo.t_type, 0, c ); paramList.add( p2 ); - look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f2 ); } @@ -1633,25 +1633,25 @@ public class ParserSymbolTableTest extends TestCase { TypeInfo p = new TypeInfo( TypeInfo.t_type, 0, a ); paramList.add( p ); - ISymbol look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + ISymbol look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f2 ); p.addPtrOperator( new PtrOp( PtrOp.t_reference, false, false ) ); - look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f1 ); p.setTypeSymbol( b ); p.getPtrOperators().clear(); - look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f1 ); p.addPtrOperator( new PtrOp( PtrOp.t_pointer, false, false ) ); - look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f2 ); p.setTypeSymbol( array ); p.getPtrOperators().clear(); - look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f1 ); } @@ -1685,11 +1685,10 @@ public class ParserSymbolTableTest extends TestCase { B.setType( TypeInfo.t_class ); compUnit.addSymbol( B ); - //12.1-1 "Constructors do not have names" - IParameterizedSymbol constructor = table.newParameterizedSymbol(""); - constructor.setType( TypeInfo.t_function ); + IParameterizedSymbol constructor = table.newParameterizedSymbol("B"); + constructor.setType( TypeInfo.t_constructor ); constructor.addParameter( A, null, false ); - B.addSymbol( constructor ); + B.addConstructor( constructor ); IParameterizedSymbol f = table.newParameterizedSymbol( "f" ); f.setType( TypeInfo.t_function ); @@ -1705,7 +1704,7 @@ public class ParserSymbolTableTest extends TestCase { TypeInfo p = new TypeInfo( TypeInfo.t_type, 0, a ); paramList.add( p ); - ISymbol look = compUnit.UnqualifiedFunctionLookup( "f", paramList ); + ISymbol look = compUnit.unqualifiedFunctionLookup( "f", paramList ); assertEquals( look, f ); } @@ -1770,7 +1769,7 @@ public class ParserSymbolTableTest extends TestCase { ISymbol look = null; try{ - look = main.UnqualifiedFunctionLookup( "f", params ); + look = main.unqualifiedFunctionLookup( "f", params ); assertTrue( false ); } catch ( ParserSymbolTableException e ){ assertEquals( e.reason, ParserSymbolTableException.r_Ambiguous ); @@ -1780,21 +1779,21 @@ public class ParserSymbolTableTest extends TestCase { TypeInfo p3 = new TypeInfo( TypeInfo.t_int, TypeInfo.isLong, null ); params.add( p1 ); params.add( p3 ); - look = main.UnqualifiedFunctionLookup( "f", params ); + look = main.unqualifiedFunctionLookup( "f", params ); assertEquals( look, f2 ); params.clear(); TypeInfo p4 = new TypeInfo( TypeInfo.t_char, 0, null ); params.add( p1 ); params.add( p4 ); - look = main.UnqualifiedFunctionLookup( "f", params ); + look = main.unqualifiedFunctionLookup( "f", params ); assertEquals( look, f2 ); params.clear(); ((PtrOp)p1.getPtrOperators().getFirst()).setConst( true ); params.add( p1 ); params.add( p3 ); - look = main.UnqualifiedFunctionLookup( "f", params ); + look = main.unqualifiedFunctionLookup( "f", params ); assertEquals( look, f1 ); } @@ -1837,10 +1836,10 @@ public class ParserSymbolTableTest extends TestCase { A.setType( TypeInfo.t_class ); compUnit.addSymbol( A ); - IParameterizedSymbol constructA = table.newParameterizedSymbol( "" ); - constructA.setType( TypeInfo.t_function ); + IParameterizedSymbol constructA = table.newParameterizedSymbol( "A" ); + constructA.setType( TypeInfo.t_constructor ); constructA.addParameter( B, new PtrOp( PtrOp.t_reference ), false ); - A.addSymbol( constructA ); + A.addConstructor( constructA ); IParameterizedSymbol operator = table.newParameterizedSymbol( "operator A" ); operator.setType( TypeInfo.t_function ); @@ -1862,7 +1861,7 @@ public class ParserSymbolTableTest extends TestCase { ISymbol look = null; try{ - look = compUnit.UnqualifiedFunctionLookup( "f", params ); + look = compUnit.unqualifiedFunctionLookup( "f", params ); assertTrue( false ); } catch( ParserSymbolTableException e ){ assertEquals( e.reason, ParserSymbolTableException.r_Ambiguous ); @@ -1872,10 +1871,10 @@ public class ParserSymbolTableTest extends TestCase { C.setType( TypeInfo.t_class ); compUnit.addSymbol( C ); - IParameterizedSymbol constructC = table.newParameterizedSymbol(""); - constructC.setType( TypeInfo.t_function ); + IParameterizedSymbol constructC = table.newParameterizedSymbol("C"); + constructC.setType( TypeInfo.t_constructor ); constructC.addParameter( B, new PtrOp( PtrOp.t_reference ), false ); - C.addSymbol( constructC ); + C.addConstructor( constructC ); IParameterizedSymbol f2 = table.newParameterizedSymbol( "f" ); f2.setType( TypeInfo.t_function ); @@ -1883,7 +1882,7 @@ public class ParserSymbolTableTest extends TestCase { compUnit.addSymbol( f2 ); try{ - look = compUnit.UnqualifiedFunctionLookup( "f", params ); + look = compUnit.unqualifiedFunctionLookup( "f", params ); assertTrue( false ); } catch( ParserSymbolTableException e ){ assertEquals( e.reason, ParserSymbolTableException.r_Ambiguous ); @@ -1894,7 +1893,7 @@ public class ParserSymbolTableTest extends TestCase { f3.addParameter( B, null, false ); compUnit.addSymbol( f3 ); - look = compUnit.UnqualifiedFunctionLookup( "f", params ); + look = compUnit.unqualifiedFunctionLookup( "f", params ); assertEquals( look, f3 ); } @@ -1910,12 +1909,12 @@ public class ParserSymbolTableTest extends TestCase { ISymbol f = table.newSymbol("f"); A.addSymbol( f ); - ISymbol look = A.Lookup("f"); + ISymbol look = A.lookup("f"); assertEquals( look, f ); assertTrue( table.rollBack( mark ) ); - look = A.Lookup("f"); + look = A.lookup("f"); assertEquals( look, null ); IDerivableContainerSymbol B = table.newDerivableContainerSymbol("B"); @@ -1984,7 +1983,7 @@ public class ParserSymbolTableTest extends TestCase { LinkedList args = new LinkedList(); args.add( type ); - ParserSymbolTable.TemplateInstance instance = table.getCompilationUnit().TemplateLookup( "A", args ); + ParserSymbolTable.TemplateInstance instance = table.getCompilationUnit().templateLookup( "A", args ); assertEquals( instance.getInstantiatedSymbol(), A ); ISymbol a = table.newSymbol( "a", TypeInfo.t_type ); @@ -1992,14 +1991,14 @@ public class ParserSymbolTableTest extends TestCase { table.getCompilationUnit().addSymbol( a ); - ISymbol look = table.getCompilationUnit().Lookup( "a" ); + ISymbol look = table.getCompilationUnit().lookup( "a" ); assertEquals( look, a ); ISymbol symbol = a.getTypeSymbol(); assertEquals( symbol, instance ); - look = ((IContainerSymbol)instance.getInstantiatedSymbol()).Lookup( "i" ); + look = ((IContainerSymbol)instance.getInstantiatedSymbol()).lookup( "i" ); assertEquals( look, i ); } @@ -2023,7 +2022,7 @@ public class ParserSymbolTableTest extends TestCase { IDerivableContainerSymbol A = table.newDerivableContainerSymbol( "A", TypeInfo.t_class ); ISymbol t = table.newSymbol( "t", TypeInfo.t_type ); - ISymbol look = template.Lookup( "T" ); + ISymbol look = template.lookup( "T" ); assertEquals( look, param ); t.setTypeSymbol( param ); @@ -2038,7 +2037,7 @@ public class ParserSymbolTableTest extends TestCase { LinkedList args = new LinkedList(); args.add( type ); - look = table.getCompilationUnit().TemplateLookup( "A", args ); + look = table.getCompilationUnit().templateLookup( "A", args ); assertTrue( look instanceof ParserSymbolTable.TemplateInstance ); B.addParent( look ); @@ -2048,10 +2047,10 @@ public class ParserSymbolTableTest extends TestCase { b.setTypeSymbol( B ); table.getCompilationUnit().addSymbol( b ); - look = table.getCompilationUnit().Lookup( "b" ); + look = table.getCompilationUnit().lookup( "b" ); assertEquals( look, b ); - look = ((IDerivableContainerSymbol) b.getTypeSymbol()).Lookup( "t" ); + look = ((IDerivableContainerSymbol) b.getTypeSymbol()).lookup( "t" ); assertTrue( look instanceof TemplateInstance ); TemplateInstance instance = (TemplateInstance) look; @@ -2084,7 +2083,7 @@ public class ParserSymbolTableTest extends TestCase { ISymbol paramT = table.newSymbol( "T", TypeInfo.t_undef ); template.addParameter( paramT ); - ISymbol look = template.Lookup( "T" ); + ISymbol look = template.lookup( "T" ); assertEquals( look, paramT ); ISymbol paramU = table.newSymbol( "U", TypeInfo.t_undef ); paramU.getTypeInfo().setDefault( new TypeInfo( TypeInfo.t_type, 0, look ) ); @@ -2093,13 +2092,13 @@ public class ParserSymbolTableTest extends TestCase { IDerivableContainerSymbol X = table.newDerivableContainerSymbol( "X", TypeInfo.t_class ); template.addSymbol( X ); - look = X.Lookup( "T" ); + look = X.lookup( "T" ); assertEquals( look, paramT ); ISymbol t = table.newSymbol( "t", TypeInfo.t_type ); t.setTypeSymbol( look ); X.addSymbol( t ); - look = X.Lookup( "U" ); + look = X.lookup( "U" ); assertEquals( look, paramU ); ISymbol u = table.newSymbol( "u", TypeInfo.t_type ); u.setTypeSymbol( look ); @@ -2110,16 +2109,16 @@ public class ParserSymbolTableTest extends TestCase { TypeInfo type = new TypeInfo( TypeInfo.t_char, 0, null ); LinkedList args = new LinkedList(); args.add( type ); - look = table.getCompilationUnit().TemplateLookup( "X", args ); + look = table.getCompilationUnit().templateLookup( "X", args ); assertTrue( look instanceof TemplateInstance ); TemplateInstance instance = (TemplateInstance) look; - look = ((IDerivableContainerSymbol) instance.getInstantiatedSymbol()).Lookup( "t" ); + look = ((IDerivableContainerSymbol) instance.getInstantiatedSymbol()).lookup( "t" ); assertTrue( look instanceof TemplateInstance ); assertTrue( ((TemplateInstance) look).isType( TypeInfo.t_char ) ); - look = ((IDerivableContainerSymbol) instance.getInstantiatedSymbol()).Lookup( "u" ); + look = ((IDerivableContainerSymbol) instance.getInstantiatedSymbol()).lookup( "u" ); assertTrue( look instanceof TemplateInstance ); assertTrue( ((TemplateInstance) look).isType( TypeInfo.t_char ) ); } @@ -2158,7 +2157,7 @@ public class ParserSymbolTableTest extends TestCase { IDerivableContainerSymbol B = table.newDerivableContainerSymbol( "B", TypeInfo.t_class ); table.getCompilationUnit().addSymbol( B ); - IParameterizedSymbol temp = (IParameterizedSymbol) table.getCompilationUnit().Lookup( "A" ); + IParameterizedSymbol temp = (IParameterizedSymbol) table.getCompilationUnit().lookup( "A" ); assertEquals( temp, template ); LinkedList args = new LinkedList(); @@ -2184,7 +2183,7 @@ public class ParserSymbolTableTest extends TestCase { LinkedList params = new LinkedList(); params.add( new TypeInfo( TypeInfo.t_type, 0, a ) ); - ISymbol look = table.getCompilationUnit().UnqualifiedFunctionLookup( "f", params ); + ISymbol look = table.getCompilationUnit().unqualifiedFunctionLookup( "f", params ); assertEquals( look, f2 ); } @@ -2288,7 +2287,7 @@ public class ParserSymbolTableTest extends TestCase { template5.addSymbol( cls5 ); template1.addSpecialization( template5 ); - IParameterizedSymbol a = (IParameterizedSymbol) table.getCompilationUnit().Lookup( "A" ); + IParameterizedSymbol a = (IParameterizedSymbol) table.getCompilationUnit().lookup( "A" ); LinkedList args = new LinkedList(); @@ -2352,8 +2351,8 @@ public class ParserSymbolTableTest extends TestCase { /*...*/ - ISymbol lookup = table.getCompilationUnit().Lookup( "A" ); - ISymbol otherLookup = table.getCompilationUnit().ElaboratedLookup( TypeInfo.t_class, "A" ); + ISymbol lookup = table.getCompilationUnit().lookup( "A" ); + ISymbol otherLookup = table.getCompilationUnit().elaboratedLookup( TypeInfo.t_class, "A" ); assertEquals( lookup, otherLookup ); assertEquals( lookup, forwardSymbol ); @@ -2366,21 +2365,21 @@ public class ParserSymbolTableTest extends TestCase { /*...*/ - lookup = table.getCompilationUnit().Lookup( "A" ); + lookup = table.getCompilationUnit().lookup( "A" ); IDerivableContainerSymbol classA = table.newDerivableContainerSymbol( "A", TypeInfo.t_class ); assertTrue( lookup.isForwardDeclaration() ); lookup.setTypeSymbol( classA ); table.getCompilationUnit().addSymbol( classA ); - lookup = table.getCompilationUnit().Lookup( "a" ); + lookup = table.getCompilationUnit().lookup( "a" ); assertEquals( lookup, a ); assertEquals( a.getTypeSymbol(), classA ); - lookup = table.getCompilationUnit().Lookup( "A" ); + lookup = table.getCompilationUnit().lookup( "A" ); assertEquals( lookup, classA ); - lookup = table.getCompilationUnit().ElaboratedLookup( TypeInfo.t_class, "A" ); + lookup = table.getCompilationUnit().elaboratedLookup( TypeInfo.t_class, "A" ); assertEquals( lookup, classA ); } @@ -2418,7 +2417,7 @@ public class ParserSymbolTableTest extends TestCase { IDerivableContainerSymbol classB = table.newDerivableContainerSymbol( "B", TypeInfo.t_class ); IParameterizedSymbol fn1 = table.newParameterizedSymbol( "f", TypeInfo.t_function ); - ISymbol lookup = table.getCompilationUnit().Lookup( "A" ); + ISymbol lookup = table.getCompilationUnit().lookup( "A" ); assertEquals( lookup, forwardSymbol ); fn1.addParameter( lookup, new PtrOp( PtrOp.t_pointer ), false ); fn1.getTypeInfo().setBit( true, TypeInfo.isStatic ); @@ -2434,7 +2433,7 @@ public class ParserSymbolTableTest extends TestCase { /*...*/ ISymbol a1 = table.newSymbol( "a1", TypeInfo.t_type ); - lookup = table.getCompilationUnit().Lookup( "A" ); + lookup = table.getCompilationUnit().lookup( "A" ); assertEquals( lookup, forwardSymbol ); a1.setTypeSymbol( lookup ); a1.addPtrOperator( new PtrOp( PtrOp.t_pointer ) ); @@ -2443,7 +2442,7 @@ public class ParserSymbolTableTest extends TestCase { /*...*/ - lookup = table.getCompilationUnit().Lookup( "A" ); + lookup = table.getCompilationUnit().lookup( "A" ); IDerivableContainerSymbol classA = table.newDerivableContainerSymbol( "A", TypeInfo.t_class ); assertTrue( lookup.isForwardDeclaration() ); lookup.setTypeSymbol( classA ); @@ -2451,7 +2450,7 @@ public class ParserSymbolTableTest extends TestCase { /*..*/ ISymbol a2 = table.newSymbol( "a2", TypeInfo.t_type ); - lookup = table.getCompilationUnit().Lookup( "A" ); + lookup = table.getCompilationUnit().lookup( "A" ); assertEquals( lookup, classA ); a2.setTypeSymbol( lookup ); a2.addPtrOperator( new PtrOp( PtrOp.t_pointer ) ); @@ -2463,14 +2462,45 @@ public class ParserSymbolTableTest extends TestCase { LinkedList paramList = new LinkedList(); TypeInfo p1 = new TypeInfo( TypeInfo.t_type, 0, a1 ); paramList.add( p1 ); - ISymbol look = classB.MemberFunctionLookup( "f", paramList ); + ISymbol look = classB.memberFunctionLookup( "f", paramList ); assertEquals( look, fn1 ); paramList.clear(); p1 = new TypeInfo( TypeInfo.t_type, 0, a2 ); paramList.add( p1 ); - look = classB.MemberFunctionLookup( "f", paramList ); + look = classB.memberFunctionLookup( "f", paramList ); assertEquals( look, fn1 ); } + + public void testConstructors() throws Exception{ + newTable(); + + IDerivableContainerSymbol classA = table.newDerivableContainerSymbol( "A", TypeInfo.t_class ); + + IParameterizedSymbol constructor1 = table.newParameterizedSymbol( "A", TypeInfo.t_constructor ); + constructor1.addParameter( classA, new PtrOp( PtrOp.t_reference ), false ); + + IParameterizedSymbol constructor2 = table.newParameterizedSymbol( "A", TypeInfo.t_constructor ); + constructor2.addParameter( TypeInfo.t_int, 0, null, false ); + + classA.addConstructor( constructor1 ); + classA.addConstructor( constructor2 ); + + assertEquals( classA.getConstructors().size(), 2 ); + + IParameterizedSymbol cloned = (IParameterizedSymbol) constructor2.clone(); + try{ + classA.addConstructor( cloned ); + } catch ( ParserSymbolTableException e ) { + assertEquals( e.reason, ParserSymbolTableException.r_InvalidOverload ); + } + + LinkedList paramList = new LinkedList(); + paramList.add( new TypeInfo( TypeInfo.t_int, 0, null ) ); + + ISymbol lookup = classA.lookupConstructor( paramList ); + + assertEquals( lookup, constructor2 ); + } } diff --git a/core/org.eclipse.cdt.core/parser/ChangeLog b/core/org.eclipse.cdt.core/parser/ChangeLog index c964345d250..da30b99b77d 100644 --- a/core/org.eclipse.cdt.core/parser/ChangeLog +++ b/core/org.eclipse.cdt.core/parser/ChangeLog @@ -1,3 +1,13 @@ +2003-08-05 Andrew Niefer + - Refactor symbol table functions to start with lower case letters + - Added better constructor support : + IDerivableContainerSymbol.addConstructor + IDerivableContainerSymbol.lookupConstructor + IDerivableContainerSymbol.getConstructors + - Changed ParserSymbolTableException.r_Unspecified to r_InternalError + - implicit user-defined conversion sequences now only use constructors not marked explicit + - user-defined conversion sequences are now only applied at most once (12.3-4 in spec) + 2003-07-31 Andrew Niefer Added better support to the parser symbol table for forward declarations diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/complete/CompleteParseASTFactory.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/complete/CompleteParseASTFactory.java index 6b6e6600981..539bf5ba155 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/complete/CompleteParseASTFactory.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/complete/CompleteParseASTFactory.java @@ -111,7 +111,7 @@ public class CompleteParseASTFactory extends BaseASTFactory implements IASTFacto if( t.getType() == IToken.tCOLONCOLON ) continue; try { - symbol = symbol.LookupNestedNameSpecifier( t.getImage() ); + symbol = symbol.lookupNestedNameSpecifier( t.getImage() ); references.add( createReference( symbol, t.getImage(), t.getOffset() )); } catch( ParserSymbolTableException pste ) @@ -178,9 +178,9 @@ public class CompleteParseASTFactory extends BaseASTFactory implements IASTFacto try { if( t != name.getLastToken() ) - symbol = ((IContainerSymbol)symbol).LookupNestedNameSpecifier( t.getImage() ); + symbol = ((IContainerSymbol)symbol).lookupNestedNameSpecifier( t.getImage() ); else - symbol = ((IContainerSymbol)symbol).Lookup( t.getImage() ); + symbol = ((IContainerSymbol)symbol).lookup( t.getImage() ); } catch (ParserSymbolTableException e) { @@ -229,7 +229,7 @@ public class CompleteParseASTFactory extends BaseASTFactory implements IASTFacto ISymbol namespaceSymbol = null; try { - namespaceSymbol = pstScope.Lookup( identifier ); + namespaceSymbol = pstScope.lookup( identifier ); } catch (ParserSymbolTableException e) { @@ -396,9 +396,9 @@ public class CompleteParseASTFactory extends BaseASTFactory implements IASTFacto try { if( t == parentClassName.getLastToken()) - symbol = (IContainerSymbol)symbol.Lookup( t.getImage() ); + symbol = (IContainerSymbol)symbol.lookup( t.getImage() ); else - symbol = symbol.LookupNestedNameSpecifier( t.getImage() ); + symbol = symbol.lookupNestedNameSpecifier( t.getImage() ); references.add( createReference( symbol, t.getImage(), t.getOffset() )); } catch( ParserSymbolTableException pste ) @@ -672,9 +672,9 @@ public class CompleteParseASTFactory extends BaseASTFactory implements IASTFacto try { if( current != typeName.getLastToken() ) - typeSymbol = ((IContainerSymbol)typeSymbol).LookupNestedNameSpecifier( current.getImage()); + typeSymbol = ((IContainerSymbol)typeSymbol).lookupNestedNameSpecifier( current.getImage()); else - typeSymbol = ((IContainerSymbol)typeSymbol).Lookup( current.getImage()); + typeSymbol = ((IContainerSymbol)typeSymbol).lookup( current.getImage()); references.add( createReference( typeSymbol, current.getImage(), current.getOffset() )); } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IContainerSymbol.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IContainerSymbol.java index b58a3374aec..f266de7dabe 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IContainerSymbol.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IContainerSymbol.java @@ -41,14 +41,14 @@ public interface IContainerSymbol extends ISymbol { public Map getContainedSymbols(); - public ISymbol ElaboratedLookup( TypeInfo.eType type, String name ) throws ParserSymbolTableException; - public ISymbol Lookup( String name ) throws ParserSymbolTableException; - public ISymbol LookupMemberForDefinition( String name ) throws ParserSymbolTableException; - public IContainerSymbol LookupNestedNameSpecifier( String name ) throws ParserSymbolTableException; - public ISymbol QualifiedLookup( String name ) throws ParserSymbolTableException; - public IParameterizedSymbol UnqualifiedFunctionLookup( String name, LinkedList parameters ) throws ParserSymbolTableException; - public IParameterizedSymbol MemberFunctionLookup( String name, LinkedList parameters ) throws ParserSymbolTableException; - - public TemplateInstance TemplateLookup( String name, LinkedList arguments ) throws ParserSymbolTableException; + public ISymbol elaboratedLookup( TypeInfo.eType type, String name ) throws ParserSymbolTableException; + public ISymbol lookup( String name ) throws ParserSymbolTableException; + public ISymbol lookupMemberForDefinition( String name ) throws ParserSymbolTableException; + public IContainerSymbol lookupNestedNameSpecifier( String name ) throws ParserSymbolTableException; + public ISymbol qualifiedLookup( String name ) throws ParserSymbolTableException; + public IParameterizedSymbol unqualifiedFunctionLookup( String name, LinkedList parameters ) throws ParserSymbolTableException; + public IParameterizedSymbol memberFunctionLookup( String name, LinkedList parameters ) throws ParserSymbolTableException; + public IParameterizedSymbol qualifiedFunctionLookup( String name, LinkedList parameters ) throws ParserSymbolTableException; + public TemplateInstance templateLookup( String name, LinkedList arguments ) throws ParserSymbolTableException; public TemplateInstance instantiate( LinkedList arguments ) throws ParserSymbolTableException; } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IDerivableContainerSymbol.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IDerivableContainerSymbol.java index 188ca147bf6..c30545f2959 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IDerivableContainerSymbol.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IDerivableContainerSymbol.java @@ -16,6 +16,7 @@ */ package org.eclipse.cdt.internal.core.parser.pst; +import java.util.LinkedList; import java.util.List; import org.eclipse.cdt.core.parser.ast.ASTAccessVisibility; @@ -33,6 +34,10 @@ public interface IDerivableContainerSymbol extends IContainerSymbol { public List getParents(); public boolean hasParents(); + public void addConstructor( IParameterizedSymbol constructor ) throws ParserSymbolTableException; + public IParameterizedSymbol lookupConstructor( LinkedList parameters ) throws ParserSymbolTableException; + public LinkedList getConstructors(); + public interface IParentSymbol{ public void setParent( ISymbol parent ); public ISymbol getParent(); diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTable.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTable.java index cb730070e33..7eeea7e7292 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTable.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTable.java @@ -82,7 +82,7 @@ public class ParserSymbolTable { * @return Declaration * @throws ParserSymbolTableException */ - static private void Lookup( LookupData data, IContainerSymbol inSymbol ) throws ParserSymbolTableException + static private void lookup( LookupData data, IContainerSymbol inSymbol ) throws ParserSymbolTableException { if( data.type != TypeInfo.t_any && data.type.compareTo(TypeInfo.t_class) < 0 && data.upperType.compareTo(TypeInfo.t_union) > 0 ){ throw new ParserSymbolTableException( ParserSymbolTableException.r_BadTypeInfo ); @@ -92,7 +92,7 @@ public class ParserSymbolTable { LinkedList transitives = new LinkedList(); //list of transitive using directives //if this name define in this scope? - LookupInContained( data, inSymbol ); + lookupInContained( data, inSymbol ); if( !data.ignoreUsingDirectives ){ //check nominated namespaces @@ -101,24 +101,24 @@ public class ParserSymbolTable { data.visited.clear(); //each namesapce is searched at most once, so keep track - LookupInNominated( data, inSymbol, transitives ); + lookupInNominated( data, inSymbol, transitives ); //if we are doing a qualified lookup, only process using directives if //we haven't found the name yet (and if we aren't ignoring them). if( !data.qualified || data.foundItems == null ){ - ProcessDirectives( inSymbol, data, transitives ); + processDirectives( inSymbol, data, transitives ); if( inSymbol.hasUsingDirectives() ){ - ProcessDirectives( inSymbol, data, inSymbol.getUsingDirectives() ); + processDirectives( inSymbol, data, inSymbol.getUsingDirectives() ); } while( data.usingDirectives != null && data.usingDirectives.get( inSymbol ) != null ){ transitives.clear(); - LookupInNominated( data, inSymbol, transitives ); + lookupInNominated( data, inSymbol, transitives ); if( !data.qualified || data.foundItems == null ){ - ProcessDirectives( inSymbol, data, transitives ); + processDirectives( inSymbol, data, transitives ); } } } @@ -131,7 +131,7 @@ public class ParserSymbolTable { if( inSymbol instanceof IDerivableContainerSymbol ){ //if we still havn't found it, check any parents we have data.visited.clear(); //each virtual base class is searched at most once - symbol = LookupInParents( data, (IDerivableContainerSymbol)inSymbol ); + symbol = lookupInParents( data, (IDerivableContainerSymbol)inSymbol ); //there is a resolveAmbiguities inside LookupInParents, which means if we found //something the foundItems set will be non-null, but empty. So, add the decl into @@ -143,7 +143,7 @@ public class ParserSymbolTable { //if still not found, check our containing scope. if( data.foundItems == null && inSymbol.getContainingSymbol() != null ){ - Lookup( data, inSymbol.getContainingSymbol() ); + lookup( data, inSymbol.getContainingSymbol() ); } return; @@ -168,7 +168,7 @@ public class ParserSymbolTable { * directives, the effect is as if the using-directives from the second * namespace also appeared in the first. */ - static private void LookupInNominated( LookupData data, IContainerSymbol symbol, LinkedList transitiveDirectives ){ + static private void lookupInNominated( LookupData data, IContainerSymbol symbol, LinkedList transitiveDirectives ){ //if the data.usingDirectives is empty, there is nothing to do. if( data.usingDirectives == null ){ return; @@ -197,7 +197,7 @@ public class ParserSymbolTable { if( !data.visited.contains( temp ) ){ data.visited.add( temp ); - foundSomething = LookupInContained( data, temp ); + foundSomething = lookupInContained( data, temp ); //only consider the transitive using directives if we are an unqualified //lookup, or we didn't find the name in decl @@ -218,7 +218,7 @@ public class ParserSymbolTable { * * Look for data.name in our collection _containedDeclarations */ - private static boolean LookupInContained( LookupData data, IContainerSymbol lookIn ){ + private static boolean lookupInContained( LookupData data, IContainerSymbol lookIn ){ boolean foundSomething = false; ISymbol temp = null; @@ -323,14 +323,14 @@ public class ParserSymbolTable { * @return Declaration * @throws ParserSymbolTableException */ - private static ISymbol LookupInParents( LookupData data, ISymbol lookIn ) throws ParserSymbolTableException{ + private static ISymbol lookupInParents( LookupData data, ISymbol lookIn ) throws ParserSymbolTableException{ IDerivableContainerSymbol container = null; if( lookIn instanceof TemplateInstance ){ } else if( lookIn instanceof IDerivableContainerSymbol ){ container = (IDerivableContainerSymbol) lookIn; } else{ - throw new ParserSymbolTableException(); + throw new ParserSymbolTableException( ParserSymbolTableException.r_InternalError ); } List scopes = container.getParents(); @@ -380,18 +380,18 @@ public class ParserSymbolTable { data.templateInstance = (TemplateInstance) parent; ISymbol instance = ((TemplateInstance)parent).getInstantiatedSymbol(); if( instance instanceof IContainerSymbol ) - LookupInContained( data, (IContainerSymbol)instance ); + lookupInContained( data, (IContainerSymbol)instance ); else throw new ParserSymbolTableException( ParserSymbolTableException.r_BadTemplate ); data.templateInstance = tempInstance; } else if( parent instanceof IDerivableContainerSymbol ){ - LookupInContained( data, (IDerivableContainerSymbol) parent ); + lookupInContained( data, (IDerivableContainerSymbol) parent ); } else { throw new ParserSymbolTableException( ParserSymbolTableException.r_BadTypeInfo ); } - temp = ResolveAmbiguities( data ); + temp = resolveAmbiguities( data ); if( temp == null ){ - temp = LookupInParents( data, parent ); + temp = lookupInParents( data, parent ); } } else { throw new ParserSymbolTableException( ParserSymbolTableException.r_CircularInheritance ); @@ -491,7 +491,8 @@ public class ParserSymbolTable { } private static boolean isValidFunctionOverload( IParameterizedSymbol origSymbol, IParameterizedSymbol newSymbol ){ - if( origSymbol.getType() != TypeInfo.t_function || newSymbol.getType() != TypeInfo.t_function ){ + if( ( !origSymbol.isType( TypeInfo.t_function ) && !origSymbol.isType( TypeInfo.t_constructor ) ) || + ( ! newSymbol.isType( TypeInfo.t_function ) && ! newSymbol.isType( TypeInfo.t_constructor ) ) ){ return false; } @@ -533,7 +534,7 @@ public class ParserSymbolTable { * all, when looking for functions with no parameters, an empty list must be * provided in data.parameters. */ - static private ISymbol ResolveAmbiguities( LookupData data ) throws ParserSymbolTableException{ + static private ISymbol resolveAmbiguities( LookupData data ) throws ParserSymbolTableException{ ISymbol decl = null; ISymbol obj = null; IContainerSymbol cls = null; @@ -643,7 +644,7 @@ public class ParserSymbolTable { return null; } } else { - return ResolveFunction( data, functionList ); + return resolveFunction( data, functionList ); } } @@ -654,9 +655,12 @@ public class ParserSymbolTable { } } - static private IParameterizedSymbol ResolveFunction( LookupData data, LinkedList functions ) throws ParserSymbolTableException{ - - ReduceToViable( data, functions ); + static private IParameterizedSymbol resolveFunction( LookupData data, LinkedList functions ) throws ParserSymbolTableException{ + if( functions == null ){ + return null; + } + + reduceToViable( data, functions ); int numSourceParams = ( data.parameters == null ) ? 0 : data.parameters.size(); int numFns = functions.size(); @@ -726,7 +730,9 @@ public class ParserSymbolTable { } else { cost = checkStandardConversionSequence( source, target ); - if( cost.rank == -1){ + //12.3-4 At most one user-defined conversion is implicitly applied to + //a single value. (also prevents infinite loop) + if( cost.rank == -1 && !data.forUserDefinedConversion ){ temp = checkUserDefinedConversionSequence( source, target ); if( temp != null ){ cost = temp; @@ -779,7 +785,7 @@ public class ParserSymbolTable { return bestFn; } - static private void ReduceToViable( LookupData data, LinkedList functions ){ + static private void reduceToViable( LookupData data, LinkedList functions ){ int numParameters = ( data.parameters == null ) ? 0 : data.parameters.size(); int num; @@ -829,7 +835,7 @@ public class ParserSymbolTable { * nominated namespace to the lookup data for consideration when we reach * the enclosing declaration. */ - static private void ProcessDirectives( IContainerSymbol symbol, LookupData data, List directives ){ + static private void processDirectives( IContainerSymbol symbol, LookupData data, List directives ){ IContainerSymbol enclosing = null; IContainerSymbol temp = null; @@ -1341,19 +1347,25 @@ public class ParserSymbolTable { if( target.getType() == TypeInfo.t_type ){ targetDecl = target.getTypeSymbol(); if( targetDecl.isType( TypeInfo.t_class, TypeInfo.t_union ) ){ - LookupData data = new LookupData( "", TypeInfo.t_function, null ); - LinkedList params = new LinkedList(); - params.add( source ); - data.parameters = params; + LookupData data = new LookupData( "", TypeInfo.t_constructor, null ); + data.parameters = new LinkedList(); + data.parameters.add( source ); + data.forUserDefinedConversion = true; + + IDerivableContainerSymbol container = (IDerivableContainerSymbol) targetDecl; + if( targetDecl instanceof TemplateInstance ){ data.templateInstance = targetDecl; - TemplateInstance instance = (TemplateInstance) targetDecl; - LookupInContained( data, (IContainerSymbol) instance.getInstantiatedSymbol() ); - } else { - LookupInContained( data, (IContainerSymbol) targetDecl ); + container = (IDerivableContainerSymbol)((TemplateInstance) targetDecl).getInstantiatedSymbol(); + } + + if( container.getConstructors() != null ){ + constructor = resolveFunction( data, container.getConstructors() ); + } + if( constructor != null && constructor.getTypeInfo().checkBit( TypeInfo.isExplicit ) ){ + constructor = null; } - constructor = (IParameterizedSymbol)ResolveAmbiguities( data ); } } @@ -1369,9 +1381,10 @@ public class ParserSymbolTable { LookupData data = new LookupData( "operator " + name, TypeInfo.t_function, null ); LinkedList params = new LinkedList(); data.parameters = params; + data.forUserDefinedConversion = true; - LookupInContained( data, (IContainerSymbol) sourceDecl ); - conversion = (IParameterizedSymbol)ResolveAmbiguities( data ); + lookupInContained( data, (IContainerSymbol) sourceDecl ); + conversion = (IParameterizedSymbol)resolveAmbiguities( data ); } } } @@ -1856,8 +1869,8 @@ public class ParserSymbolTable { } else if( obj instanceof BasicSymbol ){ _context.getContainedSymbols().remove( _decl.getName() ); } - if( _removeThis ){ - _context.getContainedSymbols().remove( "this" ); + if( _removeThis && _decl instanceof IParameterizedSymbol ){ + ((IParameterizedSymbol)_decl).getContainedSymbols().remove( "this" ); } } @@ -1866,6 +1879,36 @@ public class ParserSymbolTable { private boolean _removeThis; } + static private class AddConstructorCommand extends Command{ + AddConstructorCommand( Declaration newConstr, Declaration context, boolean removeThis ){ + _constructor = newConstr; + _context = context; + _removeThis = removeThis; + } + public void undoIt(){ + LinkedList constructors = _context.getConstructors(); + ListIterator iter = constructors.listIterator(); + + int size = constructors.size(); + Declaration item = null; + for( int i = 0; i < size; i++ ){ + item = (Declaration)iter.next(); + if( item == _constructor ){ + iter.remove(); + break; + } + } + + if( _removeThis ){ + _constructor.getContainedSymbols().remove( "this" ); + } + } + + private Declaration _constructor; + private Declaration _context; + private boolean _removeThis; + } + static private class AddParentCommand extends Command{ public AddParentCommand( Declaration container, Declaration.ParentWrapper wrapper ){ _decl = container; @@ -1943,6 +1986,7 @@ public class ParserSymbolTable { public TypeInfo.eType upperType = TypeInfo.t_undef; public boolean qualified = false; public boolean ignoreUsingDirectives = false; + public boolean forUserDefinedConversion = false; public HashSet foundItems = null; @@ -2413,6 +2457,16 @@ public class ParserSymbolTable { return _containedDeclarations; } + public LinkedList getConstructors(){ + return _constructors; + } + + public LinkedList createConstructors(){ + if( _constructors == null ) + _constructors = new LinkedList(); + + return _constructors; + } public boolean hasParents(){ return ( _parentScopes != null && !_parentScopes.isEmpty() ); } @@ -2594,7 +2648,7 @@ public class ParserSymbolTable { } else if( origObj.getClass() == LinkedList.class ){ origList = (LinkedList)origObj; } else { - throw new ParserSymbolTableException(); + throw new ParserSymbolTableException( ParserSymbolTableException.r_InternalError ); } boolean validOverride = ((origList == null) ? isValidOverload( origDecl, obj ) : isValidOverload( origList, obj ) ); @@ -2605,7 +2659,7 @@ public class ParserSymbolTable { origList.add( origDecl ); origList.add( obj ); - declarations.remove( obj ); + declarations.remove( origDecl ); declarations.put( obj.getName(), origList ); } else { origList.add( obj ); @@ -2624,14 +2678,37 @@ public class ParserSymbolTable { TypeInfo type = obj.getTypeInfo(); boolean addedThis = false; if( type.isType( TypeInfo.t_function ) && !type.checkBit( TypeInfo.isStatic ) ){ - addThis( (Declaration) obj ); - addedThis = true; + addedThis = addThis( (Declaration) obj ); } Command command = new AddDeclarationCommand( (BasicSymbol) obj, containing, addedThis ); pushCommand( command ); } + public void addConstructor(IParameterizedSymbol constructor) throws ParserSymbolTableException { + if( !constructor.isType( TypeInfo.t_constructor ) ) + throw new ParserSymbolTableException( ParserSymbolTableException.r_BadTypeInfo ); + + Object origObj = null; + + LinkedList constructors = getConstructors(); + + if( constructors == null ) + constructors = createConstructors(); + + if( constructors.size() == 0 || isValidOverload( constructors, constructor ) ){ + constructors.add( constructor ); + } else { + throw new ParserSymbolTableException( ParserSymbolTableException.r_InvalidOverload ); + } + + constructor.setContainingSymbol( this ); + boolean addedThis = addThis( (Declaration) constructor ); + + Command command = new AddConstructorCommand( (Declaration)constructor, this, addedThis ); + pushCommand( command ); + } + /** * * @param obj @@ -2641,17 +2718,18 @@ public class ParserSymbolTable { * this is const X*, if the member function is declared volatile, the type * of this is volatile X*.... */ - private void addThis( Declaration obj ){ + private boolean addThis( Declaration obj ){ TypeInfo type = obj.getTypeInfo(); - if( !type.isType( TypeInfo.t_function ) || type.checkBit( TypeInfo.isStatic ) ){ - return; + if( ( !type.isType( TypeInfo.t_function ) && !type.isType( TypeInfo.t_constructor) ) || + type.checkBit( TypeInfo.isStatic ) ){ + return false; } if( obj.getContainingSymbol().isType( TypeInfo.t_class, TypeInfo.t_union ) ){ //check to see if there is already a this object, since using declarations //of function will have them from the original declaration LookupData data = new LookupData( "this", TypeInfo.t_any, null ); - LookupInContained( data, obj ); + lookupInContained( data, obj ); //if we didn't find "this" then foundItems will still be null, no need to actually //check its contents if( data.foundItems == null ){ @@ -2671,11 +2749,13 @@ public class ParserSymbolTable { try{ obj.addSymbol( thisObj ); } catch ( ParserSymbolTableException e ) { - //won't happen because we checked that "this" didn't exist already + //shouldn't happen because we checked that "this" didn't exist already + return false; } } - } + } + return true; } /** @@ -2692,7 +2772,7 @@ public class ParserSymbolTable { * (public/protected/private) we will need to do more to record friendship. */ public Declaration addFriend( String name ) throws ParserSymbolTableException{ - Declaration friend = LookupForFriendship( name ); + Declaration friend = lookupForFriendship( name ); if( friend == null ){ friend = new Declaration( name ); @@ -2723,7 +2803,7 @@ public class ParserSymbolTable { * without considering scopes that are outside the innermost enclosing non- * class scope. */ - private Declaration LookupForFriendship( String name ) throws ParserSymbolTableException{ + private Declaration lookupForFriendship( String name ) throws ParserSymbolTableException{ LookupData data = new LookupData( name, TypeInfo.t_any, getTemplateInstance() ); boolean inClass = ( getType() == TypeInfo.t_class); @@ -2737,8 +2817,8 @@ public class ParserSymbolTable { data.stopAt = enclosing; - ParserSymbolTable.Lookup( data, this ); - return (Declaration)ParserSymbolTable.ResolveAmbiguities( data ); + ParserSymbolTable.lookup( data, this ); + return (Declaration)ParserSymbolTable.resolveAmbiguities( data ); } /** @@ -2767,17 +2847,17 @@ public class ParserSymbolTable { if( declContext != null ){ data.qualified = true; data.templateInstance = declContext.getTemplateInstance(); - ParserSymbolTable.Lookup( data, declContext ); + ParserSymbolTable.lookup( data, declContext ); } else { - ParserSymbolTable.Lookup( data, this ); + ParserSymbolTable.lookup( data, this ); } //figure out which declaration we are talking about, if it is a set of functions, //then they will be in data.foundItems (since we provided no parameter info); - BasicSymbol obj = (BasicSymbol)ParserSymbolTable.ResolveAmbiguities( data ); + BasicSymbol obj = (BasicSymbol)ParserSymbolTable.resolveAmbiguities( data ); if( data.foundItems == null ){ - throw new ParserSymbolTableException(); + throw new ParserSymbolTableException( ParserSymbolTableException.r_InvalidUsing ); } BasicSymbol clone = null; @@ -2793,7 +2873,7 @@ public class ParserSymbolTable { clone = (BasicSymbol) obj.clone(); //7.3.3-9 addSymbol( clone ); } else { - throw new ParserSymbolTableException(); + throw new ParserSymbolTableException( ParserSymbolTableException.r_InvalidUsing ); } } @@ -2802,7 +2882,7 @@ public class ParserSymbolTable { public void addUsingDirective( IContainerSymbol namespace ) throws ParserSymbolTableException{ if( namespace.getType() != TypeInfo.t_namespace ){ - throw new ParserSymbolTableException( ParserSymbolTableException.r_BadTypeInfo ); + throw new ParserSymbolTableException( ParserSymbolTableException.r_InvalidUsing ); } if( _usingDirectives == null ){ @@ -2823,20 +2903,20 @@ public class ParserSymbolTable { return _usingDirectives; } - public ISymbol ElaboratedLookup( TypeInfo.eType type, String name ) throws ParserSymbolTableException{ + public ISymbol elaboratedLookup( TypeInfo.eType type, String name ) throws ParserSymbolTableException{ LookupData data = new LookupData( name, type, getTemplateInstance() ); - ParserSymbolTable.Lookup( data, this ); + ParserSymbolTable.lookup( data, this ); - return ParserSymbolTable.ResolveAmbiguities( data ); + return ParserSymbolTable.resolveAmbiguities( data ); } - public ISymbol Lookup( String name ) throws ParserSymbolTableException { + public ISymbol lookup( String name ) throws ParserSymbolTableException { LookupData data = new LookupData( name, TypeInfo.t_any, getTemplateInstance() ); - ParserSymbolTable.Lookup( data, this ); + ParserSymbolTable.lookup( data, this ); - return ParserSymbolTable.ResolveAmbiguities( data ); + return ParserSymbolTable.resolveAmbiguities( data ); } /** @@ -2867,13 +2947,13 @@ public class ParserSymbolTable { * ie, We need a seperate lookup function for looking up the member names * for a definition. */ - public ISymbol LookupMemberForDefinition( String name ) throws ParserSymbolTableException{ + public ISymbol lookupMemberForDefinition( String name ) throws ParserSymbolTableException{ LookupData data = new LookupData( name, TypeInfo.t_any, getTemplateInstance() ); data.qualified = true; - ParserSymbolTable.LookupInContained( data, this ); + ParserSymbolTable.lookupInContained( data, this ); - return ParserSymbolTable.ResolveAmbiguities( data ); + return ParserSymbolTable.resolveAmbiguities( data ); } /** @@ -2886,23 +2966,23 @@ public class ParserSymbolTable { * the ::, object, function and enumerator names are ignored. If the name * is not a class-name or namespace-name, the program is ill-formed */ - public IContainerSymbol LookupNestedNameSpecifier( String name ) throws ParserSymbolTableException { - return LookupNestedNameSpecifier( name, this ); + public IContainerSymbol lookupNestedNameSpecifier( String name ) throws ParserSymbolTableException { + return lookupNestedNameSpecifier( name, this ); } - private Declaration LookupNestedNameSpecifier(String name, Declaration inDeclaration ) throws ParserSymbolTableException{ + private Declaration lookupNestedNameSpecifier(String name, Declaration inDeclaration ) throws ParserSymbolTableException{ Declaration foundDeclaration = null; LookupData data = new LookupData( name, TypeInfo.t_namespace, getTemplateInstance() ); data.upperType = TypeInfo.t_union; - ParserSymbolTable.LookupInContained( data, inDeclaration ); + ParserSymbolTable.lookupInContained( data, inDeclaration ); if( data.foundItems != null ){ - foundDeclaration = (Declaration) ParserSymbolTable.ResolveAmbiguities( data );//, data.foundItems ); + foundDeclaration = (Declaration) ParserSymbolTable.resolveAmbiguities( data );//, data.foundItems ); } if( foundDeclaration == null && inDeclaration.getContainingSymbol() != null ){ - foundDeclaration = LookupNestedNameSpecifier( name, (Declaration)inDeclaration.getContainingSymbol() ); + foundDeclaration = lookupNestedNameSpecifier( name, (Declaration)inDeclaration.getContainingSymbol() ); } return foundDeclaration; @@ -2918,49 +2998,57 @@ public class ParserSymbolTable { * Member lookup really proceeds as an unqualified lookup, but doesn't * include argument dependant scopes */ - public IParameterizedSymbol MemberFunctionLookup( String name, LinkedList parameters ) throws ParserSymbolTableException{ + public IParameterizedSymbol memberFunctionLookup( String name, LinkedList parameters ) throws ParserSymbolTableException{ LookupData data = new LookupData( name, TypeInfo.t_function, getTemplateInstance() ); //if parameters == null, thats no parameters, but we need to distinguish that from //no parameter information at all, so make an empty list. data.parameters = ( parameters == null ) ? new LinkedList() : parameters; - ParserSymbolTable.Lookup( data, (IContainerSymbol) this ); - return (IParameterizedSymbol) ParserSymbolTable.ResolveAmbiguities( data ); + ParserSymbolTable.lookup( data, (IContainerSymbol) this ); + return (IParameterizedSymbol) ParserSymbolTable.resolveAmbiguities( data ); } - public IParameterizedSymbol QualifiedFunctionLookup( String name, LinkedList parameters ) throws ParserSymbolTableException{ + public IParameterizedSymbol qualifiedFunctionLookup( String name, LinkedList parameters ) throws ParserSymbolTableException{ LookupData data = new LookupData( name, TypeInfo.t_function, getTemplateInstance() ); data.qualified = true; //if parameters == null, thats no parameters, but we need to distinguish that from //no parameter information at all, so make an empty list. data.parameters = ( parameters == null ) ? new LinkedList() : parameters; - ParserSymbolTable.Lookup( data, (IContainerSymbol)this ); + ParserSymbolTable.lookup( data, (IContainerSymbol)this ); - return (IParameterizedSymbol) ParserSymbolTable.ResolveAmbiguities( data ); + return (IParameterizedSymbol) ParserSymbolTable.resolveAmbiguities( data ); } - public ISymbol QualifiedLookup( String name ) throws ParserSymbolTableException{ + public ISymbol qualifiedLookup( String name ) throws ParserSymbolTableException{ LookupData data = new LookupData( name, TypeInfo.t_any, getTemplateInstance() ); data.qualified = true; - ParserSymbolTable.Lookup( data, this ); + ParserSymbolTable.lookup( data, this ); - return ParserSymbolTable.ResolveAmbiguities( data ); + return ParserSymbolTable.resolveAmbiguities( data ); } - public TemplateInstance TemplateLookup( String name, LinkedList arguments ) throws ParserSymbolTableException + public TemplateInstance templateLookup( String name, LinkedList arguments ) throws ParserSymbolTableException { LookupData data = new LookupData( name, TypeInfo.t_any, getTemplateInstance() ); data.parameters = arguments; - ParserSymbolTable.Lookup( data, (IContainerSymbol) this ); - ISymbol found = ParserSymbolTable.ResolveAmbiguities( data ); + ParserSymbolTable.lookup( data, (IContainerSymbol) this ); + ISymbol found = ParserSymbolTable.resolveAmbiguities( data ); if( found.isType( TypeInfo.t_template ) ){ return ((IParameterizedSymbol) found).instantiate( arguments ); } return null; } + public IParameterizedSymbol lookupConstructor( LinkedList parameters ) throws ParserSymbolTableException + { + LookupData data = new LookupData( "", TypeInfo.t_constructor, null ); + data.parameters = parameters; + + return ParserSymbolTable.resolveFunction( data, getConstructors() ); + } + /** * UnqualifiedFunctionLookup * @param name @@ -2983,7 +3071,7 @@ public class ParserSymbolTable { * ordinary unqualified lookup and the set of declarations found in the * namespaces and classes associated with the argument types. */ - public IParameterizedSymbol UnqualifiedFunctionLookup( String name, LinkedList parameters ) throws ParserSymbolTableException{ + public IParameterizedSymbol unqualifiedFunctionLookup( String name, LinkedList parameters ) throws ParserSymbolTableException{ //figure out the set of associated scopes first, so we can remove those that are searched //during the normal lookup to avoid doing them twice HashSet associated = new HashSet(); @@ -3018,9 +3106,9 @@ public class ParserSymbolTable { data.parameters = ( parameters == null ) ? new LinkedList() : parameters; data.associated = associated; - ParserSymbolTable.Lookup( data, this ); + ParserSymbolTable.lookup( data, this ); - Declaration found = (Declaration)ResolveAmbiguities( data ); + Declaration found = (Declaration)resolveAmbiguities( data ); //if we haven't found anything, or what we found is not a class member, consider the //associated scopes @@ -3044,11 +3132,11 @@ public class ParserSymbolTable { if( associated.contains( decl ) ){ data.qualified = true; data.ignoreUsingDirectives = true; - ParserSymbolTable.Lookup( data, decl ); + ParserSymbolTable.lookup( data, decl ); } } - found = (Declaration)ParserSymbolTable.ResolveAmbiguities( data ); + found = (Declaration)ParserSymbolTable.resolveAmbiguities( data ); } return found; @@ -3136,6 +3224,8 @@ public class ParserSymbolTable { private LinkedList _parameterList; //have my cake private HashMap _parameterHash; //and eat it too + private LinkedList _constructors; //constructor list + private ISymbol _returnType; @@ -3196,5 +3286,4 @@ public class ParserSymbolTable { } } - } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTableException.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTableException.java index b5ef7338ac3..9c9920d0774 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTableException.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTableException.java @@ -36,12 +36,13 @@ public class ParserSymbolTableException extends Exception { reason = r; } - public static final int r_Unspecified = -1; + public static final int r_InternalError = -1; public static final int r_Ambiguous = 0; public static final int r_BadTypeInfo = 1; public static final int r_CircularInheritance = 2; public static final int r_InvalidOverload = 3; public static final int r_BadTemplate = 4; + public static final int r_InvalidUsing = 5; public int reason = -1; } \ No newline at end of file diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeInfo.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeInfo.java index 99c6192b113..7cc6c47c13e 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeInfo.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeInfo.java @@ -97,19 +97,20 @@ public class TypeInfo { public static final TypeInfo.eType t_struct = new TypeInfo.eType( 4 ); public static final TypeInfo.eType t_union = new TypeInfo.eType( 5 ); public static final TypeInfo.eType t_enumeration = new TypeInfo.eType( 6 ); - public static final TypeInfo.eType t_function = new TypeInfo.eType( 7 ); - public static final TypeInfo.eType t_bool = new TypeInfo.eType( 8 ); - public static final TypeInfo.eType t_char = new TypeInfo.eType( 9 ); - public static final TypeInfo.eType t_wchar_t = new TypeInfo.eType( 10 ); - public static final TypeInfo.eType t_int = new TypeInfo.eType( 11 ); - public static final TypeInfo.eType t_float = new TypeInfo.eType( 12 ); - public static final TypeInfo.eType t_double = new TypeInfo.eType( 13 ); - public static final TypeInfo.eType t_void = new TypeInfo.eType( 14 ); - public static final TypeInfo.eType t_enumerator = new TypeInfo.eType( 15 ); - public static final TypeInfo.eType t_block = new TypeInfo.eType( 16 ); - public static final TypeInfo.eType t_template = new TypeInfo.eType( 17 ); - public static final TypeInfo.eType t_asm = new TypeInfo.eType( 18 ); - public static final TypeInfo.eType t_linkage = new TypeInfo.eType( 19 ); + public static final TypeInfo.eType t_constructor = new TypeInfo.eType( 7 ); + public static final TypeInfo.eType t_function = new TypeInfo.eType( 8 ); + public static final TypeInfo.eType t_bool = new TypeInfo.eType( 9 ); + public static final TypeInfo.eType t_char = new TypeInfo.eType( 10 ); + public static final TypeInfo.eType t_wchar_t = new TypeInfo.eType( 11 ); + public static final TypeInfo.eType t_int = new TypeInfo.eType( 12 ); + public static final TypeInfo.eType t_float = new TypeInfo.eType( 13 ); + public static final TypeInfo.eType t_double = new TypeInfo.eType( 14 ); + public static final TypeInfo.eType t_void = new TypeInfo.eType( 15 ); + public static final TypeInfo.eType t_enumerator = new TypeInfo.eType( 16 ); + public static final TypeInfo.eType t_block = new TypeInfo.eType( 17 ); + public static final TypeInfo.eType t_template = new TypeInfo.eType( 18 ); + public static final TypeInfo.eType t_asm = new TypeInfo.eType( 19 ); + public static final TypeInfo.eType t_linkage = new TypeInfo.eType( 20 ); //public static final eType t_templateParameter = new eType( 18 ); public static class eType implements Comparable{