PageRenderTime 311ms CodeModel.GetById 296ms app.highlight 12ms RepoModel.GetById 1ms app.codeStats 0ms

/jEdit/tags/jedit-4-5-pre1/org/gjt/sp/jedit/bsh/BSHMethodDeclaration.java

#
Java | 179 lines | 95 code | 24 blank | 60 comment | 16 complexity | 605ac5c3379041cc74b75dc2758877da MD5 | raw file
  1/*****************************************************************************
  2 *                                                                           *
  3 *  This file is part of the BeanShell Java Scripting distribution.          *
  4 *  Documentation and updates may be found at http://www.beanshell.org/      *
  5 *                                                                           *
  6 *  Sun Public License Notice:                                               *
  7 *                                                                           *
  8 *  The contents of this file are subject to the Sun Public License Version  *
  9 *  1.0 (the "License"); you may not use this file except in compliance with *
 10 *  the License. A copy of the License is available at http://www.sun.com    * 
 11 *                                                                           *
 12 *  The Original Code is BeanShell. The Initial Developer of the Original    *
 13 *  Code is Pat Niemeyer. Portions created by Pat Niemeyer are Copyright     *
 14 *  (C) 2000.  All Rights Reserved.                                          *
 15 *                                                                           *
 16 *  GNU Public License Notice:                                               *
 17 *                                                                           *
 18 *  Alternatively, the contents of this file may be used under the terms of  *
 19 *  the GNU Lesser General Public License (the "LGPL"), in which case the    *
 20 *  provisions of LGPL are applicable instead of those above. If you wish to *
 21 *  allow use of your version of this file only under the  terms of the LGPL *
 22 *  and not to allow others to use your version of this file under the SPL,  *
 23 *  indicate your decision by deleting the provisions above and replace      *
 24 *  them with the notice and other provisions required by the LGPL.  If you  *
 25 *  do not delete the provisions above, a recipient may use your version of  *
 26 *  this file under either the SPL or the LGPL.                              *
 27 *                                                                           *
 28 *  Patrick Niemeyer (pat@pat.net)                                           *
 29 *  Author of Learning Java, O'Reilly & Associates                           *
 30 *  http://www.pat.net/~pat/                                                 *
 31 *                                                                           *
 32 *****************************************************************************/
 33
 34package org.gjt.sp.jedit.bsh;
 35
 36class BSHMethodDeclaration extends SimpleNode
 37{
 38	public String name;
 39
 40	// Begin Child node structure evaluated by insureNodesParsed
 41
 42	BSHReturnType returnTypeNode;
 43	BSHFormalParameters paramsNode;
 44	BSHBlock blockNode;
 45	// index of the first throws clause child node
 46	int firstThrowsClause;
 47
 48	// End Child node structure evaluated by insureNodesParsed
 49
 50	public Modifiers modifiers;
 51
 52	// Unsafe caching of type here.
 53	Class returnType;  // null (none), Void.TYPE, or a Class
 54	int numThrows = 0;
 55
 56	BSHMethodDeclaration(int id) { super(id); }
 57
 58	/**
 59		Set the returnTypeNode, paramsNode, and blockNode based on child
 60		node structure.  No evaluation is done here.
 61	*/
 62	synchronized void insureNodesParsed() 
 63	{
 64		if ( paramsNode != null ) // there is always a paramsNode
 65			return;
 66
 67		Object firstNode = jjtGetChild(0);
 68		firstThrowsClause = 1;
 69		if ( firstNode instanceof BSHReturnType )
 70		{
 71			returnTypeNode = (BSHReturnType)firstNode;
 72			paramsNode = (BSHFormalParameters)jjtGetChild(1);
 73			if ( jjtGetNumChildren() > 2+numThrows )
 74				blockNode = (BSHBlock)jjtGetChild(2+numThrows); // skip throws
 75			++firstThrowsClause;
 76		}
 77		else
 78		{
 79			paramsNode = (BSHFormalParameters)jjtGetChild(0);
 80			blockNode = (BSHBlock)jjtGetChild(1+numThrows); // skip throws
 81		}
 82	}
 83
 84	/**
 85		Evaluate the return type node.
 86		@return the type or null indicating loosely typed return
 87	*/
 88	Class evalReturnType( CallStack callstack, Interpreter interpreter )
 89		throws EvalError
 90	{
 91		insureNodesParsed();
 92		if ( returnTypeNode != null )
 93			return returnTypeNode.evalReturnType( callstack, interpreter );
 94		else 
 95			return null;
 96	}
 97
 98	String getReturnTypeDescriptor( 
 99		CallStack callstack, Interpreter interpreter, String defaultPackage )
100	{
101		insureNodesParsed();
102		if ( returnTypeNode == null )
103			return null;
104		else
105			return returnTypeNode.getTypeDescriptor( 
106				callstack, interpreter, defaultPackage );
107	}
108
109	BSHReturnType getReturnTypeNode() {
110		insureNodesParsed();
111		return returnTypeNode;
112	}
113
114	/**
115		Evaluate the declaration of the method.  That is, determine the
116		structure of the method and install it into the caller's namespace.
117	*/
118	public Object eval( CallStack callstack, Interpreter interpreter )
119		throws EvalError
120	{
121		returnType = evalReturnType( callstack, interpreter );
122		evalNodes( callstack, interpreter );
123
124		// Install an *instance* of this method in the namespace.
125		// See notes in BshMethod 
126
127// This is not good...
128// need a way to update eval without re-installing...
129// so that we can re-eval params, etc. when classloader changes
130// look into this
131
132		NameSpace namespace = callstack.top();
133		BshMethod bshMethod = new BshMethod( this, namespace, modifiers );
134		try {
135			namespace.setMethod( name, bshMethod );
136		} catch ( UtilEvalError e ) {
137			throw e.toEvalError(this,callstack);
138		}
139
140		return Primitive.VOID;
141	}
142
143	private void evalNodes( CallStack callstack, Interpreter interpreter ) 
144		throws EvalError
145	{
146		insureNodesParsed();
147		
148		// validate that the throws names are class names
149		for(int i=firstThrowsClause; i<numThrows+firstThrowsClause; i++)
150			((BSHAmbiguousName)jjtGetChild(i)).toClass( 
151				callstack, interpreter );
152
153		paramsNode.eval( callstack, interpreter );
154
155		// if strictJava mode, check for loose parameters and return type
156		if ( interpreter.getStrictJava() )
157		{
158			for(int i=0; i<paramsNode.paramTypes.length; i++)
159				if ( paramsNode.paramTypes[i] == null )
160					// Warning: Null callstack here.  Don't think we need
161					// a stack trace to indicate how we sourced the method.
162					throw new EvalError(
163				"(Strict Java Mode) Undeclared argument type, parameter: " +
164					paramsNode.getParamNames()[i] + " in method: " 
165					+ name, this, null );
166
167			if ( returnType == null )
168				// Warning: Null callstack here.  Don't think we need
169				// a stack trace to indicate how we sourced the method.
170				throw new EvalError(
171				"(Strict Java Mode) Undeclared return type for method: "
172					+ name, this, null );
173		}
174	}
175
176	public String toString() {
177		return "MethodDeclaration: "+name;
178	}
179}