jdk8-mips64-public/nashorn: comparison src/jdk/nashorn/internal/parser/Parser.java

-:f3dcb12c8439
+:544e17632e96
 * Set up a new block.
 *
 * @return New block.
 */
 private Block newBlock() {
-final Block block = new Block(source, token, Token.descPosition(token));
+return lc.push(new Block(token, Token.descPosition(token)));
-return lc.push(block);
 }
 /**
 * Set up a new function block.
 *
 default:
 break;
 }
 // Build up node.
-return new BinaryNode(source, op, lhs, rhs);
+return new BinaryNode(op, lhs, rhs);
 }
 /**
 * Reduce increment/decrement to simpler operations.
 * @param firstToken First token.
 * @param tokenType  Operation token (INCPREFIX/DEC.)
 * @param expression Left hand side expression.
 * @param isPostfix  Prefix or postfix.
 * @return           Reduced expression.
 */
-private Node incDecExpression(final long firstToken, final TokenType tokenType, final Node expression, final boolean isPostfix) {
+private static Node incDecExpression(final long firstToken, final TokenType tokenType, final Node expression, final boolean isPostfix) {
 if (isPostfix) {
-return new UnaryNode(source, Token.recast(firstToken, tokenType == DECPREFIX ? DECPOSTFIX : INCPOSTFIX), expression.getStart(), Token.descPosition(firstToken) + Token.descLength(firstToken), expression);
+return new UnaryNode(Token.recast(firstToken, tokenType == DECPREFIX ? DECPOSTFIX : INCPOSTFIX), expression.getStart(), Token.descPosition(firstToken) + Token.descLength(firstToken), expression);
 }
-return new UnaryNode(source, firstToken, expression);
+return new UnaryNode(firstToken, expression);
 }
 /**
 * -----------------------------------------------------------------------
 *
 final long functionToken = Token.toDesc(FUNCTION, 0, source.getLength());
 // Set up the script to append elements.
 FunctionNode script = newFunctionNode(
 functionToken,
-new IdentNode(source, functionToken, Token.descPosition(functionToken), scriptName),
+new IdentNode(functionToken, Token.descPosition(functionToken), scriptName),
 new ArrayList<IdentNode>(),
 FunctionNode.Kind.SCRIPT);
 functionDeclarations = new ArrayList<>();
 sourceElements();
 * Parse a statement block.
 */
 private void block() {
 final Block newBlock = getBlock(true);
 // Force block execution.
-appendStatement(new ExecuteNode(source, newBlock.getToken(), finish, newBlock));
+appendStatement(new ExecuteNode(newBlock.getToken(), finish, newBlock));
 }
 /**
 * StatementList :
 *      Statement
 // Get initializer expression. Suppress IN if not statement.
 init = assignmentExpression(!isStatement);
 }
 // Allocate var node.
-final VarNode var = new VarNode(source, varToken, finish, name, init);
+final VarNode var = new VarNode(varToken, finish, name, init);
 vars.add(var);
 appendStatement(var);
 if (type != COMMARIGHT) {
 break;
 *
 * Parse an empty statement.
 */
 private void emptyStatement() {
 if (env._empty_statements) {
-appendStatement(new EmptyNode(source, token, Token.descPosition(token) + Token.descLength(token)));
+appendStatement(new EmptyNode(token, Token.descPosition(token) + Token.descLength(token)));
 }
 // SEMICOLON checked in caller.
 next();
 }
 // Get expression and add as statement.
 final Node expression = expression();
 ExecuteNode executeNode = null;
 if (expression != null) {
-executeNode = new ExecuteNode(source, expressionToken, finish, expression);
+executeNode = new ExecuteNode(expressionToken, finish, expression);
 appendStatement(executeNode);
 } else {
 expect(null);
 }
 if (type == ELSE) {
 next();
 fail = getStatement();
 }
-appendStatement(new IfNode(source, ifToken, fail != null ? fail.getFinish() : pass.getFinish(), test, pass, fail));
+appendStatement(new IfNode(ifToken, fail != null ? fail.getFinish() : pass.getFinish(), test, pass, fail));
 }
 /**
 * ... IterationStatement:
 *           ...
 *
 * Parse a FOR statement.
 */
 private void forStatement() {
 // Create FOR node, capturing FOR token.
-ForNode forNode = new ForNode(source, token, Token.descPosition(token), null, null, null, null, ForNode.IS_FOR);
+ForNode forNode = new ForNode(token, Token.descPosition(token), null, null, null, null, ForNode.IS_FOR);
 // Set up new block for scope of vars. Captures first token.
 Block outer = newBlock();
 lc.push(forNode);
 } finally {
 lc.pop(forNode);
 outer = restoreBlock(outer);
 }
