예제 #1
1
  /**
   * Converts the given value to the given NativeObject (optionally following the prototype chains).
   *
   * @param nativeObject target NativeObject
   * @param value Value to convert
   * @param prototype use the prototype chain?
   */
  public static Value toNativeObject(
      HostObject nativeObject,
      Value value,
      boolean prototype,
      Solver.SolverInterface solverInterface) {
    State state = solverInterface.getState();
    boolean bad = false;
    Set<ObjectLabel> matches = Collections.newSet();

    if (prototype) {
      // Make lookup using prototype chains
      Set<ObjectLabel> objectLabels = Collections.newSet(value.getObjectLabels());
      Set<ObjectLabel> visited = Collections.newSet();

      while (!objectLabels.isEmpty()) {
        Set<ObjectLabel> temp = Collections.newSet();
        for (ObjectLabel objectLabel : objectLabels) {
          if (!visited.contains(objectLabel)) {
            visited.add(objectLabel);
            Value prototypeValue =
                state.readInternalPrototype(java.util.Collections.singleton(objectLabel));
            prototypeValue = UnknownValueResolver.getRealValue(prototypeValue, state);

            // FIXME: Needs code review. Looks fishy to compare objects with toString().
            String nativeObjectPrototype = nativeObject.toString();
            String objectLabelPrototype = "";
            if (objectLabel.getHostObject() != null) {
              objectLabelPrototype = objectLabel.getHostObject().toString();
            }

            if (nativeObject == objectLabel.getHostObject()
                || nativeObjectPrototype.equals(objectLabelPrototype)) {
              matches.add(objectLabel);
            } else if (prototypeValue.getObjectLabels().isEmpty()) {
              bad = true;
            } else {
              temp.addAll(prototypeValue.getObjectLabels());
            }
          }
        }
        objectLabels = temp;
      }
    } else {
      // Make lookup ignoring prototype chains

      // TODO: Verify this
      for (ObjectLabel objectLabel : value.getObjectLabels()) {
        if (objectLabel.getHostObject() == nativeObject
            || (objectLabel.getHostObject() != null
                && objectLabel.getHostObject().toString().equals(nativeObject + ".prototype"))) {
          matches.add(objectLabel);
        } else {
          bad = true;
        }
      }
    }

    //        Message.Status status;
    //        if (good && bad) {
    //            status = Message.Status.MAYBE;
    //        } else if (!good && bad) {
    //            status = Message.Status.CERTAIN;
    //        } else if (good && !bad) {
    //            status = Message.Status.NONE;
    //        } else if (!good && !bad) { // equivalent to Value of Undef / a null argument
    //            // Considered a certain type error.
    //            status = Message.Status.CERTAIN;
    //        } else {
    //            throw new AnalysisException("toNativeObject: fell through cases - should not
    // happen.");
    //        }
    if (bad) {
      String message = "TypeError, argument is not of expected type: " + nativeObject;
      solverInterface
          .getMonitoring()
          .addMessage(solverInterface.getNode(), Message.Severity.HIGH, message);
    }

    return Value.makeObject(matches);
  }
예제 #2
0
  /** End of loop. */
  @Override
  public void visit(EndLoopNode n, State state) {
    // TODO: do nothing if loop unrolling is disabled or in scanning mode

    // branch condition is determinate, switch context and propagate only to generalized successor
    Context generalizedContext =
        c.getAnalysis().getContextSensitivityStrategy().makeLoopExitContext(state.getContext(), n);
    BasicBlock successor = state.getBasicBlock().getSingleSuccessor();
    State specializedState = state.clone();
    specializedState.setContext(generalizedContext);
    specializedState.setBasicBlock(successor);
    c.propagateToBasicBlock(specializedState, successor, generalizedContext);
    state.setToNone();
  }
