Exemple #1
0
  protected void recursiveParse(Node node) {
    // Ignore null nodes or those we have seen before!
    if (node == null || parsedNodes.contains(node)) {
      return;
    }

    // Script level nodes have global list of function definitions.
    // Parse inner tokens for function definitions here.
    if (node instanceof ScriptOrFnNode) {
      ScriptOrFnNode sofn = (ScriptOrFnNode) node;
      int count = sofn.getFunctionCount() - 1;
      while (count > -1) {
        FunctionNode fn = sofn.getFunctionNode(count);
        recursiveParse(fn);
        count--;
      }
    }

    // Parse children from left to right.
    recursiveParse(node.getFirstChild());
    recursiveParse(node.getLastChild());

    // Parse this node and then move along to next
    parseNode(node);
    parsedNodes.add(node);

    recursiveParse(node.getNext());
  }
Exemple #2
0
  protected Map<String, String> findLiteralStringValues(Node objLiteral) {
    Map<String, String> literalValues = new HashMap<String, String>();

    // Find object literal keys from property list.
    Object[] propertyList = (Object[]) objLiteral.getProp(Token.EQ);

    // Iterate through each literal key, extracting associated value. Ignore
    // any non-string values, we aren't attempting inner-resolution of references.
    if (propertyList != null) {
      int numArgs = 0;
      // Child nodes are linked list of object values
      Node propertyValue = objLiteral.getFirstChild();

      while (numArgs < propertyList.length) {
        // Convert key/value pairs into a handy format
        if (propertyValue.getType() == Token.STRING) {
          literalValues.put((String) propertyList[numArgs], propertyValue.getString());
        }

        propertyValue = propertyValue.getNext();
        numArgs++;
      }
    }

    return literalValues;
  }
Exemple #3
0
  // Given child nodes for a function call, object ref and arguments, return
  // the string value for the first argument. Ignore any complicated resolution.
  protected String functionCallArgument(Node functionCallNodes, int argIndex) {
    String fnCallArg = null;

    // Traverse argument nodes until we reach desired one.
    Node argument = functionCallNodes.getNext();
    while (argument != null && argIndex > 0) {
      argument = argument.getNext();
      argIndex--;
    }
    ;

    // Check we have a simple type value.
    if (argument != null && argument.getType() == Token.STRING) {
      fnCallArg = argument.getString();
    }

    return fnCallArg;
  }
Exemple #4
0
  // Extract property name accessed. Will have two child nodes,
  // object reference and property name. Ignore any further
  // variable resolution.
  protected String functionPropertyName(Node propertyLookup) {
    String propertyName = null;

    // First argument is an object reference that lookup should be
    // performed against.
    Node objectReference = propertyLookup.getFirstChild();

    if (objectReference != null) {
      // Find property identifier we are retrieving...
      Node propertyNameNode = objectReference.getNext();

      // Only handle explicit string properties, we cannot resolve variables.
      if (propertyNameNode != null && propertyNameNode.getType() == Token.STRING) {
        propertyName = propertyNameNode.getString();
      }
    }

    return propertyName;
  }
Exemple #5
0
  // Find an object literal's value for a given key. If not found,
  // return null.
  protected Node findLiteralValue(Node objLiteral, String key) {
    Node literalValueNode = null;

    // Get list of all properties
    Object[] propertyList = (Object[]) objLiteral.getProp(Token.EQ);

    // Iterate through key/values looking for a match
    if (propertyList != null) {
      Node propertyValue = objLiteral.getFirstChild();
      for (int index = 0; index < propertyList.length; index++) {
        if (key.equals(propertyList[index])) {
          literalValueNode = propertyValue;
          break;
        }
        propertyValue = propertyValue.getNext();
      }
    }

    return literalValueNode;
  }