core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTNameBase.java

/*******************************************************************************
 * Copyright (c) 2008, 2014 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.cpp;

import java.util.regex.Pattern;

import org.eclipse.cdt.core.dom.ILinkage;
import org.eclipse.cdt.core.dom.ast.IASTCompletionContext;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTNameOwner;
import org.eclipse.cdt.core.dom.ast.IASTNode;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.IProblemBinding;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTName;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTNameSpecifier;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTQualifiedName;
import org.eclipse.cdt.internal.core.dom.Linkage;
import org.eclipse.cdt.internal.core.dom.parser.ASTNode;
import org.eclipse.cdt.internal.core.dom.parser.IASTInternalNameOwner;
import org.eclipse.cdt.internal.core.dom.parser.IRecursionResolvingBinding;
import org.eclipse.cdt.internal.core.dom.parser.ProblemBinding;
import org.eclipse.core.runtime.Assert;

/**
 * Common base class for all sorts of c++ names: unqualified, qualified, operator and conversion
 * names plus template-ids
 */
public abstract class CPPASTNameBase extends ASTNode implements ICPPASTName {
	protected static final Pattern WHITESPACE_SEQ = Pattern.compile("\\s+"); //$NON-NLS-1$

	/**
	 * For test-purposes, only.
	 */
	public static boolean sAllowRecursionBindings = true;
	public static boolean sAllowNameComputation = true;
	private static final byte MAX_RESOLUTION_DEPTH= 6;

	protected final static class RecursionResolvingBinding extends ProblemBinding implements IRecursionResolvingBinding {
		public RecursionResolvingBinding(IASTName node, char[] arg) {
			super(node, IProblemBinding.SEMANTIC_RECURSION_IN_LOOKUP, arg);
			Assert.isTrue(sAllowRecursionBindings, getMessage());
		}
	}

	private RecursionResolvingBinding createRecursionResolvingBinding() {
		// We create a recursion resolving binding when the resolution depth
		// exceeds MAX_RESOLUTION_DEPTH. If the resolution depth exceeds
		// MAX_RESOLUTION_DEPTH + 1, it means that attempting to create the
		// recursion resolving binding has led us back to trying to resolve
		// the binding for this name again, so the recursion isn't broken.
		// This can happen because the constructor of RecursionResolvingBinding
		// calls ProblemBinding.getMessage(), which can try to do name
		// resolution to build an argument string if one wasn't provided in the
		// ProblemBinding constructor. To break the recursion in a case
		// like, this we provide the argument string "(unknown)" instead.
		char[] args = (fResolutionDepth > MAX_RESOLUTION_DEPTH + 1) ? "(unknown)".toCharArray() : null;  //$NON-NLS-1$
		return new RecursionResolvingBinding(this, args);
	}

	private IBinding fBinding;
	private byte fResolutionDepth;
	private boolean fIsFinal;

	public final void incResolutionDepth() {
		if (fBinding == null && ++fResolutionDepth > MAX_RESOLUTION_DEPTH) {
			setBinding(createRecursionResolvingBinding());
		}
	}

	/**
	 * Called to perform the binding resolution. Subclasses may return lazy bindings that
	 * will not be exposed within public API.
	 */
	protected abstract IBinding createIntermediateBinding();

	/**
	 * Resolves the name at least up to the intermediate binding and returns it.
	 * @see ICPPTwoPhaseBinding
	 */
	@Override
	public IBinding resolvePreBinding() {
    	if (fBinding == null) {
    		if (++fResolutionDepth > MAX_RESOLUTION_DEPTH) {
    			setBinding(createRecursionResolvingBinding());
    		} else {
    			setBinding(createIntermediateBinding());
    		}
    	}
    	return fBinding;
	}

