X-Git-Url: http://git.phpeclipse.com diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/MethodDeclaration.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/MethodDeclaration.java index 45def4b..615fc04 100644 --- a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/MethodDeclaration.java +++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/MethodDeclaration.java @@ -1,103 +1,268 @@ -/******************************************************************************* - * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. 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 Corporation - initial API and implementation - ******************************************************************************/ package net.sourceforge.phpdt.internal.compiler.ast; -import net.sourceforge.phpdt.internal.compiler.CompilationResult; -import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor; -import net.sourceforge.phpdt.internal.compiler.lookup.*; -import net.sourceforge.phpdt.internal.compiler.parser.*; -import net.sourceforge.phpdt.internal.compiler.util.*; - -public class MethodDeclaration extends AbstractMethodDeclaration { - - public TypeReference returnType; - - /** - * MethodDeclaration constructor comment. - */ - public MethodDeclaration(CompilationResult compilationResult) { - super(compilationResult); - } - - - public void parseStatements(Parser parser, CompilationUnitDeclaration unit) { - - //fill up the method body with statement - if (ignoreFurtherInvestigation) - return; - parser.parse(this, unit); - } - - public void resolveStatements(ClassScope upperScope) { - - // ========= abort on fatal error ============= - if (this.returnType != null && this.binding != null) { - this.returnType.binding = this.binding.returnType; - // record the return type binding - } - // look if the name of the method is correct - if (binding != null && isTypeUseDeprecated(binding.returnType, scope)) - scope.problemReporter().deprecatedType(binding.returnType, returnType); - - if (CharOperation.equals(scope.enclosingSourceType().sourceName, selector)) - scope.problemReporter().methodWithConstructorName(this); - - // by grammatical construction, interface methods are always abstract - if (!scope.enclosingSourceType().isInterface()){ - - // if a method has an semicolon body and is not declared as abstract==>error - // native methods may have a semicolon body - if ((modifiers & AccSemicolonBody) != 0) { - if ((modifiers & AccNative) == 0) - if ((modifiers & AccAbstract) == 0) - scope.problemReporter().methodNeedingAbstractModifier(this); - } else { - // the method HAS a body --> abstract native modifiers are forbiden - if (((modifiers & AccNative) != 0) || ((modifiers & AccAbstract) != 0)) - scope.problemReporter().methodNeedingNoBody(this); - } - } - super.resolveStatements(upperScope); - } - - public String returnTypeToString(int tab) { - - if (returnType == null) - return ""; //$NON-NLS-1$ - return returnType.toString(tab) + " "; //$NON-NLS-1$ - } - - public void traverse( - IAbstractSyntaxTreeVisitor visitor, - ClassScope classScope) { - - if (visitor.visit(this, classScope)) { - if (returnType != null) - returnType.traverse(visitor, scope); - if (arguments != null) { - int argumentLength = arguments.length; - for (int i = 0; i < argumentLength; i++) - arguments[i].traverse(visitor, scope); - } - if (thrownExceptions != null) { - int thrownExceptionsLength = thrownExceptions.length; - for (int i = 0; i < thrownExceptionsLength; i++) - thrownExceptions[i].traverse(visitor, scope); - } - if (statements != null) { - int statementsLength = statements.length; - for (int i = 0; i < statementsLength; i++) - statements[i].traverse(visitor, scope); - } - } - visitor.endVisit(this, classScope); - } -} \ No newline at end of file +import net.sourceforge.phpdt.internal.compiler.parser.OutlineableWithChildren; +import net.sourceforge.phpdt.internal.compiler.parser.Outlineable; +import net.sourceforge.phpdt.internal.compiler.ast.declarations.VariableUsage; +import net.sourceforge.phpdt.internal.ui.PHPUiImages; +import net.sourceforge.phpeclipse.PHPeclipsePlugin; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.jface.text.Position; +import org.eclipse.core.runtime.CoreException; + +import java.util.Hashtable; +import java.util.Enumeration; +import java.util.ArrayList; +import java.util.List; + +import test.PHPParserSuperclass; + +/** + * A Method declaration. + * @author Matthieu Casanova + */ +public class MethodDeclaration extends Statement implements OutlineableWithChildren { + + /** The name of the method. */ + public char[] name; + public Hashtable arguments; + + + public Statement[] statements; + public int bodyStart; + public int bodyEnd = -1; + /** Tell if the method is a class constructor. */ + public boolean isConstructor; + + /** The parent object. */ + private Object parent; + /** The outlineable children (those will be in the node array too. */ + private ArrayList children = new ArrayList(); + + /** Tell if the method returns a reference. */ + public boolean reference; + + private Position position; + + public MethodDeclaration(final Object parent, + final char[] name, + final Hashtable arguments, + final boolean reference, + final int sourceStart, + final int sourceEnd) { + super(sourceStart, sourceEnd); + this.name = name; + this.arguments = arguments; + this.parent = parent; + this.reference = reference; + position = new Position(sourceStart, sourceEnd); + } + + /** + * Return method into String, with a number of tabs + * @param tab the number of tabs + * @return the String containing the method + */ + public String toString(final int tab) { + final StringBuffer buff = new StringBuffer(tabString(tab)); + buff.append(toStringHeader()); + buff.append(toStringStatements(tab + 1)); + return buff.toString(); + } + + public String toStringHeader() { + return "function " + toString(); + } + + /** + * Return the statements of the method into Strings + * @param tab the number of tabs + * @return the String containing the statements + */ + public String toStringStatements(final int tab) { + final StringBuffer buff = new StringBuffer(" {"); //$NON-NLS-1$ + if (statements != null) { + for (int i = 0; i < statements.length; i++) { + buff.append("\n").append(statements[i].toString(tab)); //$NON-NLS-1$ + if (!(statements[i] instanceof Block)) { + buff.append(";"); //$NON-NLS-1$ + } + } + } + buff.append("\n").append(tabString(tab == 0 ? 0 : tab - 1)).append("}"); //$NON-NLS-2$ //$NON-NLS-1$ + return buff.toString(); + } + + /** + * Get the image of a class. + * @return the image that represents a php class + */ + public ImageDescriptor getImage() { + return PHPUiImages.DESC_FUN; + } + + public void setParent(final Object parent) { + this.parent = parent; + } + + public Object getParent() { + return parent; + } + + public boolean add(final Outlineable o) { + return children.add(o); + } + + public Outlineable get(final int index) { + return (Outlineable) children.get(index); + } + + public int size() { + return children.size(); + } + + public String toString() { + final StringBuffer buff = new StringBuffer(); + if (reference) { + buff.append("&");//$NON-NLS-1$ + } + buff.append(name).append("(");//$NON-NLS-1$ + + if (arguments != null) { + final Enumeration values = arguments.elements(); + int i = 0; + while (values.hasMoreElements()) { + final VariableDeclaration o = (VariableDeclaration) values.nextElement(); + buff.append(o.toStringExpression()); + if (i != (arguments.size() - 1)) { + buff.append(", "); //$NON-NLS-1$ + } + i++; + } + } + buff.append(")"); //$NON-NLS-1$ + return buff.toString(); + } + + public Position getPosition() { + return position; + } + + public List getList() { + return children; + } + + /** + * Get the variables from outside (parameters, globals ...) + * @return the variables from outside + */ + public List getOutsideVariable() { + final ArrayList list = new ArrayList(); + if (arguments != null) { + final Enumeration vars = arguments.keys(); + while (vars.hasMoreElements()) { + list.add(new VariableUsage((String) vars.nextElement(), getSourceStart())); + } + } + + if (statements != null) { + for (int i = 0; i < statements.length; i++) { + list.addAll(statements[i].getOutsideVariable()); + } + } + return list; + } + + /** + * get the modified variables. + * @return the variables from we change value + */ + public List getModifiedVariable() { + final ArrayList list = new ArrayList(); + if (statements != null) { + for (int i = 0; i < statements.length; i++) { + list.addAll(statements[i].getModifiedVariable()); + } + } + return list; + } + + /** + * Get the variables used. + * @return the variables used + */ + public List getUsedVariable() { + final ArrayList list = new ArrayList(); + if (statements != null) { + for (int i = 0; i < statements.length; i++) { + list.addAll(statements[i].getUsedVariable()); + } + } + return list; + } + + private boolean isVariableDeclaredBefore(List list, VariableUsage var) { + final String name = var.getName(); + final int pos = var.getStartOffset(); + for (int i = 0; i < list.size(); i++) { + VariableUsage variableUsage = (VariableUsage) list.get(i); + if (variableUsage.getName().equals(name) && variableUsage.getStartOffset() < pos) { + return true; + } + } + return false; + } + + private void dumpList(List list, String name) { + StringBuffer buff = new StringBuffer(name).append("\n"); + for (int i = 0; i < list.size(); i++) { + buff.append(list.get(i).toString()).append("\n"); + } + if (PHPeclipsePlugin.DEBUG) { + PHPeclipsePlugin.log(1, buff.toString()); + } + } + + /** + * This method will analyze the code. + */ + public void analyzeCode() { + final List outsideVars = getOutsideVariable(); + final List modifiedVars = getModifiedVariable(); + + final List declaredVars = new ArrayList(outsideVars.size() + modifiedVars.size()); + declaredVars.addAll(outsideVars); + declaredVars.addAll(modifiedVars); + + final List usedVars = getUsedVariable(); + +/* dumpList(outsideVars, "outside"); + dumpList(modifiedVars, "modified"); + dumpList(usedVars, "used"); */ + + + //look for used variables that were not declared before + findUnknownUsedVars(usedVars, declaredVars); + } + + /** + * This method will add a warning on all used variables in a method that aren't declared before. + * @param usedVars the used variable list + * @param declaredVars the declared variable list + */ + private void findUnknownUsedVars(final List usedVars, final List declaredVars) { + for (int i = 0; i < usedVars.size(); i++) { + VariableUsage variableUsage = (VariableUsage) usedVars.get(i); + if (!isVariableDeclaredBefore(declaredVars, variableUsage)) { + try { + PHPParserSuperclass.setMarker("warning, usage of an unknown variable : " + variableUsage.getName(), + variableUsage.getStartOffset(), + variableUsage.getStartOffset() + variableUsage.getName().length(), + PHPParserSuperclass.WARNING, + ""); + } catch (CoreException e) { + PHPeclipsePlugin.log(e); + } + } + } + } +}