From 89bda83e0570ab87c6e449f5955613d5385e90b3 Mon Sep 17 00:00:00 2001 From: "alexanders@b2ef00c0-3703-41da-baef-cfe82387ac0c" Date: Wed, 3 Feb 2010 00:50:41 +0000 Subject: removed obsolete svn folder from hg tree --HG-- extra : convert_revision : svn%3Ab2ef00c0-3703-41da-baef-cfe82387ac0c/trunk%408 --- .../mozilla/javascript/InterpretedFunction.java | 221 +++++++++++++++++++++ 1 file changed, 221 insertions(+) create mode 100644 infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterpretedFunction.java (limited to 'infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterpretedFunction.java') diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterpretedFunction.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterpretedFunction.java new file mode 100644 index 0000000..db84299 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterpretedFunction.java @@ -0,0 +1,221 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * Bob Jervis + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import org.mozilla.javascript.debug.DebuggableScript; + +final class InterpretedFunction extends NativeFunction implements Script +{ + static final long serialVersionUID = 541475680333911468L; + + InterpreterData idata; + SecurityController securityController; + Object securityDomain; + Scriptable[] functionRegExps; + + private InterpretedFunction(InterpreterData idata, + Object staticSecurityDomain) + { + this.idata = idata; + + // Always get Context from the current thread to + // avoid security breaches via passing mangled Context instances + // with bogus SecurityController + Context cx = Context.getContext(); + SecurityController sc = cx.getSecurityController(); + Object dynamicDomain; + if (sc != null) { + dynamicDomain = sc.getDynamicSecurityDomain(staticSecurityDomain); + } else { + if (staticSecurityDomain != null) { + throw new IllegalArgumentException(); + } + dynamicDomain = null; + } + + this.securityController = sc; + this.securityDomain = dynamicDomain; + } + + private InterpretedFunction(InterpretedFunction parent, int index) + { + this.idata = parent.idata.itsNestedFunctions[index]; + this.securityController = parent.securityController; + this.securityDomain = parent.securityDomain; + } + + /** + * Create script from compiled bytecode. + */ + static InterpretedFunction createScript(InterpreterData idata, + Object staticSecurityDomain) + { + InterpretedFunction f; + f = new InterpretedFunction(idata, staticSecurityDomain); + return f; + } + + /** + * Create function compiled from Function(...) constructor. + */ + static InterpretedFunction createFunction(Context cx,Scriptable scope, + InterpreterData idata, + Object staticSecurityDomain) + { + InterpretedFunction f; + f = new InterpretedFunction(idata, staticSecurityDomain); + f.initInterpretedFunction(cx, scope); + return f; + } + + /** + * Create function embedded in script or another function. + */ + static InterpretedFunction createFunction(Context cx, Scriptable scope, + InterpretedFunction parent, + int index) + { + InterpretedFunction f = new InterpretedFunction(parent, index); + f.initInterpretedFunction(cx, scope); + return f; + } + + Scriptable[] createRegExpWraps(Context cx, Scriptable scope) + { + if (idata.itsRegExpLiterals == null) Kit.codeBug(); + + RegExpProxy rep = ScriptRuntime.checkRegExpProxy(cx); + int N = idata.itsRegExpLiterals.length; + Scriptable[] array = new Scriptable[N]; + for (int i = 0; i != N; ++i) { + array[i] = rep.wrapRegExp(cx, scope, idata.itsRegExpLiterals[i]); + } + return array; + } + + private void initInterpretedFunction(Context cx, Scriptable scope) + { + initScriptFunction(cx, scope); + if (idata.itsRegExpLiterals != null) { + functionRegExps = createRegExpWraps(cx, scope); + } + } + + public String getFunctionName() + { + return (idata.itsName == null) ? "" : idata.itsName; + } + + /** + * Calls the function. + * @param cx the current context + * @param scope the scope used for the call + * @param thisObj the value of "this" + * @param args function arguments. Must not be null. You can use + * {@link ScriptRuntime#emptyArgs} to pass empty arguments. + * @return the result of the function call. + */ + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + if (!ScriptRuntime.hasTopCall(cx)) { + return ScriptRuntime.doTopCall(this, cx, scope, thisObj, args); + } + return Interpreter.interpret(this, cx, scope, thisObj, args); + } + + public Object exec(Context cx, Scriptable scope) + { + if (idata.itsFunctionType != 0) { + // Can only be applied to scripts + throw new IllegalStateException(); + } + if (!ScriptRuntime.hasTopCall(cx)) { + // It will go through "call" path. but they are equivalent + return ScriptRuntime.doTopCall( + this, cx, scope, scope, ScriptRuntime.emptyArgs); + } + return Interpreter.interpret( + this, cx, scope, scope, ScriptRuntime.emptyArgs); + } + + public String getEncodedSource() + { + return Interpreter.getEncodedSource(idata); + } + + public DebuggableScript getDebuggableView() + { + return idata; + } + + public Object resumeGenerator(Context cx, Scriptable scope, int operation, + Object state, Object value) + { + return Interpreter.resumeGenerator(cx, scope, operation, state, value); + } + + protected int getLanguageVersion() + { + return idata.languageVersion; + } + + protected int getParamCount() + { + return idata.argCount; + } + + protected int getParamAndVarCount() + { + return idata.argNames.length; + } + + protected String getParamOrVarName(int index) + { + return idata.argNames[index]; + } + + protected boolean getParamOrVarConst(int index) + { + return idata.argIsConst[index]; + } +} + -- cgit v1.2.3