예제 #3
0
 /** 11.1.2 assignment with right-hand-side identifier reference. */
 @Override
 public void visit(ReadVariableNode n, State state) {
   String varname = n.getVariableName();
   Value v;
   if (varname.equals("this")) {
     // 11.1.1 read 'this' from the execution context
     v = state.readThis();
     m.visitReadThis(n, v, state, InitialStateBuilder.GLOBAL);
   } else { // ordinary variable
     int result_base_reg = n.getResultBaseRegister();
     Set<ObjectLabel> base_objs = null;
     if (c.isScanning() || result_base_reg != AbstractNode.NO_VALUE) base_objs = newSet();
     v = state.readVariable(varname, base_objs);
     m.visitPropertyRead(n, base_objs, Value.makeTemporaryStr(varname), state, true);
     m.visitVariableAsRead(n, v, state);
     m.visitVariableOrProperty(varname, n.getSourceLocation(), v, state.getContext(), state);
     m.visitReadNonThisVariable(n, v);
     if (v.isMaybeAbsent()) Exceptions.throwReferenceError(state, c);
     if (v.isNotPresent() && !Options.get().isPropagateDeadFlow()) {
       state.setToNone();
       return;
     }
     if (result_base_reg != AbstractNode.NO_VALUE)
       state.writeRegister(result_base_reg, Value.makeObject(base_objs)); // see 10.1.4
     m.visitRead(n, v, state);
     m.visitReadVariable(n, v, state); // TODO: combine some of these m.visitXYZ methods?
   }
   if (v.isNotPresent() && !Options.get().isPropagateDeadFlow()) {
     state.setToNone();
     return;
   }
   if (n.getResultRegister() != AbstractNode.NO_VALUE)
     state.writeRegister(n.getResultRegister(), v.restrictToNotAbsent());
 }
예제 #4
0
  public static void build(Solver.SolverInterface c) {
    State s = c.getState();
    PropVarOperations pv = c.getAnalysis().getPropVarOperations();
    CONSTRUCTOR =
        new ObjectLabel(DOMObjects.HTMLBODYELEMENT_CONSTRUCTOR, ObjectLabel.Kind.FUNCTION);
    PROTOTYPE = new ObjectLabel(DOMObjects.HTMLBODYELEMENT_PROTOTYPE, ObjectLabel.Kind.OBJECT);
    INSTANCES = new ObjectLabel(DOMObjects.HTMLBODYELEMENT_INSTANCES, ObjectLabel.Kind.OBJECT);

    // Constructor Object
    s.newObject(CONSTRUCTOR);
    pv.writePropertyWithAttributes(
        CONSTRUCTOR, "length", Value.makeNum(0).setAttributes(true, true, true));
    pv.writePropertyWithAttributes(
        CONSTRUCTOR, "prototype", Value.makeObject(PROTOTYPE).setAttributes(true, true, true));
    s.writeInternalPrototype(CONSTRUCTOR, Value.makeObject(InitialStateBuilder.FUNCTION_PROTOTYPE));
    pv.writeProperty(DOMWindow.WINDOW, "HTMLBodyElement", Value.makeObject(CONSTRUCTOR));

    // Prototype Object
    s.newObject(PROTOTYPE);
    s.writeInternalPrototype(PROTOTYPE, Value.makeObject(HTMLElement.ELEMENT_PROTOTYPE));

    // Multiplied Object
    s.newObject(INSTANCES);
    s.writeInternalPrototype(INSTANCES, Value.makeObject(PROTOTYPE));

    /*
     * Properties.
     */
    // DOM LEVEL 1
    createDOMProperty(INSTANCES, "aLink", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "background", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "bgColor", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "link", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "text", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "vLink", Value.makeAnyStr(), c);

    s.multiplyObject(INSTANCES);
    INSTANCES = INSTANCES.makeSingleton().makeSummary();

    /*
     * Functions.
     */
    // No functions.

    createDOMProperty(HTMLDocument.INSTANCES, "body", Value.makeObject(INSTANCES), c);
  }