-appendStatement(new ExecuteNode(source, outer.getToken(), outer.getFinish(), outer));
+appendStatement(new ExecuteNode(outer.getToken(), outer.getFinish(), outer));
 }
 /**
 * ... IterationStatement :
 *           ...
 final long whileToken = token;
 // WHILE tested in caller.
 next();
 // Construct WHILE node.
-WhileNode whileNode = new WhileNode(source, whileToken, Token.descPosition(whileToken), false);
+WhileNode whileNode = new WhileNode(whileToken, Token.descPosition(whileToken), false);
 lc.push(whileNode);
 try {
 expect(LPAREN);
 whileNode = whileNode.setTest(lc, expression());
 // Capture DO token.
 final long doToken = token;
 // DO tested in the caller.
 next();
-WhileNode doWhileNode = new WhileNode(source, doToken, Token.descPosition(doToken), true);
+WhileNode doWhileNode = new WhileNode(doToken, Token.descPosition(doToken), true);
 lc.push(doWhileNode);
 try {
 // Get DO body.
 doWhileNode = doWhileNode.setBody(lc, getStatement());
 }
 endOfLine();
 // Construct and add CONTINUE node.
-appendStatement(new ContinueNode(source, continueToken, finish, label == null ? null : new IdentNode(label)));
+appendStatement(new ContinueNode(continueToken, finish, label == null ? null : new IdentNode(label)));
 }
 /**
 * BreakStatement :
 *      break Identifier? ; // [no LineTerminator here]
 }
 endOfLine();
 // Construct and add BREAK node.
-appendStatement(new BreakNode(source, breakToken, finish, label == null ? null : new IdentNode(label)));
+appendStatement(new BreakNode(breakToken, finish, label == null ? null : new IdentNode(label)));
 }
 /**
 * ReturnStatement :
 *      return Expression? ; // [no LineTerminator here]
 }
 endOfLine();
 // Construct and add RETURN node.
-appendStatement(new ReturnNode(source, returnToken, finish, expression));
+appendStatement(new ReturnNode(returnToken, finish, expression));
 }
 /**
 * YieldStatement :
 *      yield Expression? ; // [no LineTerminator here]
 }
 endOfLine();
 // Construct and add YIELD node.
-appendStatement(new ReturnNode(source, yieldToken, finish, expression));
+appendStatement(new ReturnNode(yieldToken, finish, expression));
 }
 /**
 * WithStatement :
 *      with ( Expression ) Statement
 if (isStrictMode) {
 throw error(AbstractParser.message("strict.no.with"), withToken);
 }
 // Get WITH expression.
-WithNode withNode = new WithNode(source, withToken, finish);
+WithNode withNode = new WithNode(withToken, finish);
 try {
 lc.push(withNode);
 expect(LPAREN);
 withNode = withNode.setExpression(lc, expression());
 final long switchToken = token;
 // SWITCH tested in caller.
 next();
 // Create and add switch statement.
-SwitchNode switchNode = new SwitchNode(source, switchToken, Token.descPosition(switchToken), null, new ArrayList<CaseNode>(), null);
+SwitchNode switchNode = new SwitchNode(switchToken, Token.descPosition(switchToken), null, new ArrayList<CaseNode>(), null);
 lc.push(switchNode);
 try {
 expect(LPAREN);
 switchNode = switchNode.setExpression(lc, expression());
 expect(COLON);
 // Get CASE body.
 final Block statements = getBlock(false);
-final CaseNode caseNode = new CaseNode(source, caseToken, finish, caseExpression, statements);
+final CaseNode caseNode = new CaseNode(caseToken, finish, caseExpression, statements);
 statements.setFinish(finish);
 if (caseExpression == null) {
 defaultCase = caseNode;
 }
 if (lc.findLabel(ident.getName()) != null) {
 throw error(AbstractParser.message("duplicate.label", ident.getName()), labelToken);
 }
-LabelNode labelNode = new LabelNode(source, labelToken, finish, ident, null);
+LabelNode labelNode = new LabelNode(labelToken, finish, ident, null);
 try {
 lc.push(labelNode);
 labelNode = labelNode.setBody(lc, getStatement());
 labelNode.setFinish(finish);
 appendStatement(labelNode);
 throw error(AbstractParser.message("expected.operand", type.getNameOrType()));
 }
 endOfLine();
-appendStatement(new ThrowNode(source, throwToken, finish, expression));
+appendStatement(new ThrowNode(throwToken, finish, expression));
 }
 /**
 * TryStatement :
 *      try Block Catch
 Block catchBlock = newBlock();
 try {
 // Get CATCH body.
 final Block catchBody = getBlock(true);
-final CatchNode catchNode = new CatchNode(source, catchToken, finish, exception, ifExpression, catchBody);
+final CatchNode catchNode = new CatchNode(catchToken, finish, exception, ifExpression, catchBody);
 appendStatement(catchNode);
 } finally {
 catchBlock = restoreBlock(catchBlock);
 catchBlocks.add(catchBlock);
 }
 // Need at least one catch or a finally.
 if (catchBlocks.isEmpty() && finallyStatements == null) {
 throw error(AbstractParser.message("missing.catch.or.finally"), tryToken);
 }
-final TryNode tryNode = new TryNode(source, tryToken, Token.descPosition(tryToken), tryBody, catchBlocks, finallyStatements);
+final TryNode tryNode = new TryNode(tryToken, Token.descPosition(tryToken), tryBody, catchBlocks, finallyStatements);
 // Add try.
 assert lc.peek() == outer;
 appendStatement(tryNode);
 tryNode.setFinish(finish);
 } finally {
 outer = restoreBlock(outer);
 }
-appendStatement(new ExecuteNode(source, outer.getToken(), outer.getFinish(), outer));
+appendStatement(new ExecuteNode(outer.getToken(), outer.getFinish(), outer));
 }
 /**
 * DebuggerStatement :
 *      debugger ;
 // Capture DEBUGGER token.
 final long debuggerToken = token;
 // DEBUGGER tested in caller.
 next();
 endOfLine();
-appendStatement(new RuntimeNode(source, debuggerToken, finish, RuntimeNode.Request.DEBUGGER, new ArrayList<Node>()));
+appendStatement(new RuntimeNode(debuggerToken, finish, RuntimeNode.Request.DEBUGGER, new ArrayList<Node>()));
 }
 /**
 * PrimaryExpression :
 *      this
 switch (type) {
 case THIS:
 final String name = type.getName();
 next();
-return new IdentNode(source, primaryToken, finish, name);
+return new IdentNode(primaryToken, finish, name);
 case IDENT:
 final IdentNode ident = getIdent();
 if (ident == null) {
 break;
 }
 return getLiteral();
 case EXECSTRING:
 return execString(primaryToken);
 case FALSE:
 next();
-return LiteralNode.newInstance(source, primaryToken, finish, false);
+return LiteralNode.newInstance(primaryToken, finish, false);
 case TRUE:
 next();
-return LiteralNode.newInstance(source, primaryToken, finish, true);
+return LiteralNode.newInstance(primaryToken, finish, true);
 case NULL:
 next();
-return LiteralNode.newInstance(source, primaryToken, finish);
+return LiteralNode.newInstance(primaryToken, finish);
 case LBRACKET:
 return arrayLiteral();
 case LBRACE:
 return objectLiteral();
 case LPAREN:
 * @param primaryToken Original string token.
 * @return callNode to $EXEC.
 */
 Node execString(final long primaryToken) {
 // Synthesize an ident to call $EXEC.
-final IdentNode execIdent = new IdentNode(source, primaryToken, finish, ScriptingFunctions.EXEC_NAME);
+final IdentNode execIdent = new IdentNode(primaryToken, finish, ScriptingFunctions.EXEC_NAME);
 // Skip over EXECSTRING.
 next();
 // Set up argument list for call.
 final List<Node> arguments = new ArrayList<>();
 // Skip beginning of edit string expression.
 // Add the following expression to arguments.
 arguments.add(expression());
 // Skip ending of edit string expression.
 expect(RBRACE);
-return new CallNode(source, primaryToken, finish, execIdent, arguments);
+return new CallNode(primaryToken, finish, execIdent, arguments);
 }
 /**
 * ArrayLiteral :
 *      [ Elision? ]
 elision = false;
 break;
 }
 }
-return LiteralNode.newInstance(source, arrayToken, finish, elements);
+return LiteralNode.newInstance(arrayToken, finish, elements);
 }
 /**
 * ObjectLiteral :
 *      { }
 if (value != null) {
 if (prevValue == null) {
 map.put(key, newProperty = newProperty.setValue(value));
 } else {
 final long propertyToken = Token.recast(newProperty.getToken(), COMMARIGHT);
-map.put(key, newProperty = newProperty.setValue(new BinaryNode(source, propertyToken, prevValue, value)));
+map.put(key, newProperty = newProperty.setValue(new BinaryNode(propertyToken, prevValue, value)));
 }
 map.put(key, newProperty = newProperty.setGetter(null).setSetter(null));
 }
 }
 break;
 }
 }
-return new ObjectNode(source, objectToken, finish, new ArrayList<Node>(map.values()));
+return new ObjectNode(objectToken, finish, new ArrayList<Node>(map.values()));
 }
 /**
 * PropertyName :
 *      IdentifierName
 switch (ident) {
 case "get":
 final PropertyKey getIdent = propertyName();
 final String getterName = getIdent.getPropertyName();
-final IdentNode getNameNode = new IdentNode(source, ((Node)getIdent).getToken(), finish, "get " + getterName);
+final IdentNode getNameNode = new IdentNode(((Node)getIdent).getToken(), finish, "get " + getterName);
 expect(LPAREN);
 expect(RPAREN);
 functionNode = functionBody(getSetToken, getNameNode, new ArrayList<IdentNode>(), FunctionNode.Kind.GETTER);
-return new PropertyNode(source, propertyToken, finish, getIdent, null, functionNode, null);
+return new PropertyNode(propertyToken, finish, getIdent, null, functionNode, null);
 case "set":
 final PropertyKey setIdent = propertyName();
 final String setterName = setIdent.getPropertyName();
-final IdentNode setNameNode = new IdentNode(source, ((Node)setIdent).getToken(), finish, "set " + setterName);
+final IdentNode setNameNode = new IdentNode(((Node)setIdent).getToken(), finish, "set " + setterName);
 expect(LPAREN);
 final IdentNode argIdent = getIdent();
 verifyStrictIdent(argIdent, "setter argument");
 expect(RPAREN);
 List<IdentNode> parameters = new ArrayList<>();
 parameters.add(argIdent);
 functionNode = functionBody(getSetToken, setNameNode, parameters, FunctionNode.Kind.SETTER);
-return new PropertyNode(source, propertyToken, finish, setIdent, null, null, functionNode);
+return new PropertyNode(propertyToken, finish, setIdent, null, null, functionNode);
 default:
 break;
 }
 }
-propertyName =  new IdentNode(source, propertyToken, finish, ident);
+propertyName =  new IdentNode(propertyToken, finish, ident);
 } else {
 propertyName = propertyName();
 }
 expect(COLON);
-return new PropertyNode(source, propertyToken, finish, propertyName, assignmentExpression(false), null, null);
+return new PropertyNode(propertyToken, finish, propertyName, assignmentExpression(false), null, null);
 }
 /**
 * LeftHandSideExpression :
 *      NewExpression
 // Catch special functions.
 if (lhs instanceof IdentNode) {
 detectSpecialFunction((IdentNode)lhs);
 }
-lhs = new CallNode(source, callToken, finish, lhs, arguments);
+lhs = new CallNode(callToken, finish, lhs, arguments);
 }
 loop:
 while (true) {
 // Capture token.
 case LPAREN:
 // Get NEW or FUNCTION arguments.
 final List<Node> arguments = argumentList();
 // Create call node.
-lhs = new CallNode(source, callToken, finish, lhs, arguments);
+lhs = new CallNode(callToken, finish, lhs, arguments);
 break;
 case LBRACKET:
 next();
 final Node rhs = expression();
 expect(RBRACKET);
 // Create indexing node.
-lhs = new IndexNode(source, callToken, finish, lhs, rhs);
+lhs = new IndexNode(callToken, finish, lhs, rhs);
 break;
 case PERIOD:
 next();
 final IdentNode property = getIdentifierName();
 // Create property access node.
-lhs = new AccessNode(source, callToken, finish, lhs, property);
+lhs = new AccessNode(callToken, finish, lhs, property);
 break;
 default:
 break loop;
 if (!env._no_syntax_extensions && type == LBRACE) {
 arguments.add(objectLiteral());
 }
-final CallNode callNode = new CallNode(source, constructor.getToken(), finish, constructor, arguments);
+final CallNode callNode = new CallNode(constructor.getToken(), finish, constructor, arguments);
-return new UnaryNode(source, newToken, callNode);
+return new UnaryNode(newToken, callNode);
 }
 /**
 * MemberExpression :
 *      PrimaryExpression
 final Node index = expression();
 expect(RBRACKET);
 // Create indexing node.
-lhs = new IndexNode(source, callToken, finish, lhs, index);
+lhs = new IndexNode(callToken, finish, lhs, index);
 break;
 case PERIOD:
 if (lhs == null) {
 next();
 final IdentNode property = getIdentifierName();
 // Create property access node.
-lhs = new AccessNode(source, callToken, finish, lhs, property);
+lhs = new AccessNode(callToken, finish, lhs, property);
 break;
 default:
 break loop;
 // name is null, generate anonymous name
 boolean isAnonymous = false;
 if (name == null) {
 final String tmpName = "_L" + source.getLine(Token.descPosition(token));
-name = new IdentNode(source, functionToken, Token.descPosition(functionToken), tmpName);
+name = new IdentNode(functionToken, Token.descPosition(functionToken), tmpName);
 isAnonymous = true;
 }
 expect(LPAREN);
 final List<IdentNode> parameters = formalParameterList();
 throw error(AbstractParser.message("strict.param.redefinition", parameterName), parameter.getToken());
 }
 // rename in non-strict mode
 parameterName = functionNode.uniqueName(parameterName);
 final long parameterToken = parameter.getToken();
-parameters.set(i, new IdentNode(source, parameterToken, Token.descPosition(parameterToken), functionNode.uniqueName(parameterName)));
+parameters.set(i, new IdentNode(parameterToken, Token.descPosition(parameterToken), functionNode.uniqueName(parameterName)));
 }
 parametersSet.add(parameterName);
 }
 } else if (arity == 1) {
 functionNode = functionNode.setFlag(lc, FunctionNode.DEFINES_ARGUMENTS);
 }
 }
 if (isStatement) {
-final VarNode varNode = new VarNode(source, functionToken, finish, name, functionNode, VarNode.IS_STATEMENT);
+final VarNode varNode = new VarNode(functionToken, finish, name, functionNode, VarNode.IS_STATEMENT);
 if (topLevel) {
 functionDeclarations.add(lineNumber);
 functionDeclarations.add(varNode);
 } else {
 appendStatement(lineNumber);
 // just expression as function body
 final Node expr = expression();
 assert lc.getCurrentBlock() == lc.getFunctionBody(functionNode);
 // create a return statement - this creates code in itself and does not need to be
 // wrapped into an ExecuteNode
-final ReturnNode returnNode = new ReturnNode(source, expr.getToken(), finish, expr);
+final ReturnNode returnNode = new ReturnNode(expr.getToken(), finish, expr);
 appendStatement(returnNode);
 lastToken = token;
 functionNode.setFinish(Token.descPosition(token) + Token.descLength(token));
 } else {
 }
 prependStatement(decl);
 }
 }
-private RuntimeNode referenceError(final Node lhs, final Node rhs) {
+private static RuntimeNode referenceError(final Node lhs, final Node rhs) {
 final ArrayList<Node> args = new ArrayList<>();
 args.add(lhs);
 if (rhs == null) {
-args.add(LiteralNode.newInstance(source, lhs.getToken(), lhs.getFinish()));
+args.add(LiteralNode.newInstance(lhs.getToken(), lhs.getFinish()));
 } else {
 args.add(rhs);
 }
-args.add(LiteralNode.newInstance(source, lhs.getToken(), lhs.getFinish(), lhs.toString()));
+args.add(LiteralNode.newInstance(lhs.getToken(), lhs.getFinish(), lhs.toString()));
-return new RuntimeNode(source, lhs.getToken(), lhs.getFinish(), RuntimeNode.Request.REFERENCE_ERROR, args);
+return new RuntimeNode(lhs.getToken(), lhs.getFinish(), RuntimeNode.Request.REFERENCE_ERROR, args);
 }
 /*
 * parse LHS [a, b, ..., c].
 *
 case SUB:
 case BIT_NOT:
 case NOT:
 next();
 final Node expr = unaryExpression();
-return new UnaryNode(source, unaryToken, expr);
+return new UnaryNode(unaryToken, expr);
 case INCPREFIX:
 case DECPREFIX:
 final TokenType opType = type;
 next();
 // Fail expression.
 final Node third = expression(unaryExpression(), ASSIGN.getPrecedence(), noIn);
 // Build up node.
-lhs = new TernaryNode(source, op, lhs, rhs, third);
+lhs = new TernaryNode(op, lhs, rhs, third);
 } else {
 // Skip operator.
 next();
 // Get the next primary expression.
 /**
 * Add a line number node at current position
 */
 private LineNumberNode lineNumber() {
 if (env._debug_lines) {
-return new LineNumberNode(source, token, line);
+return new LineNumberNode(token, line);
 }
 return null;
 }
 @Override

Mercurial > jdk8-mips64-public > nashorn / file comparison

comparison: src/jdk/nashorn/internal/parser/Parser.java

src/jdk/nashorn/internal/parser/Parser.java