Java XMLObject.has方法代码示例

import org.mozilla.javascript.xml.XMLObject; //导入方法依赖的package包/类
private static Object nameOrFunction(Context cx, Scriptable scope,
                                     Scriptable parentScope, String name,
                                     boolean asFunctionCall)
{
    Object result;
    Scriptable thisObj = scope; // It is used only if asFunctionCall==true.

    XMLObject firstXMLObject = null;
    for (;;) {
        if (scope instanceof NativeWith) {
            Scriptable withObj = scope.getPrototype();
            if (withObj instanceof 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 != Scriptable.NOT_FOUND) {
                    // function this should be the target object of with
                    thisObj = withObj;
                    break;
                }
            }
        } else if (scope instanceof NativeCall) {
            // NativeCall does not prototype chain and Scriptable.get
            // can be called directly.
            result = scope.get(name, scope);
            if (result != Scriptable.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 != Scriptable.NOT_FOUND) {
                thisObj = scope;
                break;
            }
        }
        scope = parentScope;
        parentScope = parentScope.getParentScope();
        if (parentScope == null) {
            result = topScopeName(cx, scope, name);
            if (result == Scriptable.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 instanceof Callable)) {
            throw notFunctionError(result, name);
        }
        storeScriptable(cx, thisObj);
    }

    return result;
}
 

import org.mozilla.javascript.xml.XMLObject; //导入方法依赖的package包/类
/**
 * 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
 */
public static Scriptable bind(Context cx, Scriptable scope, String id)
{
    Scriptable firstXMLObject = null;
    Scriptable parent = scope.getParentScope();
    childScopesChecks: if (parent != null) {
        // Check for possibly nested "with" scopes first
        while (scope instanceof NativeWith) {
            Scriptable withObj = scope.getPrototype();
            if (withObj instanceof 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) {
                break childScopesChecks;
            }
        }
        for (;;) {
            if (ScriptableObject.hasProperty(scope, id)) {
                return scope;
            }
            scope = parent;
            parent = parent.getParentScope();
            if (parent == null) {
                break childScopesChecks;
            }
        }
    }
    // 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;
}
 

import org.mozilla.javascript.xml.XMLObject; //导入方法依赖的package包/类
/**
 * 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
 */
public static Scriptable bind(Context cx, Scriptable scope, String id)
{
    //System.out.println("ScriptRuntime bind: " + id + " Context: " + cx ); //XXX
    Provenance.addVarName(id);
    Scriptable firstXMLObject = null;
    Scriptable parent = scope.getParentScope();
    childScopesChecks: if (parent != null) {
        // Check for possibly nested "with" scopes first
        while (scope instanceof NativeWith) {
            Scriptable withObj = scope.getPrototype();
            if (withObj instanceof 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) {
                break childScopesChecks;
            }
        }
        for (;;) {
            if (ScriptableObject.hasProperty(scope, id)) {
                return scope;
            }
            scope = parent;
            parent = parent.getParentScope();
            if (parent == null) {
                break childScopesChecks;
            }
        }
    }
    // 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;
}