예제 #5
0
  /** 12.6.4 end of loop of 'for-in' statement. */
  @Override
  public void visit(EndForInNode n, State state) {
    if (!Options.get().isForInSpecializationDisabled()) {
      if (!c.isScanning()) {
        // 1. Find successor block, context and base-state
        BasicBlock successor = state.getBasicBlock().getSingleSuccessor();
        for (Pair<NodeAndContext<Context>, Context> ncc :
            c.getAnalysisLatticeElement()
                .getCallGraph()
                .getSources(BlockAndContext.makeEntry(n.getBlock(), state.getContext()))) {
          State nonSpecializedMergeState = state.clone();
          Context nonSpecializedContext = ncc.getFirst().getContext();

          // 2. Use State.mergeFunctionReturn to do the merge
          State forInBeginState =
              c.getAnalysisLatticeElement()
                  .getState(
                      n.getBlock().getEntryBlock().getEntryPredecessorBlock(),
                      nonSpecializedContext);
          State forInEntryState =
              c.getAnalysisLatticeElement()
                  .getState(n.getBlock().getEntryBlock(), state.getContext());
          Value returnValue =
              nonSpecializedMergeState.mergeFunctionReturn(
                  forInBeginState,
                  forInBeginState,
                  forInEntryState,
                  nonSpecializedMergeState.getSummarized(),
                  nonSpecializedMergeState.readRegister(AbstractNode.RETURN_REG));
          nonSpecializedMergeState.setContext(nonSpecializedContext);
          nonSpecializedMergeState.writeRegister(AbstractNode.RETURN_REG, returnValue);
          if (state.hasExceptionRegisterValue()) {
            nonSpecializedMergeState.writeRegister(
                AbstractNode.EXCEPTION_REG, state.readRegister(AbstractNode.EXCEPTION_REG));
          }

          // 3. Propagate only to the non-specialized successor
          nonSpecializedMergeState.setBasicBlock(n.getBlock().getSingleSuccessor());
          c.propagateToBasicBlock(nonSpecializedMergeState, successor, nonSpecializedContext);
        }
        state.setToNone();
      }
    }
  }
예제 #6
0
 /** 11.1.5 object initializer. */
 @Override
 public void visit(NewObjectNode n, State state) {
   HeapContext heapContext =
       c.getAnalysis().getContextSensitivityStrategy().makeObjectLiteralHeapContext(n, state);
   ObjectLabel objlabel = new ObjectLabel(n, Kind.OBJECT, heapContext);
   state.newObject(objlabel);
   state.writeInternalPrototype(objlabel, Value.makeObject(InitialStateBuilder.OBJECT_PROTOTYPE));
   if (n.getResultRegister() != AbstractNode.NO_VALUE)
     state.writeRegister(n.getResultRegister(), Value.makeObject(objlabel));
 }
예제 #7
0
 /** Transfer ordinary and exceptional return for the given call node and callee entry. */
 public void transferReturn(
     AbstractNode call_node,
     BasicBlock callee_entry,
     Context caller_context,
     Context callee_context,
     Context edge_context) {
   if (call_node instanceof BeginForInNode) {
     for (EndForInNode endNode : ((BeginForInNode) call_node).getEndNodes()) {
       BasicBlock end_block = endNode.getBlock();
       if (c.getAnalysisLatticeElement().getState(end_block, callee_context)
           != null) // (EndForInNode uses same context as corresponding BeginForInNode)
       c.addToWorklist(end_block, callee_context);
     }
   } else { // call_node is an ordinary call node
     Function callee = callee_entry.getFunction();
     BasicBlock ordinary_exit = callee.getOrdinaryExit();
     BasicBlock exceptional_exit = callee.getExceptionalExit();
     State ordinary_exit_state =
         c.getAnalysisLatticeElement()
             .getState(
                 ordinary_exit,
                 callee_context); // (ReturnNode uses same context as corresponding function entry
     // node)
     State exceptional_exit_state =
         c.getAnalysisLatticeElement().getState(exceptional_exit, callee_context);
     NodeAndContext<Context> caller = new NodeAndContext<>(call_node, caller_context);
     if (ordinary_exit_state != null) {
       if (ordinary_exit.getFirstNode() instanceof ReturnNode) {
         ReturnNode returnNode = (ReturnNode) ordinary_exit.getFirstNode();
         transferReturn(
             returnNode.getReturnValueRegister(),
             ordinary_exit,
             ordinary_exit_state.clone(),
             caller,
             edge_context);
       } else throw new AnalysisException("ReturnNode expected");
     }
     if (exceptional_exit_state != null) {
       transferExceptionalReturn(
           exceptional_exit, exceptional_exit_state.clone(), caller, edge_context);
     }
   }
 }