    @Override
	public IBinding resolveBinding() {
    	if (fBinding == null) {
    		if (++fResolutionDepth > MAX_RESOLUTION_DEPTH) {
    			setBinding(createRecursionResolvingBinding());
    		} else {
    			fIsFinal= false;
    			final IBinding b= createIntermediateBinding();
    			if (b instanceof ProblemBinding) {
    				ProblemBinding pb= (ProblemBinding) b;
    				final IASTNode node= pb.getASTNode();
    				if (node == null || node.getParent() == null) {
    					pb.setASTNode(this);
    				}
    			}
    			setBinding(b);
    		}
    	}
    	if (!fIsFinal)
    		resolveFinalBinding(this);

    	return fBinding;
    }

    /**
     * If this name has not yet been resolved at all, <code>null</code> will be returned.
     * Otherwise the intermediate or final binding for this name is returned.
     * @see ICPPTwoPhaseBinding
     */
    @Override
	public IBinding getPreBinding() {
        return fBinding;
    }

    /**
     * If this name has not yet been resolved at all, <code>null</code> will be returned.
     * Otherwise the final binding for this name is returned.
     * @see ICPPTwoPhaseBinding
     */
    @Override
	public IBinding getBinding() {
    	final IBinding cand= fBinding;
        if (cand == null)
        	return null;

        if (!fIsFinal)
        	resolveFinalBinding(this);

        return fBinding;
    }

	private void resolveFinalBinding(CPPASTNameBase astName) {
		if (fBinding instanceof ICPPTwoPhaseBinding) {
    		ICPPTwoPhaseBinding intermediateBinding= (ICPPTwoPhaseBinding) fBinding;
    		if (++fResolutionDepth > MAX_RESOLUTION_DEPTH) {
    			setBinding(createRecursionResolvingBinding());
    		} else {
    			setBinding(intermediateBinding.resolveFinalBinding(astName));
    		}
    	}
		fIsFinal= true;
	}

	@Override
	public void setBinding(IBinding binding) {
		fBinding= binding;
		fResolutionDepth= 0;
	}

	@Override
	public IASTName getLastName() {
		return this;
	}

	@Override
	public boolean isQualified() {
		IASTNode parent= getParent();
		if (parent instanceof ICPPASTQualifiedName) {
			ICPPASTQualifiedName qn= (ICPPASTQualifiedName) parent;
			if (qn.isFullyQualified())
				return true;
			ICPPASTNameSpecifier[] qualifier = qn.getQualifier();
			if (qualifier.length > 0 && qualifier[0] == this)
				return false;
			return true;
		}
		return false;
	}

	@Override
	public final String toString() {
		return new String(toCharArray());
	}

	@Override
	public IASTCompletionContext getCompletionContext() {
        IASTNode node = getParent();
    	while (node != null) {
    		if (node instanceof IASTCompletionContext) {
    			return (IASTCompletionContext) node;
    		}
    		node = node.getParent();
    	}

    	return null;
	}

	@Override
	public int getRoleOfName(boolean allowResolution) {
        IASTNode parent = getParent();
        if (parent instanceof IASTInternalNameOwner) {
        	return ((IASTInternalNameOwner) parent).getRoleForName(this, allowResolution);
        }
        if (parent instanceof IASTNameOwner) {
            return ((IASTNameOwner) parent).getRoleForName(this);
        }
        return IASTNameOwner.r_unclear;
	}

    @Override
	public boolean isDeclaration() {
        IASTNode parent = getParent();
        if (parent instanceof IASTNameOwner) {
            int role = ((IASTNameOwner) parent).getRoleForName(this);
            switch (role) {
            case IASTNameOwner.r_reference:
            case IASTNameOwner.r_unclear:
                return false;
            default:
                return true;
            }
        }
        return false;
    }

    @Override
	public boolean isReference() {
        IASTNode parent = getParent();
        if (parent instanceof IASTNameOwner) {
            int role = ((IASTNameOwner) parent).getRoleForName(this);
            return role == IASTNameOwner.r_reference;
        }
        return false;
    }

    @Override
	public boolean isDefinition() {
        IASTNode parent = getParent();
        if (parent instanceof IASTNameOwner) {
            int role = ((IASTNameOwner) parent).getRoleForName(this);
            return role == IASTNameOwner.r_definition;
        }
        return false;
    }

	@Override
	public ILinkage getLinkage() {
		return Linkage.CPP_LINKAGE;
	}
}