C# Scriptable.GetPrototype方法代码示例

		/// <summary>Delegates to</summary>
		/// <returns>true iff rhs appears in lhs' proto chain</returns>
		public static bool JsDelegatesTo(Scriptable lhs, Scriptable rhs)
		{
			Scriptable proto = lhs.GetPrototype();
			while (proto != null)
			{
				if (proto.Equals(rhs))
				{
					return true;
				}
				proto = proto.GetPrototype();
			}
			return false;
		}

		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);
		}

		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>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;
		}

		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;
		}