예제 #8
0
  /** Beginning of loop. */
  @Override
  public void visit(BeginLoopNode n, State state) {
    // TODO: do nothing if loop unrolling is disabled or in scanning mode

    Value v = state.readRegister(n.getIfNode().getConditionRegister());
    v = Conversion.toBoolean(UnknownValueResolver.getRealValue(v, state));
    if (v.isMaybeTrueButNotFalse() || v.isMaybeFalseButNotTrue()) {
      // branch condition is determinate, switch context and propagate only to specialized successor
      Context specializedContext =
          c.getAnalysis()
              .getContextSensitivityStrategy()
              .makeNextLoopUnrollingContext(state.getContext(), n);
      BasicBlock successor = state.getBasicBlock().getSingleSuccessor();
      State specializedState = state.clone();
      specializedState.setContext(specializedContext);
      specializedState.setBasicBlock(successor);
      c.propagateToBasicBlock(specializedState, successor, specializedContext);
      state.setToNone();
    } // otherwise, just ordinary propagation like no-op
  }
예제 #9
0
  public static void build(Solver.SolverInterface c) {
    State s = c.getState();
    PropVarOperations pv = c.getAnalysis().getPropVarOperations();
    CONSTRUCTOR = new ObjectLabel(DOMObjects.COMMENT_CONSTRUCTOR, ObjectLabel.Kind.FUNCTION);
    PROTOTYPE = new ObjectLabel(DOMObjects.COMMENT_PROTOTYPE, ObjectLabel.Kind.OBJECT);
    INSTANCES = new ObjectLabel(DOMObjects.COMMENT_INSTANCES, ObjectLabel.Kind.OBJECT);

    // Constructor Object
    s.newObject(CONSTRUCTOR);
    pv.writePropertyWithAttributes(
        CONSTRUCTOR, "length", Value.makeNum(0).setAttributes(true, true, true));
    pv.writePropertyWithAttributes(
        CONSTRUCTOR, "prototype", Value.makeObject(PROTOTYPE).setAttributes(true, true, true));
    s.writeInternalPrototype(CONSTRUCTOR, Value.makeObject(InitialStateBuilder.OBJECT_PROTOTYPE));
    pv.writeProperty(DOMWindow.WINDOW, "Comment", Value.makeObject(CONSTRUCTOR));

    // Prototype object.
    s.newObject(PROTOTYPE);
    s.writeInternalPrototype(PROTOTYPE, Value.makeObject(DOMCharacterData.PROTOTYPE));

    // Multiplied object.
    s.newObject(INSTANCES);
    s.writeInternalPrototype(INSTANCES, Value.makeObject(PROTOTYPE));
    s.multiplyObject(INSTANCES);
    INSTANCES = INSTANCES.makeSingleton().makeSummary();

    /*
     * Properties.
     */
    // No properties.

    /*
     * Functions.
     */
    // No functions.
  }
