Google Git
Sign in
eclipse / cdt / org.eclipse.cdt / db794992cbbb687ea7c111afb992915d6f431fc1 / . / core / org.eclipse.cdt.core.tests / parser / org / eclipse / cdt / core / parser / tests / QuickParseASTTests.java
blob: 04fa8c01631e7f102ce5c851aefcc86650239637 [file] [log] [blame]
/**********************************************************************
* Copyright (c) 2002,2003 Rational Software Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v0.5
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v05.html
*
* Contributors:
* IBM Rational Software - Initial API and implementation
***********************************************************************/
package org.eclipse.cdt.core.parser.tests;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Iterator;
import org.eclipse.cdt.core.parser.ParserLanguage;
import org.eclipse.cdt.core.parser.ast.ASTAccessVisibility;
import org.eclipse.cdt.core.parser.ast.ASTClassKind;
import org.eclipse.cdt.core.parser.ast.ASTPointerOperator;
import org.eclipse.cdt.core.parser.ast.IASTASMDefinition;
import org.eclipse.cdt.core.parser.ast.IASTAbstractTypeSpecifierDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTArrayModifier;
import org.eclipse.cdt.core.parser.ast.IASTBaseSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTClassSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTCompilationUnit;
import org.eclipse.cdt.core.parser.ast.IASTDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTElaboratedTypeSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTEnumerationSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTEnumerator;
import org.eclipse.cdt.core.parser.ast.IASTExpression;
import org.eclipse.cdt.core.parser.ast.IASTField;
import org.eclipse.cdt.core.parser.ast.IASTFunction;
import org.eclipse.cdt.core.parser.ast.IASTInclusion;
import org.eclipse.cdt.core.parser.ast.IASTInitializerClause;
import org.eclipse.cdt.core.parser.ast.IASTLinkageSpecification;
import org.eclipse.cdt.core.parser.ast.IASTMacro;
import org.eclipse.cdt.core.parser.ast.IASTMethod;
import org.eclipse.cdt.core.parser.ast.IASTNamespaceAlias;
import org.eclipse.cdt.core.parser.ast.IASTNamespaceDefinition;
import org.eclipse.cdt.core.parser.ast.IASTParameterDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTSimpleTypeSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTTemplateDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTTemplateInstantiation;
import org.eclipse.cdt.core.parser.ast.IASTTemplateParameter;
import org.eclipse.cdt.core.parser.ast.IASTTemplateSpecialization;
import org.eclipse.cdt.core.parser.ast.IASTTypedefDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTUsingDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTUsingDirective;
import org.eclipse.cdt.core.parser.ast.IASTVariable;
import org.eclipse.cdt.internal.core.parser.ParserException;
/**
* @author jcamelon
*
*/
public class QuickParseASTTests extends BaseASTTest
{
public QuickParseASTTests(String a)
{
super(a);
}
/**
* Test code: int x = 5;
* Purpose: to test the simple decaration in it's simplest form.
*/
public void testIntGlobal() throws Exception
{
// Parse and get the translation Unit
IASTCompilationUnit translationUnit = parse("int x = 5;");
Iterator i = translationUnit.getDeclarations();
assertTrue(i.hasNext());
IASTVariable var = (IASTVariable)i.next();
assertTrue(
var.getAbstractDeclaration().getTypeSpecifier()
instanceof IASTSimpleTypeSpecifier);
assertTrue(
((IASTSimpleTypeSpecifier)var
.getAbstractDeclaration()
.getTypeSpecifier())
.getType()
== IASTSimpleTypeSpecifier.Type.INT);
assertEquals(var.getName(), "x");
assertNotNull(var.getInitializerClause());
assertNotNull(var.getInitializerClause().getAssigmentExpression());
assertFalse(i.hasNext());
}
/**
* Test code: class A { } a;
* Purpose: tests the use of a classSpecifier in
*/
public void testEmptyClass() throws Exception
{
// Parse and get the translation unit
Writer code = new StringWriter();
code.write("class A { } a;");
IASTCompilationUnit translationUnit = parse(code.toString());
Iterator i = translationUnit.getDeclarations();
assertTrue(i.hasNext());
IASTVariable var = (IASTVariable)i.next();
assertEquals(var.getName(), "a");
assertTrue(
var.getAbstractDeclaration().getTypeSpecifier()
instanceof IASTClassSpecifier);
IASTClassSpecifier classSpec =
(IASTClassSpecifier)var.getAbstractDeclaration().getTypeSpecifier();
assertEquals(classSpec.getName(), "A");
assertFalse(classSpec.getDeclarations().hasNext());
assertFalse(i.hasNext());
}
/**
* Test code: class A { public: int x; };
* Purpose: tests a declaration in a class scope.
*/
public void testSimpleClassMember() throws Exception
{
// Parse and get the translaton unit
Writer code = new StringWriter();
code.write("class A { public: int x; };");
IASTCompilationUnit cu = parse(code.toString());
Iterator i = cu.getDeclarations();
assertTrue(i.hasNext());
IASTAbstractTypeSpecifierDeclaration declaration =
(IASTAbstractTypeSpecifierDeclaration)i.next();
assertFalse(i.hasNext());
assertTrue(
declaration.getTypeSpecifier() instanceof IASTClassSpecifier);
assertTrue(
((IASTClassSpecifier)declaration.getTypeSpecifier()).getClassKind()
== ASTClassKind.CLASS);
Iterator j =
((IASTClassSpecifier)declaration.getTypeSpecifier())
.getDeclarations();
assertTrue(j.hasNext());
IASTField field = (IASTField)j.next();
assertFalse(j.hasNext());
assertTrue(field.getName().equals("x"));
assertTrue(
field.getAbstractDeclaration().getTypeSpecifier()
instanceof IASTSimpleTypeSpecifier);
assertTrue(
((IASTSimpleTypeSpecifier)field
.getAbstractDeclaration()
.getTypeSpecifier())
.getType()
== IASTSimpleTypeSpecifier.Type.INT);
}
public void testNamespaceDefinition() throws Exception
{
for (int i = 0; i < 2; ++i)
{
IASTCompilationUnit translationUnit;
if (i == 0)
translationUnit = parse("namespace KingJohn { int x; }");
else
translationUnit = parse("namespace { int x; }");
Iterator iter = translationUnit.getDeclarations();
assertTrue(iter.hasNext());
IASTNamespaceDefinition namespaceDefinition =
(IASTNamespaceDefinition)iter.next();
assertFalse(iter.hasNext());
if (i == 0)
assertTrue(namespaceDefinition.getName().equals("KingJohn"));
else
assertEquals(namespaceDefinition.getName(), "");
Iterator j = namespaceDefinition.getDeclarations();
assertTrue(j.hasNext());
IASTVariable var = (IASTVariable)j.next();
assertFalse(j.hasNext());
assertTrue(
var.getAbstractDeclaration().getTypeSpecifier()
instanceof IASTSimpleTypeSpecifier);
assertTrue(
((IASTSimpleTypeSpecifier)var
.getAbstractDeclaration()
.getTypeSpecifier())
.getType()
== IASTSimpleTypeSpecifier.Type.INT);
assertEquals(var.getName(), "x");
}
}
public void testLinkageSpecification() throws Exception
{
for( int i = 0; i < 2; ++i )
{
IASTCompilationUnit compilationUnit;
if( i == 0 )
compilationUnit = parse("extern \"C\" { int x(void); }");
else
compilationUnit = parse("extern \"ADA\" int x(void);");
Iterator declarations = compilationUnit.getDeclarations();
assertTrue( declarations.hasNext() );
IASTLinkageSpecification linkage = (IASTLinkageSpecification)declarations.next();
assertFalse( declarations.hasNext() );
if( i == 0 )
assertEquals( "C", linkage.getLinkageString() );
else
assertEquals( "ADA", linkage.getLinkageString() );
Iterator subDeclarations = linkage.getDeclarations();
assertTrue( subDeclarations.hasNext() );
IASTFunction function = (IASTFunction)subDeclarations.next();
assertFalse( subDeclarations.hasNext());
assertEquals( ((IASTSimpleTypeSpecifier)function.getReturnType().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.INT );
assertEquals( function.getName(), "x");
Iterator parameters = function.getParameters();
assertTrue( parameters.hasNext() );
IASTParameterDeclaration parm = (IASTParameterDeclaration)parameters.next();
assertFalse( parameters.hasNext() );
assertEquals( ((IASTSimpleTypeSpecifier)parm.getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.VOID );
assertEquals( parm.getName(), "" );
}
}
public void testEnumSpecifier() throws Exception
{
Writer code = new StringWriter();
code.write( "enum { yo, go = 3, away };\n");
code.write( "enum hasAString { last = 666 };");
IASTCompilationUnit translationUnit = parse( code.toString() );
Iterator declarations = translationUnit.getDeclarations();
for( int i = 0; i < 2; ++i )
{
assertTrue( declarations.hasNext() );
IASTAbstractTypeSpecifierDeclaration abstractDeclaration = (IASTAbstractTypeSpecifierDeclaration)declarations.next();
IASTEnumerationSpecifier enumerationSpec = (IASTEnumerationSpecifier)abstractDeclaration.getTypeSpecifier();
if( i == 0 )
assertEquals( enumerationSpec.getName(), "" );
else
assertEquals( enumerationSpec.getName(), "hasAString" );
Iterator j = enumerationSpec.getEnumerators();
if( i == 0 )
{
IASTEnumerator enumerator1 = (IASTEnumerator)j.next();
assertEquals( enumerator1.getName(), "yo");
assertNull( enumerator1.getInitialValue() );
IASTEnumerator enumerator2 = (IASTEnumerator)j.next();
assertNotNull( enumerator2.getInitialValue() );
assertEquals( enumerator2.getInitialValue().getLiteralString(), "3");
assertEquals( enumerator2.getInitialValue().getExpressionKind(), IASTExpression.Kind.PRIMARY_INTEGER_LITERAL );
assertEquals( enumerator2.getName(), "go");
IASTEnumerator enumerator3 = (IASTEnumerator)j.next();
assertEquals( enumerator3.getName(), "away");
assertNull( enumerator3.getInitialValue() );
assertFalse( j.hasNext() );
}
else
{
IASTEnumerator enumerator2 = (IASTEnumerator)j.next();
assertNotNull( enumerator2.getInitialValue() );
assertEquals( enumerator2.getInitialValue().getLiteralString(), "666");
assertEquals( enumerator2.getInitialValue().getExpressionKind(), IASTExpression.Kind.PRIMARY_INTEGER_LITERAL );
assertEquals( enumerator2.getName(), "last");
assertFalse( j.hasNext() );
}
}
}
public void testTypedef() throws Exception
{
Iterator i = parse( "typedef const struct A * const cpStructA;").getDeclarations();
IASTTypedefDeclaration typedef = (IASTTypedefDeclaration)i.next();
assertFalse( i.hasNext() );
assertTrue( typedef.getAbstractDeclarator().isConst() );
assertTrue( typedef.getAbstractDeclarator().getTypeSpecifier() instanceof IASTElaboratedTypeSpecifier );
IASTElaboratedTypeSpecifier elab = (IASTElaboratedTypeSpecifier)typedef.getAbstractDeclarator().getTypeSpecifier();
assertEquals( elab.getName(), "A");
assertEquals( elab.getClassKind(), ASTClassKind.STRUCT );
assertTrue( typedef.getAbstractDeclarator().getPointerOperators().hasNext() );
Iterator pIter = (Iterator)typedef.getAbstractDeclarator().getPointerOperators();
ASTPointerOperator po =(ASTPointerOperator)pIter.next();
assertEquals( po, ASTPointerOperator.CONST_POINTER );
assertFalse( pIter.hasNext() );
assertEquals( typedef.getName(), "cpStructA");
}
public void testUsingClauses() throws Exception
{
Writer code = new StringWriter();
code.write("using namespace A::B::C;\n");
code.write("using namespace C;\n");
code.write("using B::f;\n");
code.write("using ::f;\n");
code.write("using typename crap::de::crap;");
Iterator declarations = parse(code.toString()).getDeclarations();
IASTUsingDirective usingDirective = (IASTUsingDirective)declarations.next();
assertEquals( usingDirective.getNamespaceName(), "A::B::C" );
usingDirective = (IASTUsingDirective)declarations.next();
assertEquals( usingDirective.getNamespaceName(), "C" );
IASTUsingDeclaration usingDeclaration = (IASTUsingDeclaration)declarations.next();
assertEquals( usingDeclaration.usingTypeName(), "B::f" );
usingDeclaration = (IASTUsingDeclaration)declarations.next();
assertEquals( usingDeclaration.usingTypeName(), "::f" );
usingDeclaration = (IASTUsingDeclaration)declarations.next();
assertEquals( usingDeclaration.usingTypeName(), "crap::de::crap" );
assertTrue( usingDeclaration.isTypename() );
assertFalse( declarations.hasNext());
}
/**
* Test code: class A : public B, private C, virtual protected D { public: int x, y; float a,b,c; }
* Purpose: tests a declaration in a class scope.
*/
public void testSimpleClassMembers() throws Exception {
// Parse and get the translaton unit
Writer code = new StringWriter();
code.write("class A : public B, private C, virtual protected D { public: int x, y; float a,b,c; };");
Iterator declarations = parse( code.toString() ).getDeclarations();
IASTClassSpecifier classSpec = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)declarations.next()).getTypeSpecifier();
assertFalse( declarations.hasNext() );
Iterator baseClauses = classSpec.getBaseClauses();
IASTBaseSpecifier baseSpec = (IASTBaseSpecifier)baseClauses.next();
assertEquals( baseSpec.getParentClassName(), "B" );
assertEquals( baseSpec.getAccess(), ASTAccessVisibility.PUBLIC );
baseSpec = (IASTBaseSpecifier)baseClauses.next();
assertEquals( baseSpec.getParentClassName(), "C" );
assertEquals( baseSpec.getAccess(), ASTAccessVisibility.PRIVATE);
baseSpec = (IASTBaseSpecifier)baseClauses.next();
assertEquals( baseSpec.getAccess(), ASTAccessVisibility.PROTECTED );
assertTrue( baseSpec.isVirtual() );
assertEquals( baseSpec.getParentClassName(), "D" );
assertFalse( baseClauses.hasNext() );
Iterator members = classSpec.getDeclarations();
IASTField field = (IASTField)members.next();
assertEquals( ((IASTSimpleTypeSpecifier)field.getAbstractDeclaration().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.INT );
assertEquals( field.getName(), "x" );
field = (IASTField)members.next();
assertEquals( ((IASTSimpleTypeSpecifier)field.getAbstractDeclaration().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.INT );
assertEquals( field.getName(), "y" );
field = (IASTField)members.next();
assertEquals( ((IASTSimpleTypeSpecifier)field.getAbstractDeclaration().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.FLOAT );
assertEquals( field.getName(), "a" );
field = (IASTField)members.next();
assertEquals( ((IASTSimpleTypeSpecifier)field.getAbstractDeclaration().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.FLOAT );
assertEquals( field.getName(), "b" );
field = (IASTField)members.next();
assertEquals( ((IASTSimpleTypeSpecifier)field.getAbstractDeclaration().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.FLOAT );
assertEquals( field.getName(), "c" );
assertFalse( members.hasNext() );
}
/**
* Test code: int myFunction( void );
*/
public void testSimpleFunctionDeclaration() throws Exception
{
// Parse and get the translaton unit
Writer code = new StringWriter();
code.write("void myFunction( void );");
Iterator declarations = parse( code.toString()).getDeclarations();
IASTFunction f1 = (IASTFunction)declarations.next();
assertFalse( declarations.hasNext() );
assertEquals( f1.getName(), "myFunction");
assertEquals( ((IASTSimpleTypeSpecifier)f1.getReturnType().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.VOID );
Iterator parameters = f1.getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parameters.next();
assertFalse( parameters.hasNext() );
assertEquals( parm.getName(), "" );
assertEquals( ((IASTSimpleTypeSpecifier)parm.getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.VOID );
}
/**
* Test code: bool myFunction( int parm1 = 3 * 4, double parm2 );
* @throws Exception
*/
public void testFunctionDeclarationWithParameters() throws Exception
{
// Parse and get the translaton unit
Writer code = new StringWriter();
code.write("bool myFunction( int parm1 = 3 * 4, double parm2 );");
Iterator declarations = parse(code.toString()).getDeclarations();
IASTFunction f1 = (IASTFunction)declarations.next();
assertFalse( declarations.hasNext() );
assertEquals( f1.getName(), "myFunction");
assertEquals( ((IASTSimpleTypeSpecifier)f1.getReturnType().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.BOOL );
Iterator parameters = f1.getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parameters.next();
assertEquals( parm.getName(), "parm1" );
assertEquals( ((IASTSimpleTypeSpecifier)parm.getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.INT );
assertEquals( parm.getDefaultValue().getAssigmentExpression().getExpressionKind(), IASTExpression.Kind.MULTIPLICATIVE_MULTIPLY );
parm = (IASTParameterDeclaration)parameters.next();
assertEquals( parm.getName(), "parm2" );
assertEquals( ((IASTSimpleTypeSpecifier)parm.getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.DOUBLE );
assertNull( parm.getDefaultValue() );
assertFalse( parameters.hasNext());
}
public void testAssignmentExpressions() throws Exception
{
parse( "int x = y = z = 5;");
}
public void testBug39348() throws Exception
{
parse("unsigned char a[sizeof (struct sss)];");
}
public void testBug39501() throws Exception
{
parse("struct A { A() throw (int); };");
}
public void testBug39349() throws Exception
{
parse( "enum foo { foo1 = 0, foo2 = 0xffffffffffffffffULL, foo3 = 0xf0fffffffffffffeLLU };" );
}
public void testBug39544() throws Exception {
parse("wchar_t wc = L'X';");
}
public void testBug36290() throws Exception {
parse("typedef void ( A:: * pMethod ) ( void ); ");
parse("typedef void (boo) ( void ); ");
parse("typedef void boo (void); ");
}
public void testBug36769B() throws Exception {
parse("class X { operator int(); } \n");
parse("class X { operator int*(); } \n");
parse("class X { operator int&(); } \n");
parse("class X { operator A(); } \n");
parse("class X { operator A*(); } \n");
parse("class X { operator A&(); } \n");
parse("X::operator int() { } \n");
parse("X::operator int*() { } \n");
parse("X::operator int&() { } \n");
parse("X::operator A() { } \n");
parse("X::operator A*() { } \n");
parse("X::operator A&() { } \n");
parse("template <class A,B> class X<A,C> { operator int(); } \n");
parse("template <class A,B> class X<A,C> { operator int*(); } \n");
parse("template <class A,B> class X<A,C> { operator int&(); } \n");
parse("template <class A,B> class X<A,C> { operator A(); } \n");
parse("template <class A,B> class X<A,C> { operator A*(); } \n");
parse("template <class A,B> class X<A,C> { operator A&(); } \n");
parse("template <class A,B> X<A,C>::operator int() { } \n");
parse("template <class A,B> X<A,C>::operator int*() { } \n");
parse("template <class A,B> X<A,C>::operator int&() { } \n");
parse("template <class A,B> X<A,C>::operator A() { } \n");
parse("template <class A,B> X<A,C>::operator A*() { } \n");
parse("template <class A,B> X<A,C>::operator A&() { } \n");
}
public void testBug36932C() throws Exception {
parse("X::X( ) : var( new int ) {}");
parse("X::X( ) : var( new int(5) ) {}");
parse("X::X( ) : var( new int(B) ) {}");
parse("X::X( ) : var( new int(B,C) ) {}");
parse("X::X( ) : var( new int[5] ) {}");
parse("X::X( ) : var( new int[5][10] ) {}");
parse("X::X( ) : var( new int[B] ) {}");
parse("X::X( ) : var( new int[B][C][D] ) {}");
parse("X::X( ) : var( new A ) {}");
parse("X::X( ) : var( new A(5) ) {}");
parse("X::X( ) : var( new A(B) ) {}");
parse("X::X( ) : var( new A(B,C) ) {}");
parse("X::X( ) : var( new A[5] ) {}");
parse("X::X( ) : var( new A[5][10] ) {}");
parse("X::X( ) : var( new A[B] ) {}");
parse("X::X( ) : var( new A[B][C][D] ) {}");
parse("X::X( ) : var( new (int) ) {}");
parse("X::X( ) : var( new (int)(5) ) {}");
parse("X::X( ) : var( new (int)(B) ) {}");
parse("X::X( ) : var( new (int)(B,C) ) {}");
parse("X::X( ) : var( new (int)[5] ) {}");
parse("X::X( ) : var( new (int)[5][10] ) {}");
parse("X::X( ) : var( new (int)[B] ) {}");
parse("X::X( ) : var( new (int)[B][C][D] ) {}");
parse("X::X( ) : var( new (A) ) {}");
parse("X::X( ) : var( new (A)(5) ) {}");
parse("X::X( ) : var( new (A)(B) ) {}");
parse("X::X( ) : var( new (A)(B,C) ) {}");
parse("X::X( ) : var( new (A)[5] ) {}");
parse("X::X( ) : var( new (A)[5][10] ) {}");
parse("X::X( ) : var( new (A)[B] ) {}");
parse("X::X( ) : var( new (A)[B][C][D] ) {}");
parse("X::X( ) : var( new (0) int ) {}");
parse("X::X( ) : var( new (0) int(5) ) {}");
parse("X::X( ) : var( new (0) int(B) ) {}");
parse("X::X( ) : var( new (0) int(B,C) ) {}");
parse("X::X( ) : var( new (0) int[5] ) {}");
parse("X::X( ) : var( new (0) int[5][10] ) {}");
parse("X::X( ) : var( new (0) int[B] ) {}");
parse("X::X( ) : var( new (0) int[B][C][D] ) {}");
parse("X::X( ) : var( new (0) A ) {}");
parse("X::X( ) : var( new (0) A(5) ) {}");
parse("X::X( ) : var( new (0) A(B) ) {}");
parse("X::X( ) : var( new (0) A(B,C) ) {}");
parse("X::X( ) : var( new (0) A[5] ) {}");
parse("X::X( ) : var( new (0) A[5][10] ) {}");
parse("X::X( ) : var( new (0) A[B] ) {}");
parse("X::X( ) : var( new (0) A[B][C][D] ) {}");
parse("X::X( ) : var( new (0) (int) ) {}");
parse("X::X( ) : var( new (0) (int)(5) ) {}");
parse("X::X( ) : var( new (0) (int)(B) ) {}");
parse("X::X( ) : var( new (0) (int)(B,C) ) {}");
parse("X::X( ) : var( new (0) (int)[5] ) {}");
parse("X::X( ) : var( new (0) (int)[5][10] ) {}");
parse("X::X( ) : var( new (0) (int)[B] ) {}");
parse("X::X( ) : var( new (0) (int)[B][C][D] ) {}");
parse("X::X( ) : var( new (0) (A) ) {}");
parse("X::X( ) : var( new (0) (A)(5) ) {}");
parse("X::X( ) : var( new (0) (A)(B) ) {}");
parse("X::X( ) : var( new (0) (A)(B,C) ) {}");
parse("X::X( ) : var( new (0) (A)[5] ) {}");
parse("X::X( ) : var( new (0) (A)[5][10] ) {}");
parse("X::X( ) : var( new (0) (A)[B] ) {}");
parse("X::X( ) : var( new (0) (A)[B][C][D] ) {}");
parse("X::X( ) : var( new (P) int ) {}");
parse("X::X( ) : var( new (P) int(5) ) {}");
parse("X::X( ) : var( new (P) int(B) ) {}");
parse("X::X( ) : var( new (P) int(B,C) ) {}");
parse("X::X( ) : var( new (P) int[5] ) {}");
parse("X::X( ) : var( new (P) int[5][10] ) {}");
parse("X::X( ) : var( new (P) int[B] ) {}");
parse("X::X( ) : var( new (P) int[B][C][D] ) {}");
parse("X::X( ) : var( new (P) A ) {}");
parse("X::X( ) : var( new (P) A(5) ) {}");
parse("X::X( ) : var( new (P) A(B) ) {}");
parse("X::X( ) : var( new (P) A(B,C) ) {}");
parse("X::X( ) : var( new (P) A[5] ) {}");
parse("X::X( ) : var( new (P) A[5][10] ) {}");
parse("X::X( ) : var( new (P) A[B] ) {}");
parse("X::X( ) : var( new (P) A[B][C][D] ) {}");
parse("X::X( ) : var( new (P) (int) ) {}");
parse("X::X( ) : var( new (P) (int)(5) ) {}");
parse("X::X( ) : var( new (P) (int)(B) ) {}");
parse("X::X( ) : var( new (P) (int)(B,C) ) {}");
parse("X::X( ) : var( new (P) (int)[5] ) {}");
parse("X::X( ) : var( new (P) (int)[5][10] ) {}");
parse("X::X( ) : var( new (P) (int)[B] ) {}");
parse("X::X( ) : var( new (P) (int)[B][C][D] ) {}");
parse("X::X( ) : var( new (P) (A) ) {}");
parse("X::X( ) : var( new (P) (A)(5) ) {}");
parse("X::X( ) : var( new (P) (A)(B) ) {}");
parse("X::X( ) : var( new (P) (A)(B,C) ) {}");
parse("X::X( ) : var( new (P) (A)[5] ) {}");
parse("X::X( ) : var( new (P) (A)[5][10] ) {}");
parse("X::X( ) : var( new (P) (A)[B] ) {}");
parse("X::X( ) : var( new (P) (A)[B][C][D] ) {}");
}
public void testBugSingleton192() throws Exception {
parse("int Test::* pMember_;" );
}
public void testBug36931() throws Exception {
parse("A::nested::nested(){}; ");
parse("int A::nested::foo() {} ");
parse("int A::nested::operator+() {} ");
parse("A::nested::operator int() {} ");
parse("static const int A::nested::i = 1; ");
parse("template <class B,C> A<B>::nested::nested(){}; ");
parse("template <class B,C> int A::nested<B,D>::foo() {} ");
parse("template <class B,C> int A<B,C>::nested<C,B>::operator+() {} ");
parse("template <class B,C> A::nested::operator int() {} ");
}
public void testBug37019() throws Exception {
parse("static const A a( 1, 0 );");
}
public void testBug36766and36769A() throws Exception {
Writer code = new StringWriter();
code.write("template <class _CharT, class _Alloc>\n");
code.write("rope<_CharT, _Alloc>::rope(size_t __n, _CharT __c,\n");
code.write("const allocator_type& __a): _Base(__a)\n");
code.write("{}\n");
parse(code.toString());
}
public void testBug36766and36769B() throws Exception {
Writer code = new StringWriter();
code.write("template<class _CharT>\n");
code.write("bool _Rope_insert_char_consumer<_CharT>::operator()\n");
code.write("(const _CharT* __leaf, size_t __n)\n");
code.write("{}\n");
parse(code.toString());
}
public void testBug36766and36769C() throws Exception {
Writer code = new StringWriter();
code.write("template <class _CharT, class _Alloc>\n");
code.write("_Rope_char_ref_proxy<_CharT, _Alloc>&\n");
code.write(
"_Rope_char_ref_proxy<_CharT, _Alloc>::operator= (_CharT __c)\n");
code.write("{}\n");
parse(code.toString());
}
public void testBug36766and36769D() throws Exception {
Writer code = new StringWriter();
code.write("template <class _CharT, class _Alloc>\n");
code.write("rope<_CharT, _Alloc>::~rope()\n");
code.write("{}\n");
parse(code.toString());
}
public void testBug36932A() throws Exception {
parse("A::A( ) : var( new char [ (unsigned)bufSize ] ) {}");
}
public void testBug36932B() throws Exception {
parse(" p = new int; ");
parse(" p = new int(5); ");
parse(" p = new int(B); ");
parse(" p = new int(B,C); ");
parse(" p = new int[5]; ");
parse(" p = new int[5][10]; ");
parse(" p = new int[B]; ");
parse(" p = new int[B][C][D]; ");
parse(" p = new A; ");
parse(" p = new A(5); ");
parse(" p = new A(B); ");
parse(" p = new A(B,C); ");
parse(" p = new A[5]; ");
parse(" p = new A[5][10]; ");
parse(" p = new A[B]; ");
parse(" p = new A[B][C][D]; ");
parse(" p = new (int); ");
parse(" p = new (int)(5); ");
parse(" p = new (int)(B); ");
parse(" p = new (int)(B,C); ");
parse(" p = new (int)[5]; ");
parse(" p = new (int)[5][10]; ");
parse(" p = new (int)[B]; ");
parse(" p = new (int)[B][C][D]; ");
parse(" p = new (A); ");
parse(" p = new (A)(5); ");
parse(" p = new (A)(B); ");
parse(" p = new (A)(B,C); ");
parse(" p = new (A)[5]; ");
parse(" p = new (A)[5][10]; ");
parse(" p = new (A)[B]; ");
parse(" p = new (A)[B][C][D]; ");
parse(" p = new (0) int; ");
parse(" p = new (0) int(5); ");
parse(" p = new (0) int(B); ");
parse(" p = new (0) int(B,C); ");
parse(" p = new (0) int[5]; ");
parse(" p = new (0) int[5][10]; ");
parse(" p = new (0) int[B]; ");
parse(" p = new (0) int[B][C][D]; ");
parse(" p = new (0) A; ");
parse(" p = new (0) A(5); ");
parse(" p = new (0) A(B); ");
parse(" p = new (0) A(B,C); ");
parse(" p = new (0) A[5]; ");
parse(" p = new (0) A[5][10]; ");
parse(" p = new (0) A[B]; ");
parse(" p = new (0) A[B][C][D]; ");
parse(" p = new (0) (int); ");
parse(" p = new (0) (int)(5); ");
parse(" p = new (0) (int)(B); ");
parse(" p = new (0) (int)(B,C); ");
parse(" p = new (0) (int)[5]; ");
parse(" p = new (0) (int)[5][10]; ");
parse(" p = new (0) (int)[B]; ");
parse(" p = new (0) (int)[B][C][D]; ");
parse(" p = new (0) (A); ");
parse(" p = new (0) (A)(5); ");
parse(" p = new (0) (A)(B); ");
parse(" p = new (0) (A)(B,C); ");
parse(" p = new (0) (A)[5]; ");
parse(" p = new (0) (A)[5][10]; ");
parse(" p = new (0) (A)[B]; ");
parse(" p = new (0) (A)[B][C][D]; ");
parse(" p = new (P) int; ");
parse(" p = new (P) int(5); ");
parse(" p = new (P) int(B); ");
parse(" p = new (P) int(B,C); ");
parse(" p = new (P) int[5]; ");
parse(" p = new (P) int[5][10]; ");
parse(" p = new (P) int[B]; ");
parse(" p = new (P) int[B][C][D]; ");
parse(" p = new (P) A; ");
parse(" p = new (P) A(5); ");
parse(" p = new (P) A(B); ");
parse(" p = new (P) A(B,C); ");
parse(" p = new (P) A[5]; ");
parse(" p = new (P) A[5][10]; ");
parse(" p = new (P) A[B]; ");
parse(" p = new (P) A[B][C][D]; ");
parse(" p = new (P) (int); ");
parse(" p = new (P) (int)(5); ");
parse(" p = new (P) (int)(B); ");
parse(" p = new (P) (int)(B,C); ");
parse(" p = new (P) (int)[5]; ");
parse(" p = new (P) (int)[5][10]; ");
parse(" p = new (P) (int)[B]; ");
parse(" p = new (P) (int)[B][C][D]; ");
parse(" p = new (P) (A); ");
parse(" p = new (P) (A)(5); ");
parse(" p = new (P) (A)(B); ");
parse(" p = new (P) (A)(B,C); ");
parse(" p = new (P) (A)[5]; ");
parse(" p = new (P) (A)[5][10]; ");
parse(" p = new (P) (A)[B]; ");
parse(" p = new (P) (A)[B][C][D]; ");
}
public void testBug36769A() throws Exception {
Writer code = new StringWriter();
code.write("template <class A, B> cls<A, C>::operator op &() const {}\n");
code.write("template <class A, B> cls<A, C>::cls() {}\n");
code.write("template <class A, B> cls<A, C>::~cls() {}\n");
parse( code.toString());
}
public void testBug36714() throws Exception {
Writer code = new StringWriter();
code.write("unsigned long a = 0UL;\n");
code.write("unsigned long a2 = 0L; \n");
parse( code.toString() );
}
public void testBugFunctor758() throws Exception {
parse( "template <typename Fun> Functor(Fun fun) : spImpl_(new FunctorHandler<Functor, Fun>(fun)){}" );
}
public void testBug36932() throws Exception
{
parse( "A::A(): b( new int( 5 ) ), b( new B ), c( new int ) {}" );
}
public void testBug36704() throws Exception {
Writer code = new StringWriter();
code.write( "template <class T, class U>\n" );
code.write( "struct Length< Typelist<T, U> >\n" );
code.write( "{\n" );
code.write( "enum { value = 1 + Length<U>::value };\n" );
code.write( "};\n" );
parse(code.toString());
}
public void testBug36699() throws Exception {
Writer code = new StringWriter();
code.write(
"template < template <class> class ThreadingModel = DEFAULT_THREADING,\n");
code.write("std::size_t chunkSize = DEFAULT_CHUNK_SIZE,\n");
code.write(
"std::size_t maxSmallObjectSize = MAX_SMALL_OBJECT_SIZE >\n");
code.write("class SmallObject : public ThreadingModel<\n");
code.write(
"SmallObject<ThreadingModel, chunkSize, maxSmallObjectSize> >\n");
code.write("{};\n");
parse(code.toString());
}
public void testBug36691() throws Exception {
Writer code = new StringWriter();
code.write("template <class T, class H>\n");
code.write(
"typename H::template Rebind<T>::Result& Field(H& obj)\n");
code.write("{ return obj; }\n");
parse(code.toString());
}
public void testBug39554() throws Exception
{
parse("_Pragma(\"foobar\")", true, true, ParserLanguage.C );
}
public void testBug36702() throws Exception
{
Writer code = new StringWriter();
code.write( "void mad_decoder_init(struct mad_decoder *, void *,\n" );
code.write( " enum mad_flow (*)(void *, struct mad_stream *),\n" );
code.write( " enum mad_flow (*)(void *, struct mad_header const *),\n" );
code.write( " enum mad_flow (*)(void *,\n" );
code.write( " struct mad_stream const *,\n" );
code.write( " struct mad_frame *),\n" );
code.write( " enum mad_flow (*)(void *,\n" );
code.write( " struct mad_header const *,\n" );
code.write( " struct mad_pcm *),\n" );
code.write( " enum mad_flow (*)(void *,\n" );
code.write( " struct mad_stream *,\n" );
code.write( " struct mad_frame *),\n" );
code.write( " enum mad_flow (*)(void *, void *, unsigned int *)\n" );
code.write( ");\n" );
parse( code.toString() );
}
public void testBug36852() throws Exception
{
Writer code = new StringWriter();
code.write( "int CBT::senseToAllRect( double id_standardQuot = DOSE, double id_minToleranz =15.0,\n" );
code.write( "double id_maxToleranz = 15.0, unsigned int iui_minY = 0, \n" );
code.write( "unsigned int iui_maxY = HEIGHT );\n" );
parse( code.toString() );
}
public void testBug36689() throws Exception {
Writer code = new StringWriter();
code.write("template\n");
code.write("<\n");
code.write("class AbstractFact,\n");
code.write(
"template <class, class> class Creator = OpNewFactoryUnit,\n");
code.write("class TList = typename AbstractFact::ProductList\n");
code.write(">\n");
code.write("class ConcreteFactory\n");
code.write(": public GenLinearHierarchy<\n");
code.write(
"typename TL::Reverse<TList>::Result, Creator, AbstractFact>\n");
code.write("{\n");
code.write("public:\n");
code.write(
"typedef typename AbstractFact::ProductList ProductList;\n");
code.write("typedef TList ConcreteProductList;\n");
code.write("};\n");
parse(code.toString());
}
public void testBug36707() throws Exception {
parse("enum { exists = sizeof(typename H::Small) == sizeof((H::Test(H::MakeT()))) };");
}
public void testBug36717() throws Exception {
parse("enum { eA = A::b };");
}
public void testBug36693() throws Exception {
parse("FixedAllocator::Chunk* FixedAllocator::VicinityFind(void* p){}");
}
public void testWeirdExpression() throws Exception
{
parse( "int x = rhs.spImpl_.get();");
}
public void testBug36696() throws Exception {
Writer code = new StringWriter();
code.write(
"template <typename P1> RefCounted(const RefCounted<P1>& rhs)\n");
code.write(
": pCount_(reinterpret_cast<const RefCounted&>(rhs).pCount_) {}\n");
parse(code.toString());
}
public void testArrayOfPointerToFunctions() throws Exception
{
parse( "unsigned char (*main_data)[MAD_BUFFER_MDLEN];");
}
public void testBug36073() throws Exception
{
StringWriter writer = new StringWriter();
writer.write( "class A{\n" );
writer.write( "int x;\n" );
writer.write( "public:\n" );
writer.write( "A(const A&);\n" );
writer.write( "};\n" );
writer.write( "A::A(const A&v) : x(v.x) { }\n" );
parse( writer.toString() );
}
public void testTemplateSpecialization() throws Exception
{
Iterator declarations = parse( "template<> class stream<char> { /* ... */ };").getDeclarations();
IASTClassSpecifier specifier = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)((IASTTemplateSpecialization)declarations.next()).getOwnedDeclaration()).getTypeSpecifier();
assertFalse( declarations.hasNext());
assertEquals( specifier.getName(), "stream<char>");
assertFalse( specifier.getDeclarations().hasNext() );
}
public void testTemplateInstantiation() throws Exception
{
Iterator declarations = parse( "template class Array<char>;").getDeclarations();
IASTElaboratedTypeSpecifier specifier = (IASTElaboratedTypeSpecifier)((IASTAbstractTypeSpecifierDeclaration)((IASTTemplateInstantiation)declarations.next()).getOwnedDeclaration()).getTypeSpecifier();
assertFalse( declarations.hasNext() );
assertEquals( specifier.getName(), "Array<char>");
assertEquals( specifier.getClassKind(), ASTClassKind.CLASS );
}
/**
* Test code: "class A { int floor( double input ), someInt; };"
*/
public void testMultipleDeclarators() throws Exception
{
// Parse and get the translaton unit
Iterator declarations = parse("class A { int floor( double input ), someInt; };").getDeclarations();
Iterator members = ((IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)declarations.next()).getTypeSpecifier()).getDeclarations();
assertFalse( declarations.hasNext() );
IASTMethod decl1 = (IASTMethod)members.next();
assertEquals( ((IASTSimpleTypeSpecifier)decl1.getReturnType().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.INT );
Iterator parameters = decl1.getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parameters.next();
assertEquals( ((IASTSimpleTypeSpecifier)parm.getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.DOUBLE );
assertFalse( parameters.hasNext());
assertEquals( parm.getName(), "input");
IASTField decl2 = (IASTField)members.next();
assertEquals( decl2.getName(), "someInt");
assertEquals( ((IASTSimpleTypeSpecifier)decl2.getAbstractDeclaration().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.INT );
assertFalse( members.hasNext());
}
public void testFunctionModifiers() throws Exception
{
Iterator declarations = parse( "class A {virtual void foo( void ) const throw ( yay, nay, we::dont::care ) = 0;};").getDeclarations();
IASTClassSpecifier classSpec = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)declarations.next()).getTypeSpecifier();
assertFalse( declarations.hasNext());
Iterator members = classSpec.getDeclarations();
IASTMethod method = (IASTMethod)members.next();
assertFalse( members.hasNext() );
assertTrue( method.isVirtual());
assertEquals( method.getName(), "foo");
assertEquals( ((IASTSimpleTypeSpecifier)method.getReturnType().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.VOID );
Iterator parameters = method.getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parameters.next();
assertEquals( ((IASTSimpleTypeSpecifier)parm.getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.VOID );
assertFalse( parameters.hasNext());
assertEquals( parm.getName(), "");
assertTrue( method.isConst() );
assertTrue( method.isPureVirtual() );
assertNotNull( method.getExceptionSpec() );
Iterator exceptions = method.getExceptionSpec().getTypeIds();
assertEquals( (String)exceptions.next(), "yay");
assertEquals( (String)exceptions.next(), "nay");
assertEquals( (String)exceptions.next(), "we::dont::care");
assertFalse( exceptions.hasNext() );
}
public void testArrays() throws Exception
{
Iterator declarations = parse("int x [5][];").getDeclarations();
IASTVariable x = (IASTVariable)declarations.next();
assertFalse( declarations.hasNext() );
assertEquals( ((IASTSimpleTypeSpecifier)x.getAbstractDeclaration().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.INT );
assertEquals( x.getName(), "x");
Iterator arrayMods = x.getAbstractDeclaration().getArrayModifiers();
IASTArrayModifier mod = (IASTArrayModifier)arrayMods.next();
assertEquals( mod.getExpression().getExpressionKind(), IASTExpression.Kind.PRIMARY_INTEGER_LITERAL );
assertEquals( mod.getExpression().getLiteralString(), "5" );
mod = (IASTArrayModifier)arrayMods.next();
assertNull( mod.getExpression());
assertFalse( arrayMods.hasNext() );
}
public void testElaboratedParms() throws Exception
{
Iterator declarations = parse( "int x( struct A myA ) { /* junk */ }" ).getDeclarations();
IASTFunction f = (IASTFunction)declarations.next();
assertSimpleReturnType( f, IASTSimpleTypeSpecifier.Type.INT );
Iterator parms = f.getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parms.next();
assertFalse( parms.hasNext());
assertEquals( parm.getName(), "myA");
assertEquals( ((IASTElaboratedTypeSpecifier)parm.getTypeSpecifier()).getName(), "A" );
assertEquals( ((IASTElaboratedTypeSpecifier)parm.getTypeSpecifier()).getClassKind(), ASTClassKind.STRUCT );
assertFalse( declarations.hasNext());
}
public void testMemberDeclarations() throws Exception
{
Writer code = new StringWriter();
code.write( "class A {\n" );
code.write( "public:\n");
code.write( " int is0;\n" );
code.write( "private:\n");
code.write( " int is1;\n" );
code.write( "protected:\n");
code.write( " int is2;\n" );
code.write( "};");
Iterator declarations = parse( code.toString()).getDeclarations();
IASTClassSpecifier classSpec = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)declarations.next()).getTypeSpecifier();
assertFalse(declarations.hasNext());
Iterator members = classSpec.getDeclarations();
for( int i = 0; i < 3; ++i )
{
IASTField field = (IASTField)members.next();
assertEquals( field.getName(), "is"+ new Integer( i ).toString());
ASTAccessVisibility visibility = null;
switch( i )
{
case 0:
visibility = ASTAccessVisibility.PUBLIC;
break;
case 1:
visibility = ASTAccessVisibility.PRIVATE;
break;
default:
visibility = ASTAccessVisibility.PROTECTED;
break;
}
assertEquals( field.getVisiblity(), visibility );
}
assertFalse( members.hasNext());
}
public void testPointerOperators() throws Exception
{
Iterator declarations = parse("int * x = 0, & y, * const * volatile * z;").getDeclarations();
for( int i = 0; i < 3; ++i )
{
IASTVariable v = (IASTVariable)declarations.next();
assertSimpleType( v, IASTSimpleTypeSpecifier.Type.INT );
Iterator pointerOperators = v.getAbstractDeclaration().getPointerOperators();
ASTPointerOperator pointerOp = (ASTPointerOperator)pointerOperators.next();
switch( i )
{
case 0:
assertEquals( v.getName(), "x");
assertEquals( pointerOp, ASTPointerOperator.POINTER );
assertFalse( pointerOperators.hasNext());
break;
case 1:
assertEquals( v.getName(), "y");
assertEquals( pointerOp, ASTPointerOperator.REFERENCE);
assertFalse( pointerOperators.hasNext());
break;
case 2:
assertEquals( v.getName(), "z");
assertEquals( pointerOp, ASTPointerOperator.CONST_POINTER );
assertEquals( pointerOperators.next(), ASTPointerOperator.VOLATILE_POINTER );
assertEquals( pointerOperators.next(), ASTPointerOperator.POINTER );
assertFalse( pointerOperators.hasNext());
break;
}
}
assertFalse( declarations.hasNext() );
}
public void testBug26467() throws Exception
{
StringWriter code = new StringWriter();
code.write( "struct foo { int fooInt; char fooChar; };\n" );
code.write( "typedef struct foo fooStruct;\n" );
code.write( "typedef struct { int anonInt; char anonChar; } anonStruct;\n" );
Iterator declarations = parse( code.toString()).getDeclarations();
IASTClassSpecifier classSpec = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)declarations.next()).getTypeSpecifier();
assertEquals( classSpec.getClassKind(), ASTClassKind.STRUCT);
assertEquals( classSpec.getName(), "foo" );
Iterator members = classSpec.getDeclarations();
IASTField field = (IASTField)members.next();
assertSimpleType(field, IASTSimpleTypeSpecifier.Type.INT );
assertEquals( field.getName(), "fooInt");
field = (IASTField)members.next();
assertSimpleType(field, IASTSimpleTypeSpecifier.Type.CHAR );
assertEquals( field.getName(), "fooChar");
assertFalse( members.hasNext());
IASTTypedefDeclaration firstTypeDef = (IASTTypedefDeclaration)declarations.next();
assertEquals( ((IASTElaboratedTypeSpecifier)firstTypeDef.getAbstractDeclarator().getTypeSpecifier()).getClassKind(), ASTClassKind.STRUCT );
assertEquals( ((IASTElaboratedTypeSpecifier)firstTypeDef.getAbstractDeclarator().getTypeSpecifier()).getName(), "foo");
assertEquals( firstTypeDef.getName(), "fooStruct");
IASTTypedefDeclaration secondTypeDef = (IASTTypedefDeclaration)declarations.next();
classSpec = (IASTClassSpecifier)secondTypeDef.getAbstractDeclarator().getTypeSpecifier();
assertEquals( classSpec.getClassKind(), ASTClassKind.STRUCT);
assertEquals( classSpec.getName(), "" );
members = classSpec.getDeclarations();
field = (IASTField)members.next();
assertSimpleType(field, IASTSimpleTypeSpecifier.Type.INT );
assertEquals( field.getName(), "anonInt");
field = (IASTField)members.next();
assertSimpleType(field, IASTSimpleTypeSpecifier.Type.CHAR );
assertEquals( field.getName(), "anonChar");
assertFalse( members.hasNext());
assertEquals( secondTypeDef.getName(), "anonStruct");
}
public void testASMDefinition() throws Exception
{
Iterator declarations = parse( "asm( \"mov ep1 ds2\");" ).getDeclarations();
IASTASMDefinition asm = (IASTASMDefinition)declarations.next();
assertFalse( declarations.hasNext());
assertEquals( asm.getBody(), "mov ep1 ds2");
}
public void testConstructorChain() throws Exception
{
Iterator declarations = parse( "TrafficLight_Actor::TrafficLight_Actor( RTController * rtg_rts, RTActorRef * rtg_ref ) : RTActor( rtg_rts, rtg_ref ), myId( 0 ) {}" ).getDeclarations();
declarations.next(); // cannot properly do this test now with new callback structure in quickparse mode
}
public void testBug36237() throws Exception
{
parse( "A::A():B( (char *)0 ){}" );
}
public void testBug36532() throws Exception
{
try
{
parse( "template<int f() {\n" );
fail( "We should not make it this far");
}
catch( ParserException pe )
{
}
catch( Exception e )
{
fail( "We should have gotten a ParserException rather than" + e);
}
}
public void testPreprocessor() throws Exception
{
Writer code = new StringWriter();
code.write( "#include <stdio.h>\n#define DEF VALUE\n");
IASTCompilationUnit tu = parse( code.toString() );
assertFalse( tu.getDeclarations().hasNext());
Iterator inclusions = quickParseCallback.getInclusions();
Iterator macros = quickParseCallback.getMacros();
IASTInclusion i = (IASTInclusion)inclusions.next();
assertFalse( inclusions.hasNext());
assertEquals( i.getName(), "stdio.h");
assertEquals( i.getStartingOffset(), 0 );
assertEquals( i.getNameOffset(), 10 );
assertEquals( i.getEndingOffset(), 19 );
IASTMacro m = (IASTMacro)macros.next();
assertEquals( m.getName(), "DEF" );
assertEquals( m.getStartingOffset(), 19 );
assertEquals( m.getNameOffset(), 27 );
assertEquals( m.getEndingOffset(), 18 + 19);
}
public void testTemplateDeclarationOfFunction() throws Exception
{
Iterator declarations = parse( "template<class A, typename B=C> A aTemplatedFunction( B bInstance );").getDeclarations();
IASTTemplateDeclaration templateDeclaration = (IASTTemplateDeclaration)declarations.next();
assertFalse( declarations.hasNext());
Iterator templateParms = templateDeclaration.getTemplateParameters();
IASTTemplateParameter parm = (IASTTemplateParameter)templateParms.next();
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.CLASS );
assertEquals( parm.getIdentifier(), "A");
parm = (IASTTemplateParameter)templateParms.next();
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.TYPENAME );
assertEquals( parm.getIdentifier(), "B");
assertEquals( parm.getDefaultValueIdExpression(), "C" );
IASTFunction f = (IASTFunction)templateDeclaration.getOwnedDeclaration();
assertEquals( f.getName(), "aTemplatedFunction" );
assertSimpleReturnType( f, IASTSimpleTypeSpecifier.Type.CLASS_OR_TYPENAME );
assertEquals( ((IASTSimpleTypeSpecifier)f.getReturnType().getTypeSpecifier()).getTypename(), "A" );
Iterator parameters = f.getParameters();
IASTParameterDeclaration parmDeclaration = (IASTParameterDeclaration)parameters.next();
assertFalse( parameters.hasNext() );
assertEquals( parmDeclaration.getName(), "bInstance");
assertEquals( ((IASTSimpleTypeSpecifier)parmDeclaration.getTypeSpecifier()).getType(),IASTSimpleTypeSpecifier.Type.CLASS_OR_TYPENAME );
assertEquals( ((IASTSimpleTypeSpecifier)parmDeclaration.getTypeSpecifier()).getTypename(), "B" );
}
public void testTemplateDeclarationOfClass() throws Exception {
Iterator declarations = parse( "template<class T, typename Tibor = junk, class, typename, int x, float y,template <class Y> class, template<class A> class AClass> class myarray { /* ... */ };").getDeclarations();
IASTTemplateDeclaration templateDeclaration = (IASTTemplateDeclaration)declarations.next();
assertFalse( declarations.hasNext());
Iterator templateParms = templateDeclaration.getTemplateParameters();
IASTTemplateParameter parm = (IASTTemplateParameter)templateParms.next();
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.CLASS );
assertEquals( parm.getIdentifier(), "T");
parm = (IASTTemplateParameter)templateParms.next();
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.TYPENAME );
assertEquals( parm.getIdentifier(), "Tibor");
assertEquals( parm.getDefaultValueIdExpression(), "junk");
parm = (IASTTemplateParameter)templateParms.next();
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.CLASS );
assertEquals( parm.getIdentifier(), "");
parm = (IASTTemplateParameter)templateParms.next();
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.TYPENAME );
assertEquals( parm.getIdentifier(), "");
parm = (IASTTemplateParameter)templateParms.next();
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.PARAMETER );
assertEquals( parm.getParameterDeclaration().getName(), "x");
assertEquals( ((IASTSimpleTypeSpecifier)parm.getParameterDeclaration().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.INT );
parm = (IASTTemplateParameter)templateParms.next();
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.PARAMETER );
assertEquals( parm.getParameterDeclaration().getName(), "y");
assertEquals( ((IASTSimpleTypeSpecifier)parm.getParameterDeclaration().getTypeSpecifier()).getType(), IASTSimpleTypeSpecifier.Type.FLOAT );
parm = (IASTTemplateParameter)templateParms.next();
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.TEMPLATE_LIST);
assertEquals( parm.getIdentifier(), "");
Iterator subParms = parm.getTemplateParameters();
parm = (IASTTemplateParameter)subParms.next();
assertFalse( subParms.hasNext() );
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.CLASS );
assertEquals( parm.getIdentifier(), "Y" );
parm = (IASTTemplateParameter)templateParms.next();
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.TEMPLATE_LIST);
assertEquals( parm.getIdentifier(), "AClass");
subParms = parm.getTemplateParameters();
parm = (IASTTemplateParameter)subParms.next();
assertFalse( subParms.hasNext() );
assertEquals( parm.getTemplateParameterKind(), IASTTemplateParameter.ParamKind.CLASS );
assertEquals( parm.getIdentifier(), "A" );
assertFalse( templateParms.hasNext() );
IASTClassSpecifier classSpec = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)templateDeclaration.getOwnedDeclaration()).getTypeSpecifier();
assertEquals( classSpec.getName(), "myarray");
assertFalse( classSpec.getDeclarations().hasNext() );
}
public void testBug35906() throws Exception
{
StringWriter code = new StringWriter();
code.write( "void TTest::MTest() {}\n" );
code.write( "struct TTest::STest *TTest::FTest (int i) {}\n" );
Iterator declarations = parse( code.toString() ).getDeclarations();
IASTFunction f = (IASTFunction)declarations.next();
assertEquals( f.getName(), "TTest::MTest");
assertSimpleReturnType( f, IASTSimpleTypeSpecifier.Type.VOID );
f = (IASTFunction)declarations.next();
assertFalse( declarations.hasNext());
assertEquals( f.getName(), "TTest::FTest");
assertEquals( ((IASTElaboratedTypeSpecifier)f.getReturnType().getTypeSpecifier()).getClassKind(), ASTClassKind.STRUCT );
assertEquals( ((IASTElaboratedTypeSpecifier)f.getReturnType().getTypeSpecifier()).getName(), "TTest::STest");
Iterator pointerOperators = f.getReturnType().getPointerOperators();
assertEquals( pointerOperators.next(), ASTPointerOperator.POINTER );
assertFalse( pointerOperators.hasNext() );
Iterator parameters = f.getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parameters.next();
assertFalse( parameters.hasNext() );
assertEquals( parm.getName(), "i");
assertParameterSimpleType( parm, IASTSimpleTypeSpecifier.Type.INT );
}
public void testBug36288() throws Exception
{
Iterator declarations = parse( "int foo() {}\nlong foo2(){}" ).getDeclarations();
IASTFunction f = (IASTFunction)declarations.next();
assertSimpleReturnType( f, IASTSimpleTypeSpecifier.Type.INT );
assertEquals( f.getName(), "foo");
f = (IASTFunction)declarations.next();
assertSimpleReturnType( f, IASTSimpleTypeSpecifier.Type.INT );
assertTrue( ((IASTSimpleTypeSpecifier)f.getReturnType().getTypeSpecifier()).isLong() );
assertEquals( f.getName(), "foo2");
assertFalse( declarations.hasNext() );
}
public void testBug36250() throws Exception
{
Iterator declarations = parse( "int f( int = 0 );").getDeclarations();
IASTFunction f = (IASTFunction)declarations.next();
assertFalse( declarations.hasNext() );
assertSimpleReturnType( f, IASTSimpleTypeSpecifier.Type.INT );
assertEquals( f.getName(), "f");
Iterator parameters = f.getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parameters.next();
assertFalse( parameters.hasNext() );
assertParameterSimpleType( parm, IASTSimpleTypeSpecifier.Type.INT );
assertEquals( parm.getName(), "" );
assertEquals( parm.getDefaultValue().getKind(), IASTInitializerClause.Kind.ASSIGNMENT_EXPRESSION );
assertEquals( parm.getDefaultValue().getAssigmentExpression().getExpressionKind(), IASTExpression.Kind.PRIMARY_INTEGER_LITERAL );
assertEquals( parm.getDefaultValue().getAssigmentExpression().getLiteralString(), "0" );
}
public void testBug36240() throws Exception
{
Iterator declarations = parse( "A & A::operator=( A ){}").getDeclarations();
IASTFunction f = (IASTFunction)declarations.next();
IASTSimpleTypeSpecifier typeSpec = (IASTSimpleTypeSpecifier)f.getReturnType().getTypeSpecifier();
assertEquals( typeSpec.getType(), IASTSimpleTypeSpecifier.Type.CLASS_OR_TYPENAME );
assertEquals( typeSpec.getTypename(), "A");
Iterator pointerOps = f.getReturnType().getPointerOperators();
assertEquals( (ASTPointerOperator)pointerOps.next(), ASTPointerOperator.REFERENCE );
assertFalse( pointerOps.hasNext() );
assertEquals( f.getName(), "A::operator =");
Iterator parms = f.getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parms.next();
assertEquals( parm.getName(), "" );
typeSpec = (IASTSimpleTypeSpecifier)parm.getTypeSpecifier();
assertEquals( typeSpec.getType(), IASTSimpleTypeSpecifier.Type.CLASS_OR_TYPENAME );
assertEquals( typeSpec.getTypename(), "A" );
}
public void testBug36254() throws Exception
{
Iterator declarations = parse( "unsigned i;\nvoid f( unsigned p1 = 0 );").getDeclarations();
IASTVariable v = (IASTVariable)declarations.next();
assertSimpleType( v, IASTSimpleTypeSpecifier.Type.INT);
assertTrue( ((IASTSimpleTypeSpecifier)v.getAbstractDeclaration().getTypeSpecifier()).isUnsigned() );
IASTFunction f = (IASTFunction)declarations.next();
assertSimpleReturnType(f, IASTSimpleTypeSpecifier.Type.VOID );
assertEquals( f.getName(), "f");
Iterator parms = f.getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parms.next();
assertEquals( parm.getName(), "p1");
assertParameterSimpleType( parm, IASTSimpleTypeSpecifier.Type.INT );
assertTrue( ((IASTSimpleTypeSpecifier)parm.getTypeSpecifier()).isUnsigned() );
assertEquals( parm.getDefaultValue().getKind(), IASTInitializerClause.Kind.ASSIGNMENT_EXPRESSION );
assertEquals( parm.getDefaultValue().getAssigmentExpression().getExpressionKind(), IASTExpression.Kind.PRIMARY_INTEGER_LITERAL );
assertEquals( parm.getDefaultValue().getAssigmentExpression().getLiteralString(), "0" );
assertFalse( declarations.hasNext());
}
public void testBug36432() throws Exception
{
Writer code = new StringWriter();
code.write( "#define CMD_GET \"g\"\n" );
code.write( "#define CMD_ACTION \"a\"\n" );
code.write( "#define CMD_QUIT \"q\"\n" );
code.write( "static const memevent_cmd_func memevent_cmd_funcs[sizeof memevent_cmds - 1] = {\n");
code.write( "memevent_get,\n");
code.write( "memevent_action,\n");
code.write( "memevent_quit,\n");
code.write( "};\n");
parse( code.toString() );
}
public void testBug36594() throws Exception
{
parse( "const int n = sizeof(A) / sizeof(B);");
}
public void testBug36794() throws Exception
{
parse( "template<> class allocator<void> {};");
Iterator i = quickParseCallback.iterateOffsetableElements();
while( i.hasNext() )
assertNotNull( i.next() );
}
public void testBug36799() throws Exception
{
parse( "static const int __WORD_BIT = int(CHAR_BIT*sizeof(unsigned int));");
}
public void testBug36764() throws Exception
{
parse( "struct{ int x : 4; int y : 8; };" );
}
public void testOrder() throws Exception
{
Writer code = new StringWriter();
code.write( "#define __SGI_STL_INTERNAL_ALGOBASE_H\n" );
code.write( "#include <string.h>\n" );
code.write( "template <class _Tp>\n" );
code.write( "inline void swap(_Tp& __a, _Tp& __b) {\n" );
code.write( "__STL_REQUIRES(_Tp, _Assignable);\n" );
code.write( "_Tp __tmp = __a;\n" );
code.write( "__a = __b;\n" );
code.write( "__b = __tmp;\n" );
code.write( "}\n" );
parse( code.toString() );
Iterator i = quickParseCallback.iterateOffsetableElements();
assertTrue( i.hasNext() );
assertTrue( i.next() instanceof IASTMacro );
assertTrue( i.hasNext() );
assertTrue( i.next() instanceof IASTInclusion );
assertTrue( i.hasNext() );
assertTrue( i.next() instanceof IASTDeclaration );
assertFalse( i.hasNext() );
}
public void testBug36771() throws Exception {
Writer code = new StringWriter();
code.write("#include /**/ \"foo.h\"\n");
parse( code.toString() );
Iterator includes = quickParseCallback.getInclusions();
IASTInclusion include = (IASTInclusion)includes.next();
assertTrue( include.getName().equals("foo.h") );
assertFalse( includes.hasNext() );
}
public void testBug36811() throws Exception
{
Writer code = new StringWriter();
code.write( "using namespace std;\n" );
code.write( "class Test {};" );
parse( code.toString() );
Iterator i = quickParseCallback.iterateOffsetableElements();
while( i.hasNext() )
assertNotNull( i.next() );
}
public void testBug36708() throws Exception {
Iterator declarations = parse("enum { isPointer = PointerTraits<T>::result };").getDeclarations();
IASTEnumerationSpecifier enumSpec = (IASTEnumerationSpecifier)((IASTAbstractTypeSpecifierDeclaration)declarations.next()).getTypeSpecifier();
assertFalse( declarations.hasNext() );
Iterator enumerators = enumSpec.getEnumerators();
IASTEnumerator enumerator = (IASTEnumerator)enumerators.next();
assertFalse( enumerators.hasNext() );
assertEquals( enumerator.getName(), "isPointer");
assertEquals( enumerator.getInitialValue().getExpressionKind(), IASTExpression.Kind.ID_EXPRESSION );
assertEquals( enumerator.getInitialValue().getIdExpression(), "PointerTraits<T>::result");
}
public void testBug36690() throws Exception {
parse("Functor(const Functor& rhs) : spImpl_(Impl::Clone(rhs.spImpl_.get())){}").getDeclarations();
}
public void testBug36703() throws Exception {
parse("const std::type_info& Get() const;");
}
public void testBug36692() throws Exception {
Writer code = new StringWriter();
code.write("template <typename T, typename Destroyer>\n");
code.write("void SetLongevity(T* pDynObject, unsigned int longevity,\n");
code.write("Destroyer d = Private::Deleter<T>::Delete){}\n");
parse(code.toString());
}
public void testBug36551() throws Exception
{
Writer code = new StringWriter();
code.write( "class TextFrame {\n" );
code.write( "BAD_MACRO()\n");
code.write( "};");
parse( code.toString(), true, false );
}
public void testBug36247() throws Exception
{
Writer code = new StringWriter();
code.write( "class A {\n" );
code.write( "INLINE_DEF int f ();\n" );
code.write( "INLINE_DEF A g ();" );
code.write( "INLINE_DEF A * h ();" );
code.write( "INLINE_DEF A & unlock( void );");
code.write( "};" );
parse(code.toString());
}
public void testStruct() throws Exception
{
StringWriter writer = new StringWriter();
writer.write( "struct mad_bitptr { unsigned char const *byte;\n" );
writer.write( "unsigned short cache;\n unsigned short left;};" );
parse( writer.toString() );
}
public void testBug36559() throws Exception
{
Writer code = new StringWriter();
code.write( "namespace myNameSpace {\n" );
code.write( "template<typename T=short> class B {};\n" );
code.write( "template<> class B<int> {};\n" );
code.write( "}\n" );
parse( code.toString() );
}
public void testPointersToFunctions() throws Exception
{
Writer code = new StringWriter();
code.write( "void (*name)( void );\n");
code.write( "static void * (* const orig_malloc_hook)(const char *file, int line, size_t size);\n");
Iterator declarations = parse( code.toString() ).getDeclarations();
IASTVariable p2f = (IASTVariable)declarations.next();
assertSimpleType( p2f, IASTSimpleTypeSpecifier.Type.VOID );
assertEquals( p2f.getName(), "name" );
Iterator parameters = p2f.getAbstractDeclaration().getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parameters.next();
assertFalse( parameters.hasNext() );
assertParameterSimpleType( parm, IASTSimpleTypeSpecifier.Type.VOID );
assertEquals( parm.getName(), "" );
p2f = (IASTVariable)declarations.next();
assertSimpleType( p2f, IASTSimpleTypeSpecifier.Type.VOID );
assertTrue( p2f.isStatic() );
Iterator rtPo = p2f.getAbstractDeclaration().getPointerOperators();
assertEquals( rtPo.next(), ASTPointerOperator.POINTER );
assertFalse( rtPo.hasNext() );
parameters = p2f.getAbstractDeclaration().getParameters();
parm = (IASTParameterDeclaration)parameters.next();
assertParameterSimpleType( parm, IASTSimpleTypeSpecifier.Type.CHAR );
assertEquals( parm.getName(), "file" );
assertTrue( parm.isConst() );
assertTrue( parm.getPointerOperators().hasNext() );
parm = (IASTParameterDeclaration)parameters.next();
assertParameterSimpleType( parm, IASTSimpleTypeSpecifier.Type.INT );
assertEquals( parm.getName(), "line" );
parm = (IASTParameterDeclaration)parameters.next();
assertParameterSimpleType( parm, IASTSimpleTypeSpecifier.Type.CLASS_OR_TYPENAME );
assertEquals( parm.getName(), "size" );
assertFalse( parameters.hasNext() );
}
public void testBug36600() throws Exception
{
IASTVariable p2f = (IASTVariable)parse( "enum mad_flow (*input_func)(void *, struct mad_stream *);").getDeclarations().next();
IASTElaboratedTypeSpecifier elab = (IASTElaboratedTypeSpecifier)p2f.getAbstractDeclaration().getTypeSpecifier();
assertEquals( elab.getName(), "mad_flow");
assertEquals( elab.getClassKind(), ASTClassKind.ENUM );
assertEquals( p2f.getName(), "input_func");
Iterator parms = p2f.getAbstractDeclaration().getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parms.next();
assertEquals( parm.getName(), "" );
assertEquals( parm.getPointerOperators().next(), ASTPointerOperator.POINTER);
assertParameterSimpleType( parm, IASTSimpleTypeSpecifier.Type.VOID);
parm = (IASTParameterDeclaration)parms.next();
assertEquals( parm.getName(), "" );
assertEquals( parm.getPointerOperators().next(), ASTPointerOperator.POINTER);
elab = (IASTElaboratedTypeSpecifier)parm.getTypeSpecifier();
assertEquals( elab.getName(), "mad_stream");
assertEquals( elab.getClassKind(), ASTClassKind.STRUCT );
}
public void testBug36713() throws Exception {
Writer code = new StringWriter();
code.write("A ( * const fPtr) (void *); \n");
code.write("A (* const fPtr2) ( A * ); \n");
parse(code.toString()).getDeclarations();
}
// K&R Test hasn't been ported from DOMTests
// still need to figure out how to represent these in the AST
// public void testOldKRFunctionDeclarations() throws Exception
// {
// // Parse and get the translaton unit
// Writer code = new StringWriter();
// code.write("bool myFunction( parm1, parm2, parm3 )\n");
// code.write("const char* parm1;\n");
// code.write("int (*parm2)(float);\n");
// code.write("{}");
// TranslationUnit translationUnit = parse(code.toString());
//
// // Get the declaration
// List declarations = translationUnit.getDeclarations();
// assertEquals(1, declarations.size());
// SimpleDeclaration simpleDeclaration = (SimpleDeclaration)declarations.get(0);
// assertEquals( simpleDeclaration.getDeclSpecifier().getType(), DeclSpecifier.t_bool );
// List declarators = simpleDeclaration.getDeclarators();
// assertEquals( 1, declarators.size() );
// Declarator functionDeclarator = (Declarator)declarators.get( 0 );
// assertEquals( functionDeclarator.getName().toString(), "myFunction" );
//
// ParameterDeclarationClause pdc = functionDeclarator.getParms();
// assertNotNull( pdc );
// List parameterDecls = pdc.getDeclarations();
// assertEquals( 3, parameterDecls.size() );
// ParameterDeclaration parm1 = (ParameterDeclaration)parameterDecls.get( 0 );
// assertNotNull( parm1.getDeclSpecifier().getName() );
// assertEquals( "parm1", parm1.getDeclSpecifier().getName().toString() );
// List parm1Decls = parm1.getDeclarators();
// assertEquals( 1, parm1Decls.size() );
//
// ParameterDeclaration parm2 = (ParameterDeclaration)parameterDecls.get( 1 );
// assertNotNull( parm2.getDeclSpecifier().getName() );
// assertEquals( "parm2", parm2.getDeclSpecifier().getName().toString() );
// List parm2Decls = parm2.getDeclarators();
// assertEquals( 1, parm2Decls.size() );
//
// ParameterDeclaration parm3 = (ParameterDeclaration)parameterDecls.get( 2 );
// assertNotNull( parm3.getDeclSpecifier().getName() );
// assertEquals( "parm3", parm3.getDeclSpecifier().getName().toString() );
// List parm3Decls = parm3.getDeclarators();
// assertEquals( 1, parm3Decls.size() );
//
// OldKRParameterDeclarationClause clause = pdc.getOldKRParms();
// assertNotNull( clause );
// assertEquals( clause.getDeclarations().size(), 2 );
// SimpleDeclaration decl1 = (SimpleDeclaration)clause.getDeclarations().get(0);
// assertEquals( decl1.getDeclarators().size(), 1 );
// assertTrue(decl1.getDeclSpecifier().isConst());
// assertFalse(decl1.getDeclSpecifier().isVolatile());
// assertEquals( decl1.getDeclSpecifier().getType(), DeclSpecifier.t_char);
// Declarator declarator1 = (Declarator)decl1.getDeclarators().get( 0 );
// assertEquals( declarator1.getName().toString(), "parm1" );
// List ptrOps1 = declarator1.getPointerOperators();
// assertNotNull( ptrOps1 );
// assertEquals( 1, ptrOps1.size() );
// PointerOperator po1 = (PointerOperator)ptrOps1.get(0);
// assertNotNull( po1 );
// assertFalse( po1.isConst() );
// assertFalse( po1.isVolatile() );
// assertEquals( po1.getType(), PointerOperator.t_pointer );
//
// SimpleDeclaration declaration = (SimpleDeclaration)clause.getDeclarations().get(1);
// assertEquals( declaration.getDeclSpecifier().getType(), DeclSpecifier.t_int );
// assertEquals( declaration.getDeclarators().size(), 1);
// assertNull( ((Declarator)declaration.getDeclarators().get(0)).getName() );
// assertNotNull( ((Declarator)declaration.getDeclarators().get(0)).getDeclarator() );
// assertEquals( ((Declarator)declaration.getDeclarators().get(0)).getDeclarator().getName().toString(), "parm2" );
// ParameterDeclarationClause clause2 = ((Declarator)declaration.getDeclarators().get(0)).getParms();
// assertEquals( clause2.getDeclarations().size(), 1 );
// assertEquals( ((ParameterDeclaration)clause2.getDeclarations().get(0)).getDeclarators().size(), 1 );
// assertNull( ((Declarator)((ParameterDeclaration)clause2.getDeclarations().get(0)).getDeclarators().get(0)).getName() );
// assertEquals( ((ParameterDeclaration)clause2.getDeclarations().get(0)).getDeclSpecifier().getType(), DeclSpecifier.t_float );
// }
public void testPointersToMemberFunctions() throws Exception
{
IASTVariable p2m = (IASTVariable)parse("void (A::*name)(void);").getDeclarations().next();
assertSimpleType( p2m, IASTSimpleTypeSpecifier.Type.VOID );
assertEquals( p2m.getName(), "A::name");
assertEquals( p2m.getAbstractDeclaration().getPointerToFunctionOperator(), ASTPointerOperator.POINTER);
Iterator parameters = p2m.getAbstractDeclaration().getParameters();
IASTParameterDeclaration parm = (IASTParameterDeclaration)parameters.next();
assertFalse( parameters.hasNext() );
assertParameterSimpleType( parm, IASTSimpleTypeSpecifier.Type.VOID );
assertEquals( parm.getName(), "" );
}
public void testBug39550() throws Exception
{
parse("double x = 0x1.fp1;").getDeclarations().next();
}
public void testBug39552A() throws Exception
{
Writer code = new StringWriter();
code.write("%:define glue(x, y) x %:%: y /* #define glue(x, y) x ## y. */\n");
code.write("#ifndef glue\n");
code.write("#error glue not defined!\n");
code.write("#endif\n");
code.write("%:define str(x) %:x /* #define str(x) #x */\n");
code.write("int main (int argc, char *argv<::>) /* argv[] */\n");
code.write("glue (<, %) /* { */\n");
code.write(" /* di_str[] = */\n");
code.write(" const char di_str glue(<, :)glue(:, >) = str(%:%:<::><%%>%:);\n");
code.write(" /* Check the glue macro actually pastes, and that the spelling of\n");
code.write(" all digraphs is preserved. */\n");
code.write(" if (glue(strc, mp) (di_str, \"%:%:<::><%%>%:\"))\n");
code.write(" err (\"Digraph spelling not preserved!\");\n");
code.write(" return 0;\n");
code.write("glue (%, >) /* } */\n");
parse(code.toString());
}
public void testBug39552B() throws Exception
{
Writer code = new StringWriter();
code.write("??=include <stdio.h>\n");
code.write("??=define TWELVE 1??/\n");
code.write("2\n");
code.write("static const char str??(??) = \"0123456789??/n\";\n");
code.write("int\n");
code.write("main(void)\n");
code.write("??<\n");
code.write(" unsigned char x = 5;\n");
code.write(" if (sizeof str != TWELVE)\n");
code.write(" abort ();\n");
code.write(" /* Test ^=, the only multi-character token to come from trigraphs. */\n");
code.write(" x ??'= 3;\n");
code.write(" if (x != 6)\n");
code.write(" abort ();\n");
code.write(" if ((5 ??! 3) != 7)\n");
code.write(" abort ();\n");
code.write(" return 0;\n");
code.write("??>\n");
parse(code.toString());
}
public void testBug39553() throws Exception
{
parse("#define COMP_INC \"foobar.h\" \n" + "#include COMP_INC");
assertTrue( quickParseCallback.getInclusions().hasNext() );
}
public void testBug39537() throws Exception
{
parse("typedef foo<(U::id > 0)> foobar;");
assertTrue( quickParseCallback.getCompilationUnit().getDeclarations().hasNext() );
}
public void testBug39546() throws Exception
{
parse("signed char c = (signed char) 0xffffffff;");
assertTrue( quickParseCallback.getCompilationUnit().getDeclarations().hasNext() );
}
public void testIndirectDeclarators() throws Exception
{
IASTVariable v = (IASTVariable)parse( "void (*x)( int );").getDeclarations().next();
assertEquals( v.getName(), "x");
assertSimpleType( v, IASTSimpleTypeSpecifier.Type.VOID );
assertParameterSimpleType( (IASTParameterDeclaration)v.getAbstractDeclaration().getParameters().next(), IASTSimpleTypeSpecifier.Type.INT );
assertEquals( v.getAbstractDeclaration().getPointerToFunctionOperator(), ASTPointerOperator.POINTER );
v = (IASTVariable)parse( "const int * (* const something)( const int * const * const );").getDeclarations().next();
assertEquals( v.getName(), "something");
assertEquals( v.getAbstractDeclaration().getPointerToFunctionOperator(), ASTPointerOperator.CONST_POINTER);
assertTrue( v.getAbstractDeclaration().isConst() );
assertSimpleType( v, IASTSimpleTypeSpecifier.Type.INT );
assertEquals( v.getAbstractDeclaration().getPointerOperators().next(), ASTPointerOperator.POINTER );
IASTParameterDeclaration parm = (IASTParameterDeclaration)v.getAbstractDeclaration().getParameters().next();
assertParameterSimpleType( parm, IASTSimpleTypeSpecifier.Type.INT );
Iterator pointerOps = parm.getPointerOperators();
assertEquals( pointerOps.next(), ASTPointerOperator.CONST_POINTER );
assertEquals( pointerOps.next(), ASTPointerOperator.CONST_POINTER );
assertFalse( pointerOps.hasNext() );
IASTTypedefDeclaration typedef = (IASTTypedefDeclaration)parse( "typedef void (*life)(int);").getDeclarations().next();
assertEquals( typedef.getName(), "life");
assertSimpleType( typedef, IASTSimpleTypeSpecifier.Type.VOID );
assertParameterSimpleType( (IASTParameterDeclaration)typedef.getAbstractDeclarator().getParameters().next(), IASTSimpleTypeSpecifier.Type.INT );
IASTFunction f = (IASTFunction)parse( "void (f)(void);").getDeclarations().next();
assertEquals( f.getName(), "f");
typedef = (IASTTypedefDeclaration)parse( "typedef void (life)(int);").getDeclarations().next();
assertEquals( typedef.getName(), "life");
}
public void testBug39532() throws Exception
{
parse("class N1::N2::B : public A {};");
assertTrue( quickParseCallback.getCompilationUnit().getDeclarations().hasNext() );
}
public void testBug39540() throws Exception
{
parse("class {} const null;");
assertTrue( quickParseCallback.getCompilationUnit().getDeclarations().hasNext() );
}
public void testBug39530() throws Exception
{
parse( "X sPassed(-1)");
}
public void testBug39526() throws Exception
{
parse("UnitList unit_list (String(\"keV\"));");
}
public void testBug39535() throws Exception
{
parse("namespace bar = foo;");
}
public void testBug39504B() throws Exception
{
parse("int y = sizeof (int*);");
}
public void testBug39505A() throws Exception
{
parse("int AD::* gp_down = static_cast<int AD::*>(gp_stat);");
}
public void testBug39505B() throws Exception
{
parse("int* gp_down = static_cast<int*>(gp_stat);");
}
public void testBug42985() throws Exception
{
parse( "const int x = 4; int y = ::x;");
}
public void testBug40419() throws Exception
{
Writer code = new StringWriter();
try
{
code.write( "template <class T, class U> struct SuperSubclass {\n" );
code.write( "enum { value = (::Loki::Conversion<const volatile U*, const volatile T*>::exists && \n" );
code.write( "!::Loki::Conversion<const volatile T*, const volatile void*>::sameType) }; };" );
} catch( IOException ioe ){}
parse( code.toString() );
}
public void testBug39556() throws Exception
{
parse("int *restrict ip_fn (void);", true, true, ParserLanguage.C).getDeclarations().next();
}
/**
* Test code: struct Example { Example(); Example(int); ~Example();};
* Purpose: tests a declaration in a class scope.
*/
public void testBug43371 () throws Exception
{
// Parse and get the translaton unit
Writer code = new StringWriter();
code.write("struct Example { Example(); Example(int); ~Example();};");
IASTCompilationUnit cu = parse(code.toString());
Iterator i = cu.getDeclarations();
assertTrue(i.hasNext());
IASTAbstractTypeSpecifierDeclaration declaration =
(IASTAbstractTypeSpecifierDeclaration)i.next();
assertFalse(i.hasNext());
assertTrue( declaration.getTypeSpecifier() instanceof IASTClassSpecifier);
assertTrue(((IASTClassSpecifier)declaration.getTypeSpecifier()).getClassKind()== ASTClassKind.STRUCT);
Iterator j =((IASTClassSpecifier)declaration.getTypeSpecifier()).getDeclarations();
assertTrue(j.hasNext());
IASTMethod m1 = (IASTMethod)j.next();
IASTMethod m2 = (IASTMethod)j.next();
IASTMethod m3 = (IASTMethod)j.next();
assertFalse(j.hasNext());
assertTrue(m1.getVisiblity() == ASTAccessVisibility.PUBLIC);
assertTrue(m2.getVisiblity() == ASTAccessVisibility.PUBLIC);
assertTrue(m3.getVisiblity() == ASTAccessVisibility.PUBLIC);
}
public void testBug43644() throws Exception
{
Iterator i = parse( "void foo();{ int x; }", true, false ).getDeclarations();
IASTFunction f = (IASTFunction)i.next();
assertEquals( f.getName(), "foo");
assertFalse( i.hasNext() );
}
public void testBug43062() throws Exception
{
Iterator i = parse( "class X { operator short (); operator int unsigned(); operator int signed(); };").getDeclarations();
IASTClassSpecifier classX = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)i.next()).getTypeSpecifier();
assertFalse( i.hasNext() );
Iterator members = classX.getDeclarations();
IASTMethod shortMethod = (IASTMethod)members.next();
IASTMethod unsignedMethod = (IASTMethod)members.next();
IASTMethod signedMethod = (IASTMethod)members.next();
assertFalse( members.hasNext() );
assertEquals( shortMethod.getName(), "operator short");
assertEquals( unsignedMethod.getName(), "operator int unsigned");
assertEquals( signedMethod.getName(), "operator int signed");
}
public void testBug39531() throws Exception
{
parse("class AString { operator char const *() const; };");
}
public void testBug40007() throws Exception
{
assertCodeFailsParse("int y = #;");
}
public void testBug40759() throws Exception
{
IASTClassSpecifier classSpec = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)assertSoleDeclaration( "#define X SomeName \n class X {};" )).getTypeSpecifier();
assertEquals( classSpec.getNameOffset() + 1, classSpec.getNameEndOffset() );
assertEquals( classSpec.getName(), "SomeName");
}
public void testBug44633() throws Exception
{
Writer writer = new StringWriter();
writer.write( "template <typename T> class A {};\n" );
writer.write( "class B { template <typename T> friend class A;\n" );
writer.write( "void method();\n" );
writer.write( "};\n" );
Iterator i = parse( writer.toString() ).getDeclarations();
assertTrue( i.next() instanceof IASTTemplateDeclaration );
IASTClassSpecifier classB = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)i.next()).getTypeSpecifier();
Iterator members = classB.getDeclarations();
assertTrue (members.next() instanceof IASTTemplateDeclaration );
assertTrue( members.next() instanceof IASTMethod );
assertFalse( i.hasNext() );
}
public void testBug39525() throws Exception
{
parse("C &(C::*DD)(const C &x) = &C::operator=;");
}
public void testBug41935() throws Exception
{
Iterator i = parse( "namespace A { int x; } namespace B = A;" ).getDeclarations();
assertTrue( i.next() instanceof IASTNamespaceDefinition );
IASTNamespaceAlias a = (IASTNamespaceAlias)i.next();
assertEquals( a.getName(), "B" );
assertFalse( i.hasNext() );
}
public void testBug39528() throws Exception
{
Writer code = new StringWriter();
try
{
code.write("struct B: public A {\n");
code.write(" A a;\n");
code.write(" B() try : A(1), a(2)\n");
code.write(" { throw 1; }\n");
code.write(" catch (...)\n");
code.write(" { if (c != 3) r |= 1; }\n");
code.write("};\n");
}
catch (IOException ioe)
{
}
IASTClassSpecifier structB = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)assertSoleDeclaration(code.toString())).getTypeSpecifier();
Iterator members = structB.getDeclarations();
IASTField a = (IASTField)members.next();
IASTMethod b = (IASTMethod)members.next();
assertFalse( members.hasNext() );
assertTrue( b.hasFunctionTryBlock() );
}
public void testBug39538() throws Exception
{
parse("template C::operator int<float> ();");
}
public void testBug39536() throws Exception
{
Writer writer = new StringWriter();
writer.write( "template<class E>\n" );
writer.write( "class X {\n" );
writer.write( "X<E>(); // This fails \n" );
writer.write( "inline X<E>(int); // This also fails \n" );
writer.write( "inline ~X<E>(); // This works fine \n" );
writer.write( "};\n" );
IASTTemplateDeclaration template = (IASTTemplateDeclaration)assertSoleDeclaration( writer.toString() );
IASTClassSpecifier X = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)template.getOwnedDeclaration()).getTypeSpecifier();
Iterator members = X.getDeclarations();
IASTMethod defaultCons = (IASTMethod)members.next();
IASTMethod inlinedCons = (IASTMethod)members.next();
IASTMethod destructor = (IASTMethod)members.next();
assertFalse( members.hasNext() );
}
public void testBug39536A() throws Exception
{
IASTTemplateDeclaration template = (IASTTemplateDeclaration)parse("template<class E> class X { X<E>(); };").getDeclarations().next();
IASTClassSpecifier classX = (IASTClassSpecifier)((IASTAbstractTypeSpecifierDeclaration)template.getOwnedDeclaration()).getTypeSpecifier();
IASTDeclaration d = (IASTDeclaration)classX.getDeclarations().next();
assertTrue( d instanceof IASTMethod);
}
public void testBug39536B() throws Exception
{
parse("template<class E> class X { inline X<E>(int); };");
}
public void testBug39542() throws Exception
{
parse("void f(int a, struct {int b[a];} c) {}");
}
//Here starts C99-specific section
public void testBug39549() throws Exception
{
parse("struct X x = { .b = 40, .z = { sizeof(X), 42 }, .t[3] = 2, .t.f[3].x = A * B };", true, true, ParserLanguage.C);
// with trailing commas
parse("struct X x = { .b = 40, .z = { sizeof(X), 42,}, .t[3] = 2, .t.f[3].x = A * B ,};", true, true, ParserLanguage.C);
}
public void testBug39551A() throws Exception
{
IASTFunction function = (IASTFunction)parse("extern float _Complex conjf (float _Complex);", true, true, ParserLanguage.C).getDeclarations().next();
assertEquals( function.getName(), "conjf");
assertTrue( ((IASTSimpleTypeSpecifier)function.getReturnType().getTypeSpecifier()).isComplex() );
}
public void testBug39551B() throws Exception
{
IASTVariable variable = (IASTVariable)parse("_Imaginary double id = 99.99 * __I__;", true, true, ParserLanguage.C).getDeclarations().next();
assertEquals( variable.getName(), "id");
assertTrue( ((IASTSimpleTypeSpecifier)variable.getAbstractDeclaration().getTypeSpecifier()).isImaginary() );
}
public void testCBool() throws Exception
{
IASTVariable variable = (IASTVariable)assertSoleDeclaration( "_Bool x;", ParserLanguage.C );
assertSimpleType( variable, IASTSimpleTypeSpecifier.Type._BOOL );
}
public void testBug39678() throws Exception
{
IASTVariable variable = (IASTVariable) assertSoleDeclaration("char *s = L\"a\" \"b\";");
IASTExpression exp = variable.getInitializerClause().getAssigmentExpression();
assertEquals( exp.getLiteralString(), "ab");
}
public void testBug43110() throws Exception
{
IASTFunction function = (IASTFunction) assertSoleDeclaration( "void x( int y, ... );");
assertTrue( function.takesVarArgs() );
function = (IASTFunction) assertSoleDeclaration( "void x( int y... );");
assertTrue( function.takesVarArgs() );
}
}