Attachment #117293 for bug #253690

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




        }
    }

	protected static class NameChecker extends ASTVisitor {
		private boolean fFound;
		protected NameChecker() {
			shouldVisitNames= true;
		}
		@Override
		public int visit(IASTName name) {
			fFound= true;
			return PROCESS_ABORT;
		}
		public boolean containsName(IASTNode node) {
			fFound= false;
			node.accept(this);
			return fFound;
		}
	}
	protected NameChecker NAME_CHECKER= new NameChecker();

	protected static final int DEFAULT_DESIGNATOR_LIST_SIZE = 4;
    protected static int parseCount = 0;


Lines 146-151 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java (-1 / +2 lines)
146	import org.eclipse.cdt.core.parser.util.CharArrayUtils;	146	import org.eclipse.cdt.core.parser.util.CharArrayUtils;
147	import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;	147	import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;
148	import org.eclipse.cdt.internal.core.dom.parser.ASTNode;	148	import org.eclipse.cdt.internal.core.dom.parser.ASTNode;
		149	import org.eclipse.cdt.internal.core.dom.parser.ASTQueries;
149	import org.eclipse.cdt.internal.core.dom.parser.AbstractGNUSourceCodeParser;	150	import org.eclipse.cdt.internal.core.dom.parser.AbstractGNUSourceCodeParser;
150	import org.eclipse.cdt.internal.core.dom.parser.BacktrackException;	151	import org.eclipse.cdt.internal.core.dom.parser.BacktrackException;
151	import org.eclipse.cdt.internal.core.dom.parser.DeclarationOptions;	152	import org.eclipse.cdt.internal.core.dom.parser.DeclarationOptions;
Lines 3301-3307 Link Here
3301	// assignmentExpression	3302	// assignmentExpression
3302	IASTExpression assignmentExpression = assignmentExpression();	3303	IASTExpression assignmentExpression = assignmentExpression();
3303	if (inAggregateInitializer && skipTrivialExpressionsInAggregateInitializers) {	3304	if (inAggregateInitializer && skipTrivialExpressionsInAggregateInitializers) {
3304	if (!NAME_CHECKER.containsName(assignmentExpression))	3305	if (!ASTQueries.canContainName(assignmentExpression))
3305	return null;	3306	return null;
3306	}	3307	}
3307		3308




import org.eclipse.cdt.core.parser.util.CharArrayUtils;
import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;
import org.eclipse.cdt.internal.core.dom.parser.ASTNode;
import org.eclipse.cdt.internal.core.dom.parser.ASTQueries;
import org.eclipse.cdt.internal.core.dom.parser.AbstractGNUSourceCodeParser;
import org.eclipse.cdt.internal.core.dom.parser.BacktrackException;
import org.eclipse.cdt.internal.core.dom.parser.DeclarationOptions;


                IASTInitializer initializer = cInitializerClause(newDesignators, true);

                // depending on value of skipTrivialItemsInCompoundInitializers initializer may be null
                if (initializer != null) {
                	if (newDesignators.isEmpty()) {
                		result.addInitializer(initializer);
                	} else {
                		ICASTDesignatedInitializer desigInitializer = createDesignatorInitializer();
                		((ASTNode) desigInitializer).setOffsetAndLength(
                				((ASTNode) newDesignators.get(0)).getOffset(),
                				((ASTNode)initializer).getOffset() + ((ASTNode)initializer).getLength() - ((ASTNode) newDesignators.get(0)).getOffset());
                		for (int i = 0; i < newDesignators.size(); ++i) {
                			ICASTDesignator d = (ICASTDesignator) newDesignators.get(i);
                			desigInitializer.addDesignator(d);
                		}
                		desigInitializer.setOperandInitializer(initializer);
                		result.addInitializer(desigInitializer);
                	}
                }
                // can end with ", }" or "}"
                if (LT(1) == IToken.tCOMMA)

        // assignmentExpression
        IASTExpression assignmentExpression = assignmentExpression();
        if (inAggregateInitializer && skipTrivialExpressionsInAggregateInitializers) {
        	if (!ASTQueries.canContainName(assignmentExpression))
        		return null;
        }
        IASTInitializerExpression result = createInitializerExpression();

Lines 151-156 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPVisitor.java (-1 / +2 lines)
151	import org.eclipse.cdt.core.parser.util.ArrayUtil;	151	import org.eclipse.cdt.core.parser.util.ArrayUtil;
152	import org.eclipse.cdt.core.parser.util.CharArrayUtils;	152	import org.eclipse.cdt.core.parser.util.CharArrayUtils;
153	import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;	153	import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;
		154	import org.eclipse.cdt.internal.core.dom.parser.ASTQueries;