예제 #10
0
  public static void build(Solver.SolverInterface c) {
    State s = c.getState();
    PropVarOperations pv = c.getAnalysis().getPropVarOperations();
    CONSTRUCTOR =
        new ObjectLabel(DOMObjects.HTMLOBJECTELEMENT_CONSTRUCTOR, ObjectLabel.Kind.FUNCTION);
    PROTOTYPE = new ObjectLabel(DOMObjects.HTMLOBJECTELEMENT_PROTOTYPE, ObjectLabel.Kind.OBJECT);
    INSTANCES = new ObjectLabel(DOMObjects.HTMLOBJECTELEMENT_INSTANCES, ObjectLabel.Kind.OBJECT);

    // Constructor Object
    s.newObject(CONSTRUCTOR);
    pv.writePropertyWithAttributes(
        CONSTRUCTOR, "length", Value.makeNum(0).setAttributes(true, true, true));
    pv.writePropertyWithAttributes(
        CONSTRUCTOR, "prototype", Value.makeObject(PROTOTYPE).setAttributes(true, true, true));
    s.writeInternalPrototype(CONSTRUCTOR, Value.makeObject(InitialStateBuilder.FUNCTION_PROTOTYPE));
    pv.writeProperty(DOMWindow.WINDOW, "HTMLObjectElement", Value.makeObject(CONSTRUCTOR));

    // Prototype Object
    s.newObject(PROTOTYPE);
    s.writeInternalPrototype(PROTOTYPE, Value.makeObject(HTMLElement.ELEMENT_PROTOTYPE));

    // Multiplied Object
    s.newObject(INSTANCES);
    s.writeInternalPrototype(INSTANCES, Value.makeObject(PROTOTYPE));

    /*
     * Properties.
     */
    // DOM Level 1
    createDOMProperty(
        INSTANCES, "form", Value.makeObject(HTMLFormElement.INSTANCES).setReadOnly(), c);
    createDOMProperty(INSTANCES, "code", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "align", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "archive", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "border", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "codeBase", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "codeType", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "data", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "declare", Value.makeAnyBool(), c);
    createDOMProperty(INSTANCES, "height", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "hspace", Value.makeAnyNum(), c);
    createDOMProperty(INSTANCES, "name", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "standby", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "tabIndex", Value.makeAnyNum(), c);
    createDOMProperty(
        INSTANCES, "type", Value.makeAnyStr().restrictToNotStrIdentifierParts() /* mime-type */, c);
    createDOMProperty(INSTANCES, "useMap", Value.makeAnyStr(), c);
    createDOMProperty(INSTANCES, "vspace", Value.makeAnyNum(), c);
    createDOMProperty(INSTANCES, "width", Value.makeAnyStr(), c);

    // DOM Level 2
    createDOMProperty(
        INSTANCES, "contentDocument", Value.makeObject(DOMDocument.INSTANCES).setReadOnly(), c);

    s.multiplyObject(INSTANCES);
    INSTANCES = INSTANCES.makeSingleton().makeSummary();

    /*
     * Functions.
     */
    // No functions.
  }
