Attachment #99743 for bug #187070

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 187070
Collapse All | Expand All

Lines 135-142 Link Here

(-)a/cnd.modelimpl/src/org/netbeans/modules/cnd/modelimpl/csm/ClassEnumBase.java (-2 / +2 lines)
135	} else {	135	} else {
136	qn = ns.getQualifiedName().toString() + "::" + prefix; // NOI18N	136	qn = ns.getQualifiedName().toString() + "::" + prefix; // NOI18N
137	}	137	}
138	CsmClassifier cls = ns.getProject().findClassifier(qn);	138	Collection<CsmClassifier> defs = ns.getProject().findClassifiers(qn);
139	if (cls != null) {	139	for(CsmClassifier cls : defs) {
140	if (CsmKindUtilities.isClass(cls)) {	140	if (CsmKindUtilities.isClass(cls)) {
141	CsmClass container = (CsmClass) cls;	141	CsmClass container = (CsmClass) cls;
142	Iterator<CsmMember> it = CsmSelect.getClassMembers(container,	142	Iterator<CsmMember> it = CsmSelect.getClassMembers(container,

Lines 74-80 Link Here

(-)a/cnd.modelimpl/src/org/netbeans/modules/cnd/modelimpl/csm/FunctionDDImpl.java (-12 / +11 lines)
74	* @author Vladimir Kvasihn	74	* @author Vladimir Kvasihn
75	*/	75	*/
76	public class FunctionDDImpl<T> extends FunctionImpl<T> implements CsmFunctionDefinition {	76	public class FunctionDDImpl<T> extends FunctionImpl<T> implements CsmFunctionDefinition {
77		77
78	private final CsmCompoundStatement body;	78	private final CsmCompoundStatement body;
79		79
80	public FunctionDDImpl(AST ast, CsmFile file, CsmScope scope, boolean global) throws AstRendererException {	80	public FunctionDDImpl(AST ast, CsmFile file, CsmScope scope, boolean global) throws AstRendererException {
Lines 163-175 Link Here
163	for(CsmOffsetableDeclaration candidate : prj.findDeclarations(uname)) {	163	for(CsmOffsetableDeclaration candidate : prj.findDeclarations(uname)) {
164	if ((candidate.getKind() == CsmDeclaration.Kind.FUNCTION \|\|	164	if ((candidate.getKind() == CsmDeclaration.Kind.FUNCTION \|\|
165	candidate.getKind() == CsmDeclaration.Kind.FUNCTION_FRIEND)) {	165	candidate.getKind() == CsmDeclaration.Kind.FUNCTION_FRIEND)) {
		166	if (FunctionImpl.isObjectVisibleInFile(getContainingFile(), candidate)) {
		167	decl = candidate;
		168	break;
		169	}
166	if (decl == null) {	170	if (decl == null) {
167	decl = candidate;	171	decl = candidate;
168	} else {
169	if (candidate.getContainingFile().equals(getContainingFile())) {
170	decl = candidate;
171	break;
172	}
173	}	172	}
174	}	173	}
175	}	174	}
Lines 191-223 Link Here
191	}	190	}
192	return null;	191	return null;
193	}	192	}
194		193
195	@Override	194	@Override
196	public CsmDeclaration.Kind getKind() {	195	public CsmDeclaration.Kind getKind() {
197	return CsmDeclaration.Kind.FUNCTION_DEFINITION;	196	return CsmDeclaration.Kind.FUNCTION_DEFINITION;
198	}	197	}
199		198
200	@Override	199	@Override
201	public Collection<CsmScopeElement> getScopeElements() {	200	public Collection<CsmScopeElement> getScopeElements() {
202	Collection<CsmScopeElement> l = super.getScopeElements();	201	Collection<CsmScopeElement> l = super.getScopeElements();
203	l.add(getBody());	202	l.add(getBody());
204	return l;	203	return l;
205	}	204	}
206		205
207	////////////////////////////////////////////////////////////////////////////	206	////////////////////////////////////////////////////////////////////////////
208	// iml of SelfPersistent	207	// iml of SelfPersistent
209		208
210	@Override	209	@Override
211	public void write(DataOutput output) throws IOException {	210	public void write(DataOutput output) throws IOException {
212	super.write(output);	211	super.write(output);
213	assert this.body != null: "null body in " + this.getQualifiedName();	212	assert this.body != null: "null body in " + this.getQualifiedName();
214	PersistentUtils.writeCompoundStatement(body, output);	213	PersistentUtils.writeCompoundStatement(body, output);
215	}	214	}
216		215
217	public FunctionDDImpl(DataInput input) throws IOException {	216	public FunctionDDImpl(DataInput input) throws IOException {
218	super(input);	217	super(input);
219	this.body = PersistentUtils.readCompoundStatement(input);	218	this.body = PersistentUtils.readCompoundStatement(input);
220	assert this.body != null: "read null body for " + this.getName();	219	assert this.body != null: "read null body for " + this.getName();
221	}	220	}
222	}	221	}
223		222




            ((Disposable) body).dispose();
        }
    }

    @Override
    public CsmCompoundStatement getBody() {
        return body;

        return (CsmFunction) def;
    }

    private CsmFunction findByNameAndParamsNumber(Iterator declarations, CharSequence name, int paramsNumber) {
        CsmFunction out = null;
        for (Iterator it = declarations; it.hasNext();) {
            Object o = it.next();
            if (CsmKindUtilities.isCsmObject(o) && CsmKindUtilities.isFunction((CsmObject) o)) {
                CsmFunction decl = (CsmFunction) o;
                if (decl.getName().equals(name) && !FunctionImplEx.isFakeFunction(decl)) {
                    if (FunctionImpl.isObjectVisibleInFile(getContainingFile(), decl)) {
                        if (decl.getParameters().size() == paramsNumber) {
                            out = decl;
                            break;
                        }
                        if (out == null) {
                            out = decl;
                        }
                    }
                }
            }




 * @param T
 * @author Dmitriy Ivanov, Vladimir Kvashin
 */
public class FunctionImpl<T> extends OffsetableDeclarationBase<T>
        implements CsmFunction, Disposable, RawNamable, CsmTemplate {

    private static final String OPERATOR = "operator"; // NOI18N;

    private final CharSequence name;
    private final CsmType returnType;
//    private final Collection<CsmUID<CsmParameter>>  parameters;
    private final FunctionParameterListImpl parameterList;
    private CharSequence signature;

    // only one of scopeRef/scopeAccessor must be used
    private /*final*/ CsmScope scopeRef;// can be set in onDispose or contstructor only
    private CsmUID<CsmScope> scopeUID;

    private final CharSequence[] rawName;

    private TemplateDescriptor templateDescriptor = null;

    protected final CharSequence classTemplateSuffix;

    private static final byte FLAGS_VOID_PARMLIST = 1 << 0;
    private static final byte FLAGS_STATIC = 1 << 1;
    private static final byte FLAGS_CONST = 1 << 2;

    private static final byte FLAGS_INVALID = 1 << 4;
    protected static final int LAST_USED_FLAG_INDEX = 4;
    private byte flags;

    private static final boolean CHECK_SCOPE = false;

    public FunctionImpl(AST ast, CsmFile file, CsmScope scope, boolean register, boolean global) throws AstRendererException {


        super(ast, file);
        assert !CHECK_SCOPE || (scope != null);

        name = QualifiedNameCache.getManager().getString(initName(ast));
        if (name.length()==0) {
            throw new AstRendererException((FileImpl)file, this.getStartOffset(), "Empty function name."); // NOI18N

        if (child != null) {
            setStatic(child.getType() == CPPTokenTypes.LITERAL_static);
        } else {
            System.err.println("function ast " + ast.getText() + " without childs in file " + file.getAbsolutePath());
        }
        if (!isStatic()) {
            CsmFilter filter = CsmSelect.getFilterBuilder().createNameFilter(

                if( name.equals(fun.getName()) ) {
                    // we don't check signature here since file-level statics
                    // is C-style construct
                    setStatic(true);
                    break;
                }
            }
        }

        // change scope to file for static methods, but only to prevent
        // registration in global  namespace
        if(scope instanceof CsmNamespace) {
            if( !NamespaceImpl.isNamespaceScope(this) ) {

        } else {
            setFlags(FLAGS_VOID_PARMLIST, false);
        }
        if (name.toString().startsWith(OPERATOR) &&
                (name.length() > OPERATOR.length()) &&
                !Character.isJavaIdentifierPart(name.charAt(OPERATOR.length()))) { // NOI18N
            setFlags(FLAGS_OPERATOR, true);

            assert (scopeUID != null || scope == null);
        } else {
            this.scopeRef = scope;
        }
    }

    /**

    protected boolean hasFlags(byte mask) {
        return (flags & mask) == mask;
    }

    protected final void setFlags(byte mask, boolean value) {
        if (value) {
            flags |= mask;
        } else {
            flags &= ~mask;
        }
    }

    public final boolean isStatic() {
        return hasFlags(FLAGS_STATIC);
    }

    protected final void setStatic(boolean value) {
        setFlags(FLAGS_STATIC, value);
    }

    private AST findParameterNode(AST node) {
        AST ast = AstUtil.findChildOfType(node, CPPTokenTypes.CSM_PARMLIST);
        if (ast != null) {

        }
        return ast;
    }

    protected CharSequence getScopeSuffix() {
        return classTemplateSuffix != null ? classTemplateSuffix : CharSequences.empty();
    }

    protected final CharSequence[] initRawName(AST node) {
        return findFunctionRawName(node);
    }

    public CharSequence getDisplayName() {
        return (templateDescriptor != null) ? CharSequences.create((getName().toString() + templateDescriptor.getTemplateSuffix())) : getName(); // NOI18N
    }

    public List<CsmTemplateParameter> getTemplateParameters() {
        return (templateDescriptor != null) ? templateDescriptor.getTemplateParameters() : Collections.<CsmTemplateParameter>emptyList();
    }

    public List<CsmTemplateParameter> getInheritedTemplateParameters() {
        List<CsmTemplateParameter> allTemplateParams = getTemplateParameters();

    public boolean isVoidParameterList(){
        return hasFlags(FLAGS_VOID_PARMLIST);
    }

    private static String extractName(AST token){
        int type = token.getType();
        if( type == CPPTokenTypes.ID ) {

        }
        return "";
    }

    private static String findFunctionName(AST ast) {
        if( CastUtils.isCast(ast) ) {
            return CastUtils.getFunctionName(ast);

            return CastUtils.getFunctionRawName(ast);
        }
        return AstUtil.getRawNameInChildren(ast);
    }

    protected boolean isCStyleStatic() {
        return isStatic() && CsmKindUtilities.isFile(getScope());
    }

    protected void registerInProject() {
        if (isCStyleStatic()) {
            // do NOT register in project C-style static funcions!

            ((ProjectBase) project).registerDeclaration(this);
        }
    }

    private void unregisterInProject() {
        CsmProject project = getContainingFile().getProject();
        if( project instanceof ProjectBase ) {

            this.cleanUID();
        }
    }


    /** Gets this element name
     * @return name
     */
    public CharSequence getName() {
        return name;
    }

    public CharSequence getQualifiedName() {
        CsmScope scope = getScope();
        if( (scope instanceof CsmNamespace) || (scope instanceof CsmClass) || (scope instanceof CsmNamespaceDefinition) ) {

        }
        return getName();
    }

    public CharSequence[] getRawName() {
        return rawName;
    }

    @Override
    public CharSequence getUniqueNameWithoutPrefix() {
        return getQualifiedName().toString() + getSignature().toString().substring(getName().length());

    public Kind getKind() {
        return CsmDeclaration.Kind.FUNCTION;
    }

    /** Gets this function's declaration text
     * @return declaration text
     */

        }
        return def;
    }

    // method try to find definition in case cast operator definition is declared without scope
    private CsmDeclaration fixCastOperator(CsmProject prj, String uname) {
        int i = uname.indexOf("operator "); // NOI18N

        return null;
    }

    public static boolean isObjectVisibleInFile(CsmFile currentFile, CsmOffsetableDeclaration item) {
        CsmFile file = item.getContainingFile();
        if (file.equals(currentFile)) {
            return true;
        }
        return ((ProjectBase) currentFile.getProject()).getGraphStorage().isFileIncluded(currentFile, file);
    }

    private CsmFunctionDefinition findDefinition(CsmProject prj, String uname){
        Collection<CsmOffsetableDeclaration> defs = prj.findDeclarations(uname);
        CsmDeclaration res = null;
        if (defs.isEmpty()) {
            if (isOperator()) {
                res = fixCastOperator(prj, uname);
            }
        } else if (defs.size() == 1) {
            res = defs.iterator().next();
        } else {
            for(CsmOffsetableDeclaration decl : defs) {
                if (decl  instanceof CsmFunctionDefinition) {
                    if (isObjectVisibleInFile(decl.getContainingFile(), this)) {
                        res = decl;
                        break;
                    }
                    if (res == null) {
                        res = decl;
                    }
                }
            }
        }
        if (res instanceof CsmFunctionDefinition) {
            return (CsmFunctionDefinition)res;

        }
        return null;
    }

    /**
     * Returns true if this class is template, otherwise false.
     * @return flag indicated if function is template

    public boolean isTemplate() {
        return templateDescriptor != null;
    }

    /**
     * Gets this function body.
     * The same as the following call:

    public CsmCompoundStatement getBody() {
        return null;
    }

    public boolean isInline() {
        return false;
    }

//    public boolean isVirtual() {
//        return false;
//    }

//    public boolean isExplicit() {
//        return false;
//    }

    private CsmType initReturnType(AST node) {
        CsmType ret = null;
        AST token = getTypeToken(node);

        }
        return TemplateUtils.checkTemplateType(ret, FunctionImpl.this);
    }

    public CsmType getReturnType() {
        return returnType;
    }

    private static AST getTypeToken(AST node) {
        for( AST token = node.getFirstChild(); token != null; token = token.getNextSibling() ) {
            int type = token.getType();

    private FunctionParameterListImpl createParameterList(AST funAST, boolean isLocal) {
        return FunctionParameterListImpl.create(getContainingFile(), funAST, this, isLocal);
    }

    private boolean isVoidParameter(AST node) {
        AST ast = findParameterNode(node);
        return AstRenderer.isVoidParameter(ast);

    public Collection<CsmParameter>  getParameters() {
        return _getParameters();
    }

    public CsmScope getScope() {
        return _getScope();
    }

    public CharSequence getSignature() {
        if( signature == null ) {
            signature = QualifiedNameCache.getManager().getString(createSignature());

    public CsmFunction getDeclaration() {
        return this;
    }

    public boolean isOperator() {
        return hasFlags(FLAGS_OPERATOR);
    }

    public OperatorKind getOperatorKind() {
        OperatorKind out = OperatorKind.NONE;
        if (isOperator()) {

                out = (binaryKind != OperatorKind.NONE) ? binaryKind : nonBinaryKind;
            }
        }
        return out;
    }

    public Collection<CsmScopeElement> getScopeElements() {
        Collection<CsmScopeElement> l = new ArrayList<CsmScopeElement>();
        l.addAll(getParameters());
        return l;
    }

    private CharSequence createSignature() {
        // TODO: this fake implementation for Deimos only!
        // we should resolve parameter types and provide

    private void appendTemplateSignature(StringBuilder sb) {
        InstantiationProviderImpl.appendTemplateParamsSignature(getOwnTemplateParameters(), sb);
    }

    @Override
    public void dispose() {
        super.dispose();

            assert (this.scopeRef != null || this.scopeUID == null) : "empty scope for UID " + this.scopeUID;
        }
    }

    private static boolean initConst(AST node) {
        AST token = node.getFirstChild();
        while( token != null &&  token.getType() != CPPTokenTypes.CSM_QUALIFIED_ID) {

        }
        return false;
    }

    /**
     * isConst was originally in MethodImpl;
     * but this methods needs internally in FunctionDefinitionImpl

    protected boolean isConst() {
        return hasFlags(FLAGS_CONST);
    }

    private synchronized CsmScope _getScope() {
        CsmScope scope = this.scopeRef;
        if (scope == null) {

        }
        return scope;
    }

    private Collection<CsmParameter> _getParameters() {
        if (this.parameterList == null) {
            return Collections.<CsmParameter>emptyList();

            return this.parameterList.getNrParameters();
        }
    }

    private void _disposeParameters() {
        if (this.parameterList != null) {
            parameterList.dispose();
        }
    }

    ////////////////////////////////////////////////////////////////////////////
    // iml of SelfPersistent

    @Override
    public void write(DataOutput output) throws IOException {
        super.write(output);

        UIDObjectFactory factory = UIDObjectFactory.getDefaultFactory();
        PersistentUtils.writeParameterList(this.parameterList, output);
        PersistentUtils.writeStrings(this.rawName, output);

        // not null UID
        assert !CHECK_SCOPE || this.scopeUID != null;
        factory.writeUID(this.scopeUID, output);

        PersistentUtils.writeUTF(this.signature, output);
        output.writeByte(flags);
        PersistentUtils.writeUTF(getScopeSuffix(), output);

        UIDObjectFactory factory = UIDObjectFactory.getDefaultFactory();
        this.parameterList = (FunctionParameterListImpl) PersistentUtils.readParameterList(input);
        this.rawName = PersistentUtils.readStrings(input, NameCache.getManager());

        this.scopeUID = factory.readUID(input);
        // not null UID
        assert !CHECK_SCOPE || this.scopeUID != null;
        this.scopeRef = null;

        this.signature = PersistentUtils.readUTF(input, QualifiedNameCache.getManager());
        this.flags = input.readByte();
        this.classTemplateSuffix = PersistentUtils.readUTF(input, NameCache.getManager());

Return to bug 187070

Lines 86-92 Link Here

(-)a/cnd.modelimpl/src/org/netbeans/modules/cnd/modelimpl/csm/FunctionDefinitionImpl.java (-11 / +11 lines)
86	((Disposable) body).dispose();	86	((Disposable) body).dispose();
87	}	87	}
88	}	88	}
89		89
90	@Override	90	@Override
91	public CsmCompoundStatement getBody() {	91	public CsmCompoundStatement getBody() {
92	return body;	92	return body;
Lines 183-203 Link Here
183	return (CsmFunction) def;	183	return (CsmFunction) def;
184	}	184	}
185		185
186	private static CsmFunction findByNameAndParamsNumber(Iterator declarations, CharSequence name, int paramsNumber) {	186	private CsmFunction findByNameAndParamsNumber(Iterator declarations, CharSequence name, int paramsNumber) {
187	CsmFunction out = null;	187	CsmFunction out = null;
188	for (Iterator it = declarations; it.hasNext();) {	188	for (Iterator it = declarations; it.hasNext();) {
189	Object o = it.next();	189	Object o = it.next();
190	if (CsmKindUtilities.isCsmObject(o) && CsmKindUtilities.isFunction((CsmObject) o)) {	190	if (CsmKindUtilities.isCsmObject(o) && CsmKindUtilities.isFunction((CsmObject) o)) {
191	CsmFunction decl = (CsmFunction) o;	191	CsmFunction decl = (CsmFunction) o;
192	if (decl.getName().equals(name) && decl.getParameters().size() == paramsNumber) {	192	if (decl.getName().equals(name) && !FunctionImplEx.isFakeFunction(decl)) {
193	out = decl;	193	if (FunctionImpl.isObjectVisibleInFile(getContainingFile(), decl)) {
194	if (!FunctionImplEx.isFakeFunction(decl)) {	194	if (decl.getParameters().size() == paramsNumber) {
195	break;	195	out = decl;
196	}	196	break;
197	}	197	}
198	if (out == null && decl.getName().equals(name)) {	198	if (out == null) {
199	if (!FunctionImplEx.isFakeFunction(decl)) {	199	out = decl;
200	out = decl;	200	}
201	}	201	}
202	}	202	}
203	}	203	}