154	import org.eclipse.cdt.internal.core.dom.parser.ITypeContainer;	155	import org.eclipse.cdt.internal.core.dom.parser.ITypeContainer;
155	import org.eclipse.cdt.internal.core.dom.parser.ProblemBinding;	156	import org.eclipse.cdt.internal.core.dom.parser.ProblemBinding;
156	import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTName;	157	import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTName;
Lines 191-197 Link Here
191	/**	192	/**
192	* @author aniefer	193	* @author aniefer
193	*/	194	*/
194	public class CPPVisitor {	195	public class CPPVisitor extends ASTQueries {
195	public static final String SIZE_T = "size_t"; //$NON-NLS-1$	196	public static final String SIZE_T = "size_t"; //$NON-NLS-1$
196	public static final String PTRDIFF_T = "ptrdiff_t"; //$NON-NLS-1$	197	public static final String PTRDIFF_T = "ptrdiff_t"; //$NON-NLS-1$
197	public static final String STD = "std"; //$NON-NLS-1$	198	public static final String STD = "std"; //$NON-NLS-1$




/*******************************************************************************
 * Copyright (c) 2008 Wind River Systems, Inc. and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Markus Schorn - initial API and implementation
 *******************************************************************************/ 
package org.eclipse.cdt.internal.core.dom.parser;

import org.eclipse.cdt.core.dom.ast.IASTBinaryExpression;
import org.eclipse.cdt.core.dom.ast.IASTConditionalExpression;
import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.ast.IASTExpressionList;
import org.eclipse.cdt.core.dom.ast.IASTIdExpression;
import org.eclipse.cdt.core.dom.ast.IASTLiteralExpression;
import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression;
import org.eclipse.cdt.internal.core.dom.parser.c.CVisitor;
import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor;

/**
 * Base class for {@link CVisitor} and {@link CPPVisitor}
 */
public class ASTQueries {
	/**
	 * Tests whether the given expression can contain ast-names, suitable to be used before ambiguity 
	 * resolution.
	 */
	public static boolean canContainName(IASTExpression expr) {
		if (expr == null || expr instanceof IASTLiteralExpression) 
			return false;

		if (expr instanceof IASTAmbiguousExpression) 
			return true;
		if (expr instanceof IASTIdExpression) 
			return true;
		
		if (expr instanceof IASTUnaryExpression) {
			IASTUnaryExpression uexpr= (IASTUnaryExpression) expr;
			return canContainName(uexpr.getOperand());
		}
		if (expr instanceof IASTBinaryExpression) {
			IASTBinaryExpression bexpr= (IASTBinaryExpression) expr;
			return canContainName(bexpr.getOperand1()) || canContainName(bexpr.getOperand2());
		}
		if (expr instanceof IASTConditionalExpression) {
			IASTConditionalExpression cexpr= (IASTConditionalExpression) expr;
			return canContainName(cexpr.getLogicalConditionExpression()) || 
					canContainName(cexpr.getPositiveResultExpression()) || canContainName(cexpr.getNegativeResultExpression());
		}
		if (expr instanceof IASTExpressionList) {
			IASTExpressionList lexpr= (IASTExpressionList) expr;
			IASTExpression[] subexprs= lexpr.getExpressions();
			for (IASTExpression subexpr : subexprs) {
				if (canContainName(subexpr))
					return true;
			}
		}
		return true;
	}
}

Return to bug 253690

Lines 108-131 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/AbstractGNUSourceCodeParser.java (-18 lines)
108	}	108	}
109	}	109	}
110		110
111	protected static class NameChecker extends ASTVisitor {
112	private boolean fFound;
113	protected NameChecker() {
114	shouldVisitNames= true;
115	}
116	@Override
117	public int visit(IASTName name) {
118	fFound= true;
119	return PROCESS_ABORT;
120	}
121	public boolean containsName(IASTNode node) {
122	fFound= false;
123	node.accept(this);
124	return fFound;
125	}
126	}
127	protected NameChecker NAME_CHECKER= new NameChecker();
128
129	protected static final int DEFAULT_DESIGNATOR_LIST_SIZE = 4;	111	protected static final int DEFAULT_DESIGNATOR_LIST_SIZE = 4;
130	protected static int parseCount = 0;	112	protected static int parseCount = 0;
131		113

Added Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/ASTQueries.java (+63 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Wind River Systems, Inc. and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Markus Schorn - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.cdt.internal.core.dom.parser;
12
13	import org.eclipse.cdt.core.dom.ast.IASTBinaryExpression;
14	import org.eclipse.cdt.core.dom.ast.IASTConditionalExpression;
15	import org.eclipse.cdt.core.dom.ast.IASTExpression;
16	import org.eclipse.cdt.core.dom.ast.IASTExpressionList;
17	import org.eclipse.cdt.core.dom.ast.IASTIdExpression;
18	import org.eclipse.cdt.core.dom.ast.IASTLiteralExpression;
19	import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression;
20	import org.eclipse.cdt.internal.core.dom.parser.c.CVisitor;
21	import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor;
22
23	/**
24	* Base class for {@link CVisitor} and {@link CPPVisitor}
25	*/
26	public class ASTQueries {
27	/**
28	* Tests whether the given expression can contain ast-names, suitable to be used before ambiguity
29	* resolution.
30	*/
31	public static boolean canContainName(IASTExpression expr) {
32	if (expr == null \|\| expr instanceof IASTLiteralExpression)
33	return false;
34
35	if (expr instanceof IASTAmbiguousExpression)
36	return true;
37	if (expr instanceof IASTIdExpression)
38	return true;
39
40	if (expr instanceof IASTUnaryExpression) {
41	IASTUnaryExpression uexpr= (IASTUnaryExpression) expr;
42	return canContainName(uexpr.getOperand());
43	}
44	if (expr instanceof IASTBinaryExpression) {
45	IASTBinaryExpression bexpr= (IASTBinaryExpression) expr;
46	return canContainName(bexpr.getOperand1()) \|\| canContainName(bexpr.getOperand2());
47	}
48	if (expr instanceof IASTConditionalExpression) {
49	IASTConditionalExpression cexpr= (IASTConditionalExpression) expr;
50	return canContainName(cexpr.getLogicalConditionExpression()) \|\|
51	canContainName(cexpr.getPositiveResultExpression()) \|\| canContainName(cexpr.getNegativeResultExpression());
52	}
53	if (expr instanceof IASTExpressionList) {
54	IASTExpressionList lexpr= (IASTExpressionList) expr;
55	IASTExpression[] subexprs= lexpr.getExpressions();
56	for (IASTExpression subexpr : subexprs) {
57	if (canContainName(subexpr))
58	return true;
59	}
60	}
61	return true;
62	}
63	}