예제 #11
0
  /** 12.6.4 begin 'for-in' statement. */
  @Override
  public void visit(BeginForInNode n, State state) {
    if (!Options.get().isForInSpecializationDisabled()) {
      // 1. Find properties to iterate through
      Value v1 = state.readRegister(n.getObjectRegister());
      state.writeRegister(
          n.getObjectRegister(), v1.makeExtendedScope()); // preserve the register value
      v1 = UnknownValueResolver.getRealValue(v1, state);
      Set<ObjectLabel> objs = Conversion.toObjectLabels(state, n, v1, c);
      State.Properties p = state.getEnumProperties(objs);
      Collection<Value> propertyNameValues = newList(p.toValues());

      // Add the no-iteration case
      propertyNameValues.add(Value.makeNull().makeExtendedScope());

      // 2. Make specialized context for each iteration
      int it = n.getPropertyListRegister();
      //            List<Context> specialized_contexts = newList();
      BasicBlock successor = n.getBlock().getSingleSuccessor();
      for (Value k : propertyNameValues) {
        m.visitPropertyRead(n, objs, k, state, true);
        if (!c.isScanning()) {
          // 2.1 Make specialized context
          State specialized_state = state.clone();
          specialized_state.writeRegister(it, k);
          Context specialized_context =
              c.getAnalysis()
                  .getContextSensitivityStrategy()
                  .makeForInEntryContext(state.getContext(), n, k);
          //                    specialized_contexts.add(specialized_context);
          specialized_state.setContext(specialized_context);
          specialized_state.setBasicBlock(successor);
          // 2.2  Propagate specialized context
          c.propagateToFunctionEntry(
              n, state.getContext(), specialized_state, specialized_context, successor);
        }
      }
      if (!c.isScanning()) {
        // TODO: could kill flow to specializations if covered by other context
        // List<Context> previousSpecializations = c.getAnalysis().getForInSpecializations(n,
        // s.getContext());
        // if (previousSpecializations != null && (p.isArray() || p.isNonArray())) {
        //    previousSpecializations.forEach(c -> {
        //        // covered.setToNone();
        //    });
        //  }

        // TODO: could kill null flow unless all iterations has reached at least one EndForInNode
      }
      state.setToNone();
    } else { // fall back to simple mode without context specialization
      Value v1 = state.readRegister(n.getObjectRegister());
      state.writeRegister(
          n.getObjectRegister(), v1.makeExtendedScope()); // preserve the register value
      v1 = UnknownValueResolver.getRealValue(v1, state);
      Set<ObjectLabel> objs = Conversion.toObjectLabels(state, n, v1, c);
      Properties p = state.getEnumProperties(objs);
      Value proplist = p.toValue().joinNull();
      m.visitPropertyRead(n, objs, proplist, state, true);
      state.writeRegister(n.getPropertyListRegister(), proplist);
    }
  }
예제 #12
0
 /** Initializes the connection to the solver. */
 public void setSolverInterface(Solver.SolverInterface c) {
   this.c = c;
   m = c.getMonitoring();
 }
