/*******************************************************************************
 * Copyright (c) 2004, 2012 IBM Corporation 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:
 *     IBM Rational Software - Initial API and implementation
 *     Markus Schorn (Wind River Systems)
 *     Sergey Prigogin (Google)
 *******************************************************************************/
package org.eclipse.cdt.internal.core.dom.parser.c;

import org.eclipse.cdt.core.dom.ILinkage;
import org.eclipse.cdt.core.dom.ast.IASTDeclSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTDeclarator;
import org.eclipse.cdt.core.dom.ast.IASTFunctionDeclarator;
import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTNode;
import org.eclipse.cdt.core.dom.ast.IASTParameterDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTStandardFunctionDeclarator;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.IFunction;
import org.eclipse.cdt.core.dom.ast.IFunctionType;
import org.eclipse.cdt.core.dom.ast.IParameter;
import org.eclipse.cdt.core.dom.ast.IProblemBinding;
import org.eclipse.cdt.core.dom.ast.IScope;
import org.eclipse.cdt.core.dom.ast.IType;
import org.eclipse.cdt.core.dom.ast.gnu.c.ICASTKnRFunctionDeclarator;
import org.eclipse.cdt.core.parser.util.ArrayUtil;
import org.eclipse.cdt.core.parser.util.AttributeUtil;
import org.eclipse.cdt.core.parser.util.CharArrayUtils;
import org.eclipse.cdt.internal.core.dom.Linkage;
import org.eclipse.cdt.internal.core.dom.parser.ASTQueries;
import org.eclipse.core.runtime.PlatformObject;

/**
 * Represents a function.
 */
public class CFunction extends PlatformObject implements IFunction, ICInternalFunction {
	private IASTDeclarator[] declarators;
	private IASTFunctionDeclarator definition;

	private static final int FULLY_RESOLVED         = 1;
	private static final int RESOLUTION_IN_PROGRESS = 1 << 1;
	private int bits = 0;

	protected IFunctionType type;

	public CFunction(IASTDeclarator declarator) {
		storeDeclarator(declarator);
	}

	private void storeDeclarator(IASTDeclarator declarator) {
		if (declarator != null) {
			if (declarator instanceof ICASTKnRFunctionDeclarator) {
				definition = (IASTFunctionDeclarator) declarator;
			} else if (declarator instanceof IASTFunctionDeclarator
					&& ASTQueries.findOutermostDeclarator(declarator).getParent() instanceof IASTFunctionDefinition) {
				definition = (IASTFunctionDeclarator) declarator;
			} else {
				declarators = ArrayUtil.append(IASTDeclarator.class, declarators, declarator);
			}
		}
	}

	@Override
	public IASTDeclarator getPhysicalNode() {
		if (definition != null) {
			return definition;
		} else if (declarators != null && declarators.length > 0) {
			return declarators[0];
		}
		return null;
	}

	@Override
	public void addDeclarator(IASTDeclarator fnDeclarator) {
		if (!fnDeclarator.isActive())
			return;

		if (fnDeclarator instanceof IASTFunctionDeclarator) {
			updateParameterBindings((IASTFunctionDeclarator) fnDeclarator);
		}
		storeDeclarator(fnDeclarator);
	}

    protected IASTTranslationUnit getTranslationUnit() {
		if (definition != null) {
            return definition.getTranslationUnit();
		} else if (declarators != null) {
            return declarators[0].getTranslationUnit();
		}
		return null;
    }

    private void resolveAllDeclarations() {
	    if ((bits & (FULLY_RESOLVED | RESOLUTION_IN_PROGRESS)) == 0) {
	        bits |= RESOLUTION_IN_PROGRESS;
		    IASTTranslationUnit tu = getTranslationUnit();
	        if (tu != null) {
	            CVisitor.getDeclarations(tu, this);
	        }
			declarators = ArrayUtil.trim(IASTDeclarator.class, declarators);
	        bits |= FULLY_RESOLVED;
	        bits &= ~RESOLUTION_IN_PROGRESS;
	    }
	}

