C# Scriptable.GetParentScope方法代码示例

		public static void InitFunction(Context cx, Scriptable scope, NativeFunction function, int type, bool fromEvalCode)
		{
			if (type == FunctionNode.FUNCTION_STATEMENT)
			{
				string name = function.GetFunctionName();
				if (name != null && name.Length != 0)
				{
					if (!fromEvalCode)
					{
						// ECMA specifies that functions defined in global and
						// function scope outside eval should have DONTDELETE set.
						ScriptableObject.DefineProperty(scope, name, function, ScriptableObject.PERMANENT);
					}
					else
					{
						scope.Put(name, scope, function);
					}
				}
			}
			else
			{
				if (type == FunctionNode.FUNCTION_EXPRESSION_STATEMENT)
				{
					string name = function.GetFunctionName();
					if (name != null && name.Length != 0)
					{
						// Always put function expression statements into initial
						// activation object ignoring the with statement to follow
						// SpiderMonkey
						while (scope is NativeWith)
						{
							scope = scope.GetParentScope();
						}
						scope.Put(name, scope, function);
					}
				}
				else
				{
					throw Kit.CodeBug();
				}
			}
		}

		public static object CallSpecial(Context cx, Callable fun, Scriptable thisObj, object[] args, Scriptable scope, Scriptable callerThis, int callType, string filename, int lineNumber)
		{
			if (callType == Node.SPECIALCALL_EVAL)
			{
				if (thisObj.GetParentScope() == null && NativeGlobal.IsEvalFunction(fun))
				{
					return EvalSpecial(cx, scope, callerThis, args, filename, lineNumber);
				}
			}
			else
			{
				if (callType == Node.SPECIALCALL_WITH)
				{
					if (NativeWith.IsWithFunction(fun))
					{
						throw Context.ReportRuntimeError1("msg.only.from.new", "With");
					}
				}
				else
				{
					throw Kit.CodeBug();
				}
			}
			return fun.Call(cx, scope, thisObj, args);
		}

		public static object NameIncrDecr(Scriptable scopeChain, string id, Context cx, int incrDecrMask)
		{
			Scriptable target;
			object value;
			do
			{
				if (cx.useDynamicScope && scopeChain.GetParentScope() == null)
				{
					scopeChain = CheckDynamicScope(cx.topCallScope, scopeChain);
				}
				target = scopeChain;
				do
				{
					if (target is NativeWith && target.GetPrototype() is XMLObject)
					{
						break;
					}
					value = target.Get(id, scopeChain);
					if (value != ScriptableConstants.NOT_FOUND)
					{
						goto search_break;
					}
					target = target.GetPrototype();
				}
				while (target != null);
				scopeChain = scopeChain.GetParentScope();
			}
			while (scopeChain != null);
			throw NotFoundError(scopeChain, id);
search_break: ;
			return DoScriptableIncrDecr(target, id, scopeChain, value, incrDecrMask);
		}

		/// <summary>Returns the object in the scope chain that has a given property.</summary>
		/// <remarks>
		/// Returns the object in the scope chain that has a given property.
		/// The order of evaluation of an assignment expression involves
		/// evaluating the lhs to a reference, evaluating the rhs, and then
		/// modifying the reference with the rhs value. This method is used
		/// to 'bind' the given name to an object containing that property
		/// so that the side effects of evaluating the rhs do not affect
		/// which property is modified.
		/// Typically used in conjunction with setName.
		/// See ECMA 10.1.4
		/// </remarks>
		public static Scriptable Bind(Context cx, Scriptable scope, string id)
		{
			Scriptable firstXMLObject = null;
			Scriptable parent = scope.GetParentScope();
			if (parent != null)
			{
				// Check for possibly nested "with" scopes first
				while (scope is NativeWith)
				{
					Scriptable withObj = scope.GetPrototype();
					if (withObj is XMLObject)
					{
						XMLObject xmlObject = (XMLObject)withObj;
						if (xmlObject.Has(cx, id))
						{
							return xmlObject;
						}
						if (firstXMLObject == null)
						{
							firstXMLObject = xmlObject;
						}
					}
					else
					{
						if (ScriptableObject.HasProperty(withObj, id))
						{
							return withObj;
						}
					}
					scope = parent;
					parent = parent.GetParentScope();
					if (parent == null)
					{
						goto childScopesChecks_break;
					}
				}
				for (; ; )
				{
					if (ScriptableObject.HasProperty(scope, id))
					{
						return scope;
					}
					scope = parent;
					parent = parent.GetParentScope();
					if (parent == null)
					{
						goto childScopesChecks_break;
					}
				}
			}
childScopesChecks_break: ;
			// scope here is top scope
			if (cx.useDynamicScope)
			{
				scope = CheckDynamicScope(cx.topCallScope, scope);
			}
			if (ScriptableObject.HasProperty(scope, id))
			{
				return scope;
			}
			// Nothing was found, but since XML objects always bind
			// return one if found
			return firstXMLObject;
		}

		/// <summary>
		/// Prepare for calling name(...): return function corresponding to
		/// name and make current top scope available
		/// as ScriptRuntime.lastStoredScriptable() for consumption as thisObj.
		/// </summary>
		/// <remarks>
		/// Prepare for calling name(...): return function corresponding to
		/// name and make current top scope available
		/// as ScriptRuntime.lastStoredScriptable() for consumption as thisObj.
		/// The caller must call ScriptRuntime.lastStoredScriptable() immediately
		/// after calling this method.
		/// </remarks>
		public static Callable GetNameFunctionAndThis(string name, Context cx, Scriptable scope)
		{
			Scriptable parent = scope.GetParentScope();
			if (parent == null)
			{
				object result = TopScopeName(cx, scope, name);
				if (!(result is Callable))
				{
					if (result == ScriptableConstants.NOT_FOUND)
					{
						throw NotFoundError(scope, name);
					}
					else
					{
						throw NotFunctionError(result, name);
					}
				}
				// Top scope is not NativeWith or NativeCall => thisObj == scope
				Scriptable thisObj = scope;
				StoreScriptable(cx, thisObj);
				return (Callable)result;
			}
			// name will call storeScriptable(cx, thisObj);
			return (Callable)NameOrFunction(cx, scope, parent, name, true);
		}

		private static object NameOrFunction(Context cx, Scriptable scope, Scriptable parentScope, string name, bool asFunctionCall)
		{
			object result;
			Scriptable thisObj = scope;
			// It is used only if asFunctionCall==true.
			XMLObject firstXMLObject = null;
			for (; ; )
			{
				if (scope is NativeWith)
				{
					Scriptable withObj = scope.GetPrototype();
					if (withObj is XMLObject)
					{
						XMLObject xmlObj = (XMLObject)withObj;
						if (xmlObj.Has(name, xmlObj))
						{
							// function this should be the target object of with
							thisObj = xmlObj;
							result = xmlObj.Get(name, xmlObj);
							break;
						}
						if (firstXMLObject == null)
						{
							firstXMLObject = xmlObj;
						}
					}
					else
					{
						result = ScriptableObject.GetProperty(withObj, name);
						if (result != ScriptableConstants.NOT_FOUND)
						{
							// function this should be the target object of with
							thisObj = withObj;
							break;
						}
					}
				}
				else
				{
					if (scope is NativeCall)
					{
						// NativeCall does not prototype chain and Scriptable.get
						// can be called directly.
						result = scope.Get(name, scope);
						if (result != ScriptableConstants.NOT_FOUND)
						{
							if (asFunctionCall)
							{
								// ECMA 262 requires that this for nested funtions
								// should be top scope
								thisObj = ScriptableObject.GetTopLevelScope(parentScope);
							}
							break;
						}
					}
					else
					{
						// Can happen if Rhino embedding decided that nested
						// scopes are useful for what ever reasons.
						result = ScriptableObject.GetProperty(scope, name);
						if (result != ScriptableConstants.NOT_FOUND)
						{
							thisObj = scope;
							break;
						}
					}
				}
				scope = parentScope;
				parentScope = parentScope.GetParentScope();
				if (parentScope == null)
				{
					result = TopScopeName(cx, scope, name);
					if (result == ScriptableConstants.NOT_FOUND)
					{
						if (firstXMLObject == null || asFunctionCall)
						{
							throw NotFoundError(scope, name);
						}
						// The name was not found, but we did find an XML
						// object in the scope chain and we are looking for name,
						// not function. The result should be an empty XMLList
						// in name context.
						result = firstXMLObject.Get(name, firstXMLObject);
					}
					// For top scope thisObj for functions is always scope itself.
					thisObj = scope;
					break;
				}
			}
			if (asFunctionCall)
			{
				if (!(result is Callable))
				{
					throw NotFunctionError(result, name);
				}
				StoreScriptable(cx, thisObj);
			}
			return result;
		}

		/// <summary>Looks up a name in the scope chain and returns its value.</summary>
		/// <remarks>Looks up a name in the scope chain and returns its value.</remarks>
		public static object Name(Context cx, Scriptable scope, string name)
		{
			Scriptable parent = scope.GetParentScope();
			if (parent == null)
			{
				object result = TopScopeName(cx, scope, name);
				if (result == ScriptableConstants.NOT_FOUND)
				{
					throw NotFoundError(scope, name);
				}
				return result;
			}
			return NameOrFunction(cx, scope, parent, name, false);
		}

		/// <summary>
		/// Static helper method to get a built-in object prototype with the given
		/// <code>type</code> from the given <code>scope</code>.
		/// </summary>
		/// <remarks>
		/// Static helper method to get a built-in object prototype with the given
		/// <code>type</code> from the given <code>scope</code>. If the scope is not
		/// an instance of this class or does have a cache of built-ins,
		/// the prototype is looked up via normal property lookup.
		/// </remarks>
		/// <param name="scope">the top-level scope</param>
		/// <param name="type">the built-in type</param>
		/// <returns>the built-in prototype</returns>
		public static Scriptable GetBuiltinPrototype(Scriptable scope, TopLevel.Builtins type)
		{
			// must be called with top level scope
			System.Diagnostics.Debug.Assert(scope.GetParentScope() == null);
			if (scope is TopLevel)
			{
				Scriptable result = ((TopLevel)scope).GetBuiltinPrototype(type);
				if (result != null)
				{
					return result;
				}
			}
			// fall back to normal prototype lookup
			return ScriptableObject.GetClassPrototype(scope, type.ToString());
		}

		/// <summary>
		/// Static helper method to get a built-in object constructor with the given
		/// <code>type</code> from the given <code>scope</code>.
		/// </summary>
		/// <remarks>
		/// Static helper method to get a built-in object constructor with the given
		/// <code>type</code> from the given <code>scope</code>. If the scope is not
		/// an instance of this class or does have a cache of built-ins,
		/// the constructor is looked up via normal property lookup.
		/// </remarks>
		/// <param name="cx">the current Context</param>
		/// <param name="scope">the top-level scope</param>
		/// <param name="type">the built-in type</param>
		/// <returns>the built-in constructor</returns>
		public static Function GetBuiltinCtor(Context cx, Scriptable scope, TopLevel.Builtins type)
		{
			// must be called with top level scope
			System.Diagnostics.Debug.Assert(scope.GetParentScope() == null);
			if (scope is TopLevel)
			{
				Function result = ((TopLevel)scope).GetBuiltinCtor(type);
				if (result != null)
				{
					return result;
				}
			}
			// fall back to normal constructor lookup
			return ScriptRuntime.GetExistingCtor(cx, scope, type.ToString());
		}

		private Ref XmlPrimaryReference(Context cx, XMLName xmlName, Scriptable scope)
		{
			XMLObjectImpl xmlObj;
			XMLObjectImpl firstXml = null;
			for (; ; )
			{
				// XML object can only present on scope chain as a wrapper
				// of XMLWithScope
				if (scope is XMLWithScope)
				{
					xmlObj = (XMLObjectImpl)scope.GetPrototype();
					if (xmlObj.HasXMLProperty(xmlName))
					{
						break;
					}
					if (firstXml == null)
					{
						firstXml = xmlObj;
					}
				}
				scope = scope.GetParentScope();
				if (scope == null)
				{
					xmlObj = firstXml;
					break;
				}
			}
			// xmlObj == null corresponds to undefined as the target of
			// the reference
			if (xmlObj != null)
			{
				xmlName.InitXMLObject(xmlObj);
			}
			return xmlName;
		}