예제 #13
0
  public static void build(Solver.SolverInterface c) {
    State s = c.getState();
    PropVarOperations pv = c.getAnalysis().getPropVarOperations();
    CONSTRUCTOR = new ObjectLabel(DOMObjects.ELEMENT_CONSTRUCTOR, ObjectLabel.Kind.FUNCTION);
    PROTOTYPE = new ObjectLabel(DOMObjects.ELEMENT_PROTOTYPE, ObjectLabel.Kind.OBJECT);
    INSTANCES = new ObjectLabel(DOMObjects.ELEMENT_INSTANCES, ObjectLabel.Kind.OBJECT);

    // Constructor Object
    s.newObject(CONSTRUCTOR);
    pv.writePropertyWithAttributes(
        CONSTRUCTOR, "length", Value.makeNum(0).setAttributes(true, true, true));
    pv.writePropertyWithAttributes(
        CONSTRUCTOR, "prototype", Value.makeObject(PROTOTYPE).setAttributes(true, true, true));
    s.writeInternalPrototype(CONSTRUCTOR, Value.makeObject(InitialStateBuilder.OBJECT_PROTOTYPE));
    pv.writeProperty(DOMWindow.WINDOW, "Element", Value.makeObject(CONSTRUCTOR));

    // Prototype
    s.newObject(PROTOTYPE);
    s.writeInternalPrototype(PROTOTYPE, Value.makeObject(DOMNode.PROTOTYPE));

    // Multiplied object
    s.newObject(INSTANCES);
    s.writeInternalPrototype(INSTANCES, Value.makeObject(PROTOTYPE));

    /*
     * Properties.
     */
    // DOM Level 1
    createDOMProperty(INSTANCES, "tagName", Value.makeAnyStr(), c);

    s.multiplyObject(INSTANCES);
    INSTANCES = INSTANCES.makeSingleton().makeSummary();

    /*
     * Functions.
     */
    // Unknown
    createDOMFunction(
        PROTOTYPE, DOMObjects.ELEMENT_GET_BOUNDING_CLIENT_RECT, "getBoundingClientRect", 0, c);

    // DOM Level 1
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_GET_ATTRIBUTE, "getAttribute", 1, c);
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_SET_ATTRIBUTE, "setAttribute", 2, c);
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_REMOVE_ATTRIBUTE, "removeAttribute", 1, c);
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_GET_ATTRIBUTE_NODE, "getAttributeNode", 1, c);
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_SET_ATTRIBUTE_NODE, "setAttributeNode", 2, c);
    createDOMFunction(
        PROTOTYPE, DOMObjects.ELEMENT_REMOVE_ATTRIBUTE_NODE, "removeAttributeNode", 1, c);
    createDOMFunction(
        PROTOTYPE, DOMObjects.ELEMENT_GET_ELEMENTS_BY_TAGNAME, "getElementsByTagName", 1, c);

    // DOM Level 2
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_GET_ATTRIBUTE_NS, "getAttributeNS", 2, c);
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_SET_ATTRIBUTE_NS, "setAttributeNS", 3, c);
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_REMOVE_ATTRIBUTE_NS, "removeAttributeNS", 2, c);
    createDOMFunction(
        PROTOTYPE, DOMObjects.ELEMENT_GET_ATTRIBUTE_NODE_NS, "getAttributeNodeNS", 2, c);
    createDOMFunction(
        PROTOTYPE, DOMObjects.ELEMENT_SET_ATTRIBUTE_NODE_NS, "setAttributeNodeNS", 3, c);
    createDOMFunction(
        PROTOTYPE, DOMObjects.ELEMENT_GET_ELEMENTS_BY_TAGNAME_NS, "getElementsByTagNameNS", 2, c);
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_HAS_ATTRIBUTE, "hasAttribute", 1, c);
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_HAS_ATTRIBUTE_NS, "hasAttributeNS", 2, c);

    // DOM Level 3
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_SET_ID_ATTRIBUTE, "setIdAttribute", 2, c);
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_SET_ID_ATTRIBUTE_NS, "setIdAttributeNS", 3, c);
    createDOMFunction(
        PROTOTYPE, DOMObjects.ELEMENT_SET_ID_ATTRIBUTE_NODE, "setIdAttributeNode", 2, c);

    // DOM Level 2
    createDOMProperty(
        DOMAttr.INSTANCES, "ownerElement", Value.makeObject(INSTANCES).setReadOnly(), c);

    // semistandard
    createDOMFunction(PROTOTYPE, DOMObjects.ELEMENT_QUERY_SELECTOR_ALL, "querySelectorAll", 1, c);
  }