	/* (non-Javadoc)
	 * @see org.eclipse.cdt.core.dom.ast.IFunction#getParameters()
	 */
	@Override
	public IParameter[] getParameters() {
		int j= -1;
		int len = declarators != null ? declarators.length : 0;
		for (IASTDeclarator dtor = definition; j < len; j++) {
			if (j >= 0) {
				dtor = declarators[j];
			}
			if (dtor instanceof IASTStandardFunctionDeclarator) {
				IASTParameterDeclaration[] params = ((IASTStandardFunctionDeclarator) dtor).getParameters();
				int size = params.length;
				IParameter[] result = new IParameter[size];
				if (size > 0) {
					for (int i = 0; i < size; i++) {
						IASTParameterDeclaration p = params[i];
						result[i] = (IParameter) ASTQueries.findInnermostDeclarator(p.getDeclarator())
								.getName().resolveBinding();
					}
				}
				return result;
			}
			if (dtor instanceof ICASTKnRFunctionDeclarator) {
				IASTName[] names = ((ICASTKnRFunctionDeclarator) dtor).getParameterNames();
				IParameter[] result = new IParameter[names.length];
				if (names.length > 0) {
					// Ensures that the list of parameters is created in the same order as the K&R C parameter
					// names
					for (int i = 0; i < names.length; i++) {
						IASTDeclarator decl = CVisitor.getKnRParameterDeclarator(
								(ICASTKnRFunctionDeclarator) dtor, names[i]);
						if (decl != null) {
							result[i] = (IParameter) decl.getName().resolveBinding();
						} else {
							result[i] = new CParameter.CParameterProblem(names[i],
									IProblemBinding.SEMANTIC_KNR_PARAMETER_DECLARATION_NOT_FOUND,
									names[i].toCharArray());
						}
					}
				}
				return result;
			}
		}

		if ((bits & (FULLY_RESOLVED | RESOLUTION_IN_PROGRESS)) == 0) {
			resolveAllDeclarations();
			return getParameters();
		}

		return CBuiltinParameter.createParameterList(getType());
	}

	@Override
	public String getName() {
		return getASTName().toString();
	}

	@Override
	public char[] getNameCharArray() {
		return getASTName().toCharArray();
	}

	private IASTName getASTName() {
		return ASTQueries.findInnermostDeclarator(getPhysicalNode()).getName();
	}

	@Override
	public IScope getScope() {
	    IASTDeclarator dtor = getPhysicalNode();
		if (dtor != null)
			return CVisitor.getContainingScope(ASTQueries.findOutermostDeclarator(dtor).getParent());
	    return null;
	}

	@Override
	public IScope getFunctionScope() {
		if (definition != null) {
			IASTFunctionDefinition def = (IASTFunctionDefinition) definition.getParent();
			return def.getScope();
		}
		return null;
	}

    @Override
	public IFunctionType getType() {
		if (type == null) {
			type = createType();
		}
        return type;
    }

	protected IFunctionType createType() {
		IASTDeclarator declarator = getPhysicalNode();
		if (declarator == null && (bits & FULLY_RESOLVED) == 0) {
			resolveAllDeclarations();
			declarator = getPhysicalNode();
		}
		if (declarator != null) {
			IType tempType = CVisitor.unwrapTypedefs(CVisitor.createType(declarator));
			if (tempType instanceof IFunctionType)
				return (IFunctionType) tempType;
		}
		return null;
	}

