Java AstNode.getType方法代码示例

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
@Override
public boolean visit(AstNode node) {
	switch (node.getType()) {
		case Token.NAME:
		case Token.STRING:
		case Token.NUMBER:
		case Token.OBJECTLIT:
		case Token.ARRAYLIT:
		case Token.TRUE:
		case Token.FALSE:
			lastNode = node;
			break;
		case Token.NEW:
			isNew = true;
			break;
	}
	return true;
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
/**
 * Overridden iterateNode to intercept Token.EXPR_RESULT and check for importPackage and importClass named nodes
 * If found, then process them and extract the imports and add them to RhinoJavaScriptTypesFactory then return
 * otherwise call super.iterateNode() 
 */
@Override
protected void iterateNode(AstNode child, Set <Completion>set,
		String entered, CodeBlock block, int offset) {
	
	//look for importPackage and importClass
	switch (child.getType()) {
		case Token.EXPR_RESULT:
			boolean importFound = processImportNode(child, set, entered, block, offset);
			if(importFound)
				return; //already processed node
			break;
	}
	
	super.iterateNode(child, set, entered, block, offset);
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
@Override
		public boolean visit(AstNode node) {

			switch (node.getType()) {
				case Token.FUNCTION:
					if (containsOffs(node)) {
						deepestScope = node;
						return true;
					}
					return false;
				default:
					return true;
				case Token.BLOCK: // Get scope starting at e.g. "function", not "{"
//					if (node.getParent().getType()==Token.FUNCTION) {
//						System.out.println("Skipping block for function");
//						return false;
//					}
//					System.out.println("Non-function block found");
					return true;
			}

		}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
/**
 * Lookup the name of the node within the last JavaScript type. e.g var a =
 * 1; var b = a.MAX_VALUE; looks up MAX_VALUE within NumberLiteral a where a
 * is resolve before as a JavaScript Number;
 * 
 * @param node
 * @param lastJavaScriptType
 * @return
 */
protected JavaScriptType lookupFromName(AstNode node,
		JavaScriptType lastJavaScriptType) {
	JavaScriptType javaScriptType = null;
	if (lastJavaScriptType != null) {
		String lookupText = null;
		switch (node.getType()) {
			case Token.NAME:
				lookupText = ((Name) node).getIdentifier();
				break;
		}
		if (lookupText == null) {
			// just try the source
			lookupText = node.toSource();
		}
		javaScriptType = lookupJavaScriptType(lastJavaScriptType,
				lookupText);
	}
	return javaScriptType;
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
private Node transformArrayLiteral(ArrayLiteral node) {
    if (node.isDestructuring()) {
        return node;
    }
    decompiler.addToken(Token.LB);
    List<AstNode> elems = node.getElements();
    Node array = new Node(Token.ARRAYLIT);
    List<Integer> skipIndexes = null;
    for (int i = 0; i < elems.size(); ++i) {
        AstNode elem = elems.get(i);
        if (elem.getType() != Token.EMPTY) {
            array.addChildToBack(transform(elem));
        } else {
            if (skipIndexes == null) {
                skipIndexes = new ArrayList<Integer>();
            }
            skipIndexes.add(i);
        }
        if (i < elems.size() - 1)
            decompiler.addToken(Token.COMMA);
    }
    decompiler.addToken(Token.RB);
    array.putIntProp(Node.DESTRUCTURING_ARRAY_LENGTH,
                     node.getDestructuringLength());
    if (skipIndexes != null) {
        int[] skips = new int[skipIndexes.size()];
        for (int i = 0; i < skipIndexes.size(); i++)
            skips[i] = skipIndexes.get(i);
        array.putProp(Node.SKIP_INDEXES_PROP, skips);
    }
    return array;
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
void decompile(AstNode node) {
    switch (node.getType()) {
      case Token.ARRAYLIT:
          decompileArrayLiteral((ArrayLiteral)node);
          break;
      case Token.OBJECTLIT:
          decompileObjectLiteral((ObjectLiteral)node);
          break;
      case Token.STRING:
          decompiler.addString(((StringLiteral)node).getValue());
          break;
      case Token.NAME:
          decompiler.addName(((Name)node).getIdentifier());
          break;
      case Token.NUMBER:
          decompiler.addNumber(((NumberLiteral)node).getNumber());
          break;
      case Token.GETPROP:
          decompilePropertyGet((PropertyGet)node);
          break;
      case Token.EMPTY:
          break;
      case Token.GETELEM:
          decompileElementGet((ElementGet) node);
          break;
      case Token.THIS:
          decompiler.addToken(node.getType());
          break;
      default:
          Kit.codeBug("unexpected token: "
                      + Token.typeToName(node.getType()));
    }
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
private void arrowFunctionParams(FunctionNode fnNode, AstNode params, Map<String, Node> destructuring, Set<String> paramNames) {
    if (params instanceof ArrayLiteral || params instanceof ObjectLiteral) {
        markDestructuring(params);
        fnNode.addParam(params);
        String pname = currentScriptOrFn.getNextTempName();
        defineSymbol(Token.LP, pname, false);
        destructuring.put(pname, params);
    } else if (params instanceof InfixExpression && params.getType() == Token.COMMA) {
        arrowFunctionParams(fnNode, ((InfixExpression)params).getLeft(), destructuring, paramNames);
        arrowFunctionParams(fnNode, ((InfixExpression)params).getRight(), destructuring, paramNames);
    } else if (params instanceof Name) {
        fnNode.addParam(params);
        String paramName = ((Name)params).getIdentifier();
        defineSymbol(Token.LP, paramName);

        if (this.inUseStrictDirective) {
            if ("eval".equals(paramName) ||
                "arguments".equals(paramName))
                {
                    reportError("msg.bad.id.strict", paramName);
                }
            if (paramNames.contains(paramName))
                addError("msg.dup.param.strict", paramName);
            paramNames.add(paramName);
        }
    } else {
        reportError("msg.no.parm", params.getPosition(), params.getLength());
        fnNode.addParam(makeErrorNode());
    }
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
private AstNode parenExpr() throws IOException {
    boolean wasInForInit = inForInit;
    inForInit = false;
    try {
        Comment jsdocNode = getAndResetJsDoc();
        int lineno = ts.lineno;
        int begin = ts.tokenBeg;
        AstNode e = (peekToken() == Token.RP ? new EmptyExpression(begin) : expr());
        if (peekToken() == Token.FOR) {
            return generatorExpression(e, begin);
        }
        ParenthesizedExpression pn = new ParenthesizedExpression(e);
        if (jsdocNode == null) {
            jsdocNode = getAndResetJsDoc();
        }
        if (jsdocNode != null) {
            pn.setJsDocNode(jsdocNode);
        }
        mustMatchToken(Token.RP, "msg.no.paren");
        if (e.getType() == Token.EMPTY && peekToken() != Token.ARROW) {
          reportError("msg.syntax");
          return makeErrorNode();
        }
        pn.setLength(ts.tokenEnd - pn.getPosition());
        pn.setLineno(lineno);
        return pn;
    } finally {
        inForInit = wasInForInit;
    }
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
private void checkCallRequiresActivation(AstNode pn) {
    if ((pn.getType() == Token.NAME
         && "eval".equals(((Name)pn).getIdentifier()))
        || (pn.getType() == Token.GETPROP &&
            "eval".equals(((PropertyGet)pn).getProperty().getIdentifier())))
        setRequiresActivation();
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
private void checkBadIncDec(UnaryExpression expr) {
    AstNode op = removeParens(expr.getOperand());
    int tt = op.getType();
    if (!(tt == Token.NAME
          || tt == Token.GETPROP
          || tt == Token.GETELEM
          || tt == Token.GET_REF
          || tt == Token.CALL))
        reportError(expr.getType() == Token.INC
                    ? "msg.bad.incr"
                    : "msg.bad.decr");
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
boolean destructuringArray(ArrayLiteral array,
                           int variableType,
                           String tempName,
                           Node parent,
                           List<String> destructuringNames)
{
    boolean empty = true;
    int setOp = variableType == Token.CONST
        ? Token.SETCONST : Token.SETNAME;
    int index = 0;
    for (AstNode n : array.getElements()) {
        if (n.getType() == Token.EMPTY) {
            index++;
            continue;
        }
        Node rightElem = new Node(Token.GETELEM,
                                  createName(tempName),
                                  createNumber(index));
        if (n.getType() == Token.NAME) {
            String name = n.getString();
            parent.addChildToBack(new Node(setOp,
                                          createName(Token.BINDNAME,
                                                     name, null),
                                          rightElem));
            if (variableType != -1) {
                defineSymbol(variableType, name, true);
                destructuringNames.add(name);
            }
        } else {
            parent.addChildToBack
                (destructuringAssignmentHelper
                 (variableType, n,
                  rightElem,
                  currentScriptOrFn.getNextTempName()));
        }
        index++;
        empty = false;
    }
    return empty;
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
public boolean visit(AstNode node) {
  if (node.getType() == Token.FUNCTION) {
    if (node.getEnclosingFunction() != null) {
      count++;
    }
  }
  return true;
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
@Override
public boolean visit(AstNode node) {
	if( Token.NAME == node.getType()){
		if(node.getParent().getType() == Token.CALL){
			FunctionCall parent = (FunctionCall)node.getParent();
			if(parent.getTarget()==node){
				resultSoFar.add(safeGetString(node));
			}
		}
	}
	return true;
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
protected static String safeGetString(AstNode node){
	if(node.getType() == Token.STRING){
		StringLiteral sl = (StringLiteral)node;
		return sl.getValue();
	}else if(node.getType()==Token.NUMBER){
		NumberLiteral nl = (NumberLiteral)node;
		return nl.getValue();
	}else{
		return node.getString();
	}
}
 

import org.mozilla.javascript.ast.AstNode; //导入方法依赖的package包/类
@Override
public boolean visit(final AstNode node) {
  if (isRootNode(node)) {
    if (node.getType() == Token.ASSIGN) {
      visitAssignment((Assignment) node);
    } else if (node.getType() == Token.CONST) {
      LOG.error("FIXME:Const node detected, not parsed in file:{}", fileName);
    } else {
      visitOtherNode(node);
    }
  }
  return true;
}