예제 #14
0
 /** Transfer Functions. */
 public static Value evaluate(DOMObjects nativeObject, CallInfo call, Solver.SolverInterface c) {
   State s = c.getState();
   switch (nativeObject) {
     case ELEMENT_GET_ATTRIBUTE:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 1, 1);
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c);
         return Value.makeAnyStr();
       }
     case ELEMENT_SET_ATTRIBUTE:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 2, 2);
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c);
         /* Value value =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 1), c);
         return Value.makeUndef();
       }
     case ELEMENT_REMOVE_ATTRIBUTE:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 1, 1);
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c);
         return Value.makeUndef();
       }
     case ELEMENT_GET_ATTRIBUTE_NS:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 2, 2);
         /* Value namespace =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c);
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 1), c);
         return Value.makeAnyStr();
       }
     case ELEMENT_GET_ATTRIBUTE_NODE:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 1, 1);
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c);
         return Value.makeObject(DOMAttr.INSTANCES);
       }
     case ELEMENT_GET_ATTRIBUTE_NODE_NS:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 2, 2);
         /* Value namespace =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c);
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 1), c);
         return Value.makeObject(DOMAttr.INSTANCES);
       }
     case ELEMENT_GET_BOUNDING_CLIENT_RECT:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 0, 0);
         return Value.makeObject(ClientBoundingRect.INSTANCES);
       }
     case ELEMENT_GET_ELEMENTS_BY_TAGNAME:
       {
         // TODO: needs precision, but cannot do like document.getElementsByTagName() bc. State is
         // for everything
         NativeFunctions.expectParameters(nativeObject, call, c, 1, 1);
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c);
         return Value.makeObject(DOMNodeList.INSTANCES);
       }
     case ELEMENT_GET_ELEMENTS_BY_TAGNAME_NS:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 2, 2);
         /* Value namespace =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c);
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 1), c);
         return Value.makeObject(DOMNodeList.INSTANCES);
       }
     case ELEMENT_HAS_ATTRIBUTE:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 1, 1);
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c);
         return Value.makeAnyBool();
       }
     case ELEMENT_HAS_ATTRIBUTE_NS:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 2, 2);
         /* Value namespace =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c);
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 1), c);
         return Value.makeAnyBool();
       }
     case ELEMENT_REMOVE_ATTRIBUTE_NS:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 2, 2);
         /* Value namespaceURI =*/ Conversion.toString(
             NativeFunctions.readParameter(call, s, 0), c);
         /* Value localName =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 1), c);
         return Value.makeUndef();
       }
     case ELEMENT_REMOVE_ATTRIBUTE_NODE:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 1, 1);
         return DOMConversion.toAttr(NativeFunctions.readParameter(call, s, 0), c);
       }
     case ELEMENT_SET_ATTRIBUTE_NS:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 3, 3);
         /* Value namespace =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c)
             .joinNull();
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 1), c);
         /* Value value =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 2), c);
         return Value.makeUndef();
       }
     case ELEMENT_SET_ATTRIBUTE_NODE:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 1, 1);
         /* Value newAttr =*/ DOMConversion.toAttr(NativeFunctions.readParameter(call, s, 0), c);
         return Value.makeObject(DOMAttr.INSTANCES).joinNull();
       }
     case ELEMENT_SET_ATTRIBUTE_NODE_NS:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 1, 1);
         /* Value newAttr =*/ DOMConversion.toAttr(NativeFunctions.readParameter(call, s, 0), c);
         return Value.makeObject(DOMAttr.INSTANCES).joinNull();
       }
     case ELEMENT_SET_ID_ATTRIBUTE:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 2, 2);
         /* Value name =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 0), c);
         /* Value isId =*/ Conversion.toBoolean(NativeFunctions.readParameter(call, s, 1));
         return Value.makeUndef();
       }
     case ELEMENT_SET_ID_ATTRIBUTE_NS:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 3, 3);
         /* Value namespaceURI =*/ Conversion.toString(
             NativeFunctions.readParameter(call, s, 0), c);
         /* Value localName =*/ Conversion.toString(NativeFunctions.readParameter(call, s, 1), c);
         /* Value isId =*/ Conversion.toBoolean(NativeFunctions.readParameter(call, s, 2));
         return Value.makeUndef();
       }
     case ELEMENT_SET_ID_ATTRIBUTE_NODE:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 2, 2);
         /* Value idAttr =*/ DOMConversion.toAttr(NativeFunctions.readParameter(call, s, 0), c);
         /* Value isId =*/ Conversion.toBoolean(NativeFunctions.readParameter(call, s, 1));
         return Value.makeUndef();
       }
     case ELEMENT_QUERY_SELECTOR_ALL:
       {
         NativeFunctions.expectParameters(nativeObject, call, c, 1, 1);
         return Value.makeObject(DOMNodeList.INSTANCES);
       }
     default:
       {
         throw new AnalysisException("Unknown Native Object: " + nativeObject);
       }
   }
 }