    public IBinding resolveParameter(IASTName paramName) {
    	if (paramName.getBinding() != null)
    	    return paramName.getBinding();

    	IBinding binding = null;
    	int idx = 0;
    	IASTNode parent = paramName.getParent();
    	while (parent instanceof IASTDeclarator && !(parent instanceof ICASTKnRFunctionDeclarator))
    	    parent = parent.getParent();

    	ICASTKnRFunctionDeclarator fKnRDtor = null;
    	IASTDeclarator knrParamDtor = null;
    	if (parent instanceof IASTParameterDeclaration) {
    	    IASTStandardFunctionDeclarator fdtor = (IASTStandardFunctionDeclarator) parent.getParent();
    	    IASTParameterDeclaration [] ps = fdtor.getParameters();
        	for (; idx < ps.length; idx++) {
        		if (parent == ps[idx])
        			break;
        	}
    	} else if (parent instanceof IASTSimpleDeclaration) {
    	    //KnR: name in declaration list
    	    fKnRDtor = (ICASTKnRFunctionDeclarator) parent.getParent();
    	    IASTName [] ps = fKnRDtor.getParameterNames();
    	    char [] n = paramName.toCharArray();
        	for (; idx < ps.length; idx++) {
        		if (CharArrayUtils.equals(ps[idx].toCharArray(), n))
        			break;
        	}
    	} else {
    	    //KnR: name in name list
    	    fKnRDtor = (ICASTKnRFunctionDeclarator) parent;
    	    IASTName [] ps = fKnRDtor.getParameterNames();
        	for (; idx < ps.length; idx++) {
        		if (ps[idx] == paramName)
        			break;
        	}
        	knrParamDtor = CVisitor.getKnRParameterDeclarator(fKnRDtor, paramName);
            if (knrParamDtor != null)
                paramName = knrParamDtor.getName();
    	}

    	//create a new binding and set it for the corresponding parameter in all known defns and decls
    	binding = new CParameter(paramName);
    	IASTParameterDeclaration temp = null;
    	if (definition != null) {
    	    if (definition instanceof IASTStandardFunctionDeclarator) {
    	    	IASTParameterDeclaration [] parameters = ((IASTStandardFunctionDeclarator)definition).getParameters();
    	    	if (parameters.length > idx) {
	    	        temp = parameters[idx];
	    	        ASTQueries.findInnermostDeclarator(temp.getDeclarator()).getName().setBinding(binding);
    	    	}
    	    } else if (definition instanceof ICASTKnRFunctionDeclarator) {
    	    	fKnRDtor = (ICASTKnRFunctionDeclarator) definition;
    	    	IASTName [] parameterNames = fKnRDtor.getParameterNames();
    	    	if (parameterNames.length > idx) {
	    	        IASTName n = parameterNames[idx];
	    	        n.setBinding(binding);
	    	        IASTDeclarator dtor = CVisitor.getKnRParameterDeclarator(fKnRDtor, n);
	    	        if (dtor != null) {
	    	            dtor.getName().setBinding(binding);
	    	        }
    	    	}
    	    }
    	}
    	if (declarators != null) {
    		for (IASTDeclarator dtor : declarators) {
    			if (dtor instanceof IASTStandardFunctionDeclarator) {
    				IASTStandardFunctionDeclarator fdtor= (IASTStandardFunctionDeclarator) dtor;
    				if (fdtor.getParameters().length > idx) {
    					temp = fdtor.getParameters()[idx];
    					ASTQueries.findInnermostDeclarator(temp.getDeclarator()).getName().setBinding(binding);
    				}
    			}
    		}
    	}
    	return binding;
    }

    protected void updateParameterBindings(IASTFunctionDeclarator fdtor) {
        IParameter [] params = getParameters();
        if (fdtor instanceof IASTStandardFunctionDeclarator) {
        	IASTParameterDeclaration [] nps = ((IASTStandardFunctionDeclarator)fdtor).getParameters();
        	if (params.length < nps.length)
        	    return;
        	for (int i = 0; i < nps.length; i++) {
        		IASTName name = ASTQueries.findInnermostDeclarator(nps[i].getDeclarator()).getName();
        		name.setBinding(params[i]);
        		if (params[i] instanceof CParameter)
        			((CParameter)params[i]).addDeclaration(name);
        	}
        } else {
            IASTName [] ns = ((ICASTKnRFunctionDeclarator)fdtor).getParameterNames();
            if (params.length > 0 && params.length != ns.length)
                return; //problem

            for (int i = 0; i < params.length; i++) {
            	IASTName name = ns[i];
            	name.setBinding(params[i]);
            	IASTDeclarator dtor = CVisitor.getKnRParameterDeclarator((ICASTKnRFunctionDeclarator) fdtor, name);
    			if (dtor != null) {
    			    dtor.getName().setBinding(params[i]);
    			    if (params[i] instanceof CParameter)
    			    	((CParameter)params[i]).addDeclaration(dtor.getName());
    			}
        	}
        }
    }

    @Override
	public boolean isStatic() {
    	return isStatic(true);
    }

    @Override
	public boolean isStatic(boolean resolveAll) {
        if (resolveAll && (bits & FULLY_RESOLVED) == 0) {
            resolveAllDeclarations();
        }
		return hasStorageClass(IASTDeclSpecifier.sc_static);
    }

	public boolean hasStorageClass(int storage) {
	    IASTDeclarator dtor = definition;
	    IASTDeclarator[] ds = declarators;

        int i = -1;
        do {
            if (dtor != null) {
	            IASTNode parent = dtor.getParent();
	            while (!(parent instanceof IASTDeclaration))
	                parent = parent.getParent();

	            IASTDeclSpecifier declSpec = null;
	            if (parent instanceof IASTSimpleDeclaration) {
	                declSpec = ((IASTSimpleDeclaration)parent).getDeclSpecifier();
	            } else if (parent instanceof IASTFunctionDefinition)
	                declSpec = ((IASTFunctionDefinition)parent).getDeclSpecifier();

	            if (declSpec != null && declSpec.getStorageClass() == storage) {
	            	return true;
	            }
            }

            if (ds != null && ++i < ds.length) {
                dtor = ds[i];
            } else {
            	break;
            }
        } while (dtor != null);
        return false;
	}

    @Override
	public boolean isExtern() {
    	return isExtern(true);
    }

    public boolean isExtern(boolean resolveAll) {
        if (resolveAll && (bits & FULLY_RESOLVED) == 0) {
            resolveAllDeclarations();
        }
        return hasStorageClass(IASTDeclSpecifier.sc_extern);
    }

    @Override
	public boolean isAuto() {
        if ((bits & FULLY_RESOLVED) == 0) {
            resolveAllDeclarations();
        }
        return hasStorageClass(IASTDeclSpecifier.sc_auto);
    }

    @Override
	public boolean isRegister() {
        if ((bits & FULLY_RESOLVED) == 0) {
            resolveAllDeclarations();
        }
        return hasStorageClass(IASTDeclSpecifier.sc_register);
    }

    @Override
	public boolean isInline() {
        if ((bits & FULLY_RESOLVED) == 0) {
            resolveAllDeclarations();
        }
	    IASTDeclarator dtor = definition;
	    IASTDeclarator[] ds = declarators;
        int i = -1;
        do {
            if (dtor != null) {
	            IASTNode parent = dtor.getParent();
	            while (!(parent instanceof IASTDeclaration)) {
	                parent = parent.getParent();
	            }

	            IASTDeclSpecifier declSpec = null;
	            if (parent instanceof IASTSimpleDeclaration) {
	                declSpec = ((IASTSimpleDeclaration)parent).getDeclSpecifier();
	            } else if (parent instanceof IASTFunctionDefinition) {
	                declSpec = ((IASTFunctionDefinition)parent).getDeclSpecifier();
	            }

	            if (declSpec != null && declSpec.isInline())
	                return true;
            }
            if (ds != null && ++i < ds.length) {
                dtor = ds[i];
            } else {
                break;
            }
        } while (dtor != null);

        return false;
    }

	@Override
	public boolean takesVarArgs() {
		if ((bits & FULLY_RESOLVED) == 0) {
			resolveAllDeclarations();
		}

		if (definition != null) {
			if (definition instanceof IASTStandardFunctionDeclarator)
				return ((IASTStandardFunctionDeclarator) definition).takesVarArgs();
			return false;
		}

		if (declarators != null) {
			for (IASTDeclarator dtor : declarators) {
				if (dtor instanceof IASTStandardFunctionDeclarator) {
					return ((IASTStandardFunctionDeclarator) dtor).takesVarArgs();
				}
			}
		}
		return false;
	}

	@Override
	public void setFullyResolved(boolean resolved) {
		if (resolved) {
			bits |= FULLY_RESOLVED;
		} else {
			bits &= ~FULLY_RESOLVED;
		}
	}

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

	@Override
	public IASTDeclarator[] getDeclarations() {
		return declarators;
	}

	@Override
	public IASTFunctionDeclarator getDefinition() {
		return definition;
	}

	@Override
	public IBinding getOwner() {
		return null;
	}

	@Override
	public boolean isNoReturn() {
		IASTFunctionDeclarator dtor = getPreferredDtor();
		return dtor != null && AttributeUtil.hasNoreturnAttribute(dtor);
	}

	protected IASTFunctionDeclarator getPreferredDtor() {
		IASTFunctionDeclarator dtor = getDefinition();
        if (dtor != null)
        	return dtor;

        IASTDeclarator[] dtors = getDeclarations();
        if (dtors != null) {
        	for (IASTDeclarator declarator : dtors) {
        		if (declarator instanceof IASTFunctionDeclarator)
        			return (IASTFunctionDeclarator) declarator;
        	}
        }
        return null;
	}
}