jdk8-mips64-public/nashorn: src/jdk/nashorn/internal/ir/debug/JSONWriter.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/ir/debug/JSONWriter.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/ir/debug/JSONWriter.java

Thu, 24 May 2018 16:39:31 +0800

author: aoqi
date: Thu, 24 May 2018 16:39:31 +0800
changeset 1959: 61ffdd1b89f2
parent 1552: b0888b955b31
parent 1490: d85f981c8cf8
permissions: -rw-r--r--

Merge

 /*
  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package jdk.nashorn.internal.ir.debug;
 import static jdk.nashorn.internal.runtime.Source.sourceFor;
 import java.util.ArrayList;
 import java.util.List;
 import jdk.nashorn.internal.ir.AccessNode;
 import jdk.nashorn.internal.ir.BinaryNode;
 import jdk.nashorn.internal.ir.Block;
 import jdk.nashorn.internal.ir.BlockStatement;
 import jdk.nashorn.internal.ir.BreakNode;
 import jdk.nashorn.internal.ir.CallNode;
 import jdk.nashorn.internal.ir.CaseNode;
 import jdk.nashorn.internal.ir.CatchNode;
 import jdk.nashorn.internal.ir.ContinueNode;
 import jdk.nashorn.internal.ir.EmptyNode;
 import jdk.nashorn.internal.ir.Expression;
 import jdk.nashorn.internal.ir.ExpressionStatement;
 import jdk.nashorn.internal.ir.ForNode;
 import jdk.nashorn.internal.ir.FunctionNode;
 import jdk.nashorn.internal.ir.IdentNode;
 import jdk.nashorn.internal.ir.IfNode;
 import jdk.nashorn.internal.ir.IndexNode;
 import jdk.nashorn.internal.ir.JoinPredecessorExpression;
 import jdk.nashorn.internal.ir.LabelNode;
 import jdk.nashorn.internal.ir.LiteralNode;
 import jdk.nashorn.internal.ir.Node;
 import jdk.nashorn.internal.ir.ObjectNode;
 import jdk.nashorn.internal.ir.PropertyNode;
 import jdk.nashorn.internal.ir.ReturnNode;
 import jdk.nashorn.internal.ir.RuntimeNode;
 import jdk.nashorn.internal.ir.SplitNode;
 import jdk.nashorn.internal.ir.Statement;
 import jdk.nashorn.internal.ir.SwitchNode;
 import jdk.nashorn.internal.ir.TernaryNode;
 import jdk.nashorn.internal.ir.ThrowNode;
 import jdk.nashorn.internal.ir.TryNode;
 import jdk.nashorn.internal.ir.UnaryNode;
 import jdk.nashorn.internal.ir.VarNode;
 import jdk.nashorn.internal.ir.WhileNode;
 import jdk.nashorn.internal.ir.WithNode;
 import jdk.nashorn.internal.ir.visitor.SimpleNodeVisitor;
 import jdk.nashorn.internal.parser.JSONParser;
 import jdk.nashorn.internal.parser.Lexer.RegexToken;
 import jdk.nashorn.internal.parser.Parser;
 import jdk.nashorn.internal.parser.TokenType;
 import jdk.nashorn.internal.runtime.Context;
 import jdk.nashorn.internal.runtime.ParserException;
 import jdk.nashorn.internal.runtime.Source;
 /**
  * This IR writer produces a JSON string that represents AST as a JSON string.
  */
 public final class JSONWriter extends SimpleNodeVisitor {
     /**
      * Returns AST as JSON compatible string.
      *
      * @param context context
      * @param code code to be parsed
      * @param name name of the code source (used for location)
      * @param includeLoc tells whether to include location information for nodes or not
      * @return JSON string representation of AST of the supplied code
      */
     public static String parse(final Context context, final String code, final String name, final boolean includeLoc) {
         final Parser       parser     = new Parser(context.getEnv(), sourceFor(name, code), new Context.ThrowErrorManager(), context.getEnv()._strict, context.getLogger(Parser.class));
         final JSONWriter   jsonWriter = new JSONWriter(includeLoc);
         try {
             final FunctionNode functionNode = parser.parse(); //symbol name is ":program", default
             functionNode.accept(jsonWriter);
             return jsonWriter.getString();
         } catch (final ParserException e) {
             e.throwAsEcmaException();
             return null;
         }
     }
     @Override
     public boolean enterJoinPredecessorExpression(final JoinPredecessorExpression joinPredecessorExpression) {
         final Expression expr = joinPredecessorExpression.getExpression();
         if(expr != null) {
             expr.accept(this);
         } else {
             nullValue();
         }
         return false;
     }
     @Override
     protected boolean enterDefault(final Node node) {
         objectStart();
         location(node);
         return true;
     }
     private boolean leave() {
         objectEnd();
         return false;
     }
     @Override
     protected Node leaveDefault(final Node node) {
         objectEnd();
         return null;
     }
     @Override
     public boolean enterAccessNode(final AccessNode accessNode) {
         enterDefault(accessNode);
         type("MemberExpression");
         comma();
         property("object");
         accessNode.getBase().accept(this);
         comma();
         property("property", accessNode.getProperty());
         comma();
         property("computed", false);
         return leave();
     }
     @Override
     public boolean enterBlock(final Block block) {
         enterDefault(block);
         type("BlockStatement");
         comma();
         array("body", block.getStatements());
         return leave();
     }
     @Override
     public boolean enterBinaryNode(final BinaryNode binaryNode) {
         enterDefault(binaryNode);
         final String name;
         if (binaryNode.isAssignment()) {
             name = "AssignmentExpression";
         } else if (binaryNode.isLogical()) {
             name = "LogicalExpression";
         } else {
             name = "BinaryExpression";
         }
         type(name);
         comma();
         property("operator", binaryNode.tokenType().getName());
         comma();
         property("left");
         binaryNode.lhs().accept(this);
         comma();
         property("right");
         binaryNode.rhs().accept(this);
         return leave();
     }
     @Override
     public boolean enterBreakNode(final BreakNode breakNode) {
         enterDefault(breakNode);
         type("BreakStatement");
         comma();
         final String label = breakNode.getLabelName();
         if(label != null) {
             property("label", label);
         } else {
             property("label");
             nullValue();
         }
         return leave();
     }
     @Override
     public boolean enterCallNode(final CallNode callNode) {
         enterDefault(callNode);
         type("CallExpression");
         comma();
         property("callee");
         callNode.getFunction().accept(this);
         comma();
         array("arguments", callNode.getArgs());
         return leave();
     }
     @Override
     public boolean enterCaseNode(final CaseNode caseNode) {
         enterDefault(caseNode);
         type("SwitchCase");
         comma();
         final Node test = caseNode.getTest();
         property("test");
         if (test != null) {
             test.accept(this);
         } else {
             nullValue();
         }
         comma();
         array("consequent", caseNode.getBody().getStatements());
         return leave();
     }
     @Override
     public boolean enterCatchNode(final CatchNode catchNode) {
         enterDefault(catchNode);
         type("CatchClause");
         comma();
         property("param");
         catchNode.getException().accept(this);
         comma();
         final Node guard = catchNode.getExceptionCondition();
         if (guard != null) {
             property("guard");
             guard.accept(this);
             comma();
         }
         property("body");
         catchNode.getBody().accept(this);
         return leave();
     }
     @Override
     public boolean enterContinueNode(final ContinueNode continueNode) {
         enterDefault(continueNode);
         type("ContinueStatement");
         comma();
         final String label = continueNode.getLabelName();
         if(label != null) {
             property("label", label);
         } else {
             property("label");
             nullValue();
         }
         return leave();
     }
     @Override
     public boolean enterEmptyNode(final EmptyNode emptyNode) {
         enterDefault(emptyNode);
         type("EmptyStatement");
         return leave();
     }
     @Override
     public boolean enterExpressionStatement(final ExpressionStatement expressionStatement) {
         // handle debugger statement
         final Node expression = expressionStatement.getExpression();
         if (expression instanceof RuntimeNode) {
             expression.accept(this);
             return false;
         }
         enterDefault(expressionStatement);
         type("ExpressionStatement");
         comma();
         property("expression");
         expression.accept(this);
         return leave();
     }
     @Override
     public boolean enterBlockStatement(final BlockStatement blockStatement) {
         enterDefault(blockStatement);
         type("BlockStatement");
         comma();
         property("block");
         blockStatement.getBlock().accept(this);
         return leave();
     }
     @Override
     public boolean enterForNode(final ForNode forNode) {
         enterDefault(forNode);
         if (forNode.isForIn() || (forNode.isForEach() && forNode.getInit() != null)) {
             type("ForInStatement");
             comma();
             final Node init = forNode.getInit();
             assert init != null;
             property("left");
             init.accept(this);
             comma();
             final Node modify = forNode.getModify();
             assert modify != null;
             property("right");
             modify.accept(this);
             comma();
             property("body");
             forNode.getBody().accept(this);
             comma();
             property("each", forNode.isForEach());
         } else {
             type("ForStatement");
             comma();
             final Node init = forNode.getInit();
             property("init");
             if (init != null) {
                 init.accept(this);
             } else {
                 nullValue();
             }
             comma();
             final Node test = forNode.getTest();
             property("test");
             if (test != null) {
                 test.accept(this);
             } else {
                 nullValue();
             }
             comma();
             final Node update = forNode.getModify();
             property("update");
             if (update != null) {
                 update.accept(this);
             } else {
                 nullValue();
             }
             comma();
             property("body");
             forNode.getBody().accept(this);
         }
         return leave();
     }
     @Override
     public boolean enterFunctionNode(final FunctionNode functionNode) {
         final boolean program = functionNode.isProgram();
         if (program) {
             return emitProgram(functionNode);
         }
         enterDefault(functionNode);
         final String name;
         if (functionNode.isDeclared()) {
             name = "FunctionDeclaration";
         } else {
             name = "FunctionExpression";
         }
         type(name);
         comma();
         property("id");
         final FunctionNode.Kind kind = functionNode.getKind();
         if (functionNode.isAnonymous() || kind == FunctionNode.Kind.GETTER || kind == FunctionNode.Kind.SETTER) {
             nullValue();
         } else {
             functionNode.getIdent().accept(this);
         }
         comma();
         array("params", functionNode.getParameters());
         comma();
         arrayStart("defaults");
         arrayEnd();
         comma();
         property("rest");
         nullValue();
         comma();
         property("body");
         functionNode.getBody().accept(this);
         comma();
         property("generator", false);
         comma();
         property("expression", false);
         return leave();
     }
     private boolean emitProgram(final FunctionNode functionNode) {
         enterDefault(functionNode);
         type("Program");
         comma();
         // body consists of nested functions and statements
         final List<Statement> stats = functionNode.getBody().getStatements();
         final int size = stats.size();
         int idx = 0;
         arrayStart("body");
         for (final Node stat : stats) {
             stat.accept(this);
             if (idx != (size - 1)) {
                 comma();
             }
             idx++;
         }
         arrayEnd();
         return leave();
     }
     @Override
     public boolean enterIdentNode(final IdentNode identNode) {
         enterDefault(identNode);
         final String name = identNode.getName();
         if ("this".equals(name)) {
             type("ThisExpression");
         } else {
             type("Identifier");
             comma();
             property("name", identNode.getName());
         }
         return leave();
     }
     @Override
     public boolean enterIfNode(final IfNode ifNode) {
         enterDefault(ifNode);
         type("IfStatement");
         comma();
         property("test");
         ifNode.getTest().accept(this);
         comma();
         property("consequent");
         ifNode.getPass().accept(this);
         final Node elsePart = ifNode.getFail();
         comma();
         property("alternate");
         if (elsePart != null) {
             elsePart.accept(this);
         } else {
             nullValue();
         }
         return leave();
     }
     @Override
     public boolean enterIndexNode(final IndexNode indexNode) {
         enterDefault(indexNode);
         type("MemberExpression");
         comma();
         property("object");
         indexNode.getBase().accept(this);
         comma();
         property("property");
         indexNode.getIndex().accept(this);
         comma();
         property("computed", true);
         return leave();
     }
     @Override
     public boolean enterLabelNode(final LabelNode labelNode) {
         enterDefault(labelNode);
         type("LabeledStatement");
         comma();
         property("label", labelNode.getLabelName());
         comma();
         property("body");
         labelNode.getBody().accept(this);
         return leave();
     }
     @SuppressWarnings("rawtypes")
     @Override
     public boolean enterLiteralNode(final LiteralNode literalNode) {
         enterDefault(literalNode);
         if (literalNode instanceof LiteralNode.ArrayLiteralNode) {
             type("ArrayExpression");
             comma();
             array("elements", ((LiteralNode.ArrayLiteralNode)literalNode).getElementExpressions());
         } else {
             type("Literal");
             comma();
             property("value");
             final Object value = literalNode.getValue();
             if (value instanceof RegexToken) {
                 // encode RegExp literals as Strings of the form /.../<flags>
                 final RegexToken regex = (RegexToken)value;
                 final StringBuilder regexBuf = new StringBuilder();
                 regexBuf.append('/');
                 regexBuf.append(regex.getExpression());
                 regexBuf.append('/');
                 regexBuf.append(regex.getOptions());
                 buf.append(quote(regexBuf.toString()));
             } else {
                 final String str = literalNode.getString();
                 // encode every String literal with prefix '$' so that script
                 // can differentiate b/w RegExps as Strings and Strings.
                 buf.append(literalNode.isString()? quote("$" + str) : str);
             }
         }
         return leave();
     }
     @Override
     public boolean enterObjectNode(final ObjectNode objectNode) {
         enterDefault(objectNode);
         type("ObjectExpression");
         comma();
         array("properties", objectNode.getElements());
         return leave();
     }
     @Override
     public boolean enterPropertyNode(final PropertyNode propertyNode) {
         final Node key = propertyNode.getKey();
         final Node value = propertyNode.getValue();
         if (value != null) {
             objectStart();
             location(propertyNode);
             property("key");
             key.accept(this);
             comma();
             property("value");
             value.accept(this);
             comma();
             property("kind", "init");
             objectEnd();
         } else {
             // getter
             final Node getter = propertyNode.getGetter();
             if (getter != null) {
                 objectStart();
                 location(propertyNode);
                 property("key");
                 key.accept(this);
                 comma();
                 property("value");
                 getter.accept(this);
                 comma();
                 property("kind", "get");
                 objectEnd();
             }
             // setter
             final Node setter = propertyNode.getSetter();
             if (setter != null) {
                 if (getter != null) {
                     comma();
                 }
                 objectStart();
                 location(propertyNode);
                 property("key");
                 key.accept(this);
                 comma();
                 property("value");
                 setter.accept(this);
                 comma();
                 property("kind", "set");
                 objectEnd();
             }
         }
         return false;
     }
     @Override
     public boolean enterReturnNode(final ReturnNode returnNode) {
         enterDefault(returnNode);
         type("ReturnStatement");
         comma();
         final Node arg = returnNode.getExpression();
         property("argument");
         if (arg != null) {
             arg.accept(this);
         } else {
             nullValue();
         }
         return leave();
     }
     @Override
     public boolean enterRuntimeNode(final RuntimeNode runtimeNode) {
         final RuntimeNode.Request req = runtimeNode.getRequest();
         if (req == RuntimeNode.Request.DEBUGGER) {
             enterDefault(runtimeNode);
             type("DebuggerStatement");
             return leave();
         }
         return false;
     }
     @Override
     public boolean enterSplitNode(final SplitNode splitNode) {
         return false;
     }
     @Override
     public boolean enterSwitchNode(final SwitchNode switchNode) {
         enterDefault(switchNode);
         type("SwitchStatement");
         comma();
         property("discriminant");
         switchNode.getExpression().accept(this);
         comma();
         array("cases", switchNode.getCases());
         return leave();
     }
     @Override
     public boolean enterTernaryNode(final TernaryNode ternaryNode) {
         enterDefault(ternaryNode);
         type("ConditionalExpression");
         comma();
         property("test");
         ternaryNode.getTest().accept(this);
         comma();
         property("consequent");
         ternaryNode.getTrueExpression().accept(this);
         comma();
         property("alternate");
         ternaryNode.getFalseExpression().accept(this);
         return leave();
     }
     @Override
     public boolean enterThrowNode(final ThrowNode throwNode) {
         enterDefault(throwNode);
         type("ThrowStatement");
         comma();
         property("argument");
         throwNode.getExpression().accept(this);
         return leave();
     }
     @Override
     public boolean enterTryNode(final TryNode tryNode) {
         enterDefault(tryNode);
         type("TryStatement");
         comma();
         property("block");
         tryNode.getBody().accept(this);
         comma();
         final List<? extends Node> catches = tryNode.getCatches();
         final List<CatchNode> guarded = new ArrayList<>();
         CatchNode unguarded = null;
         if (catches != null) {
             for (final Node n : catches) {
                 final CatchNode cn = (CatchNode)n;
                 if (cn.getExceptionCondition() != null) {
                     guarded.add(cn);
                 } else {
                     assert unguarded == null: "too many unguarded?";
                     unguarded = cn;
                 }
             }
         }
         array("guardedHandlers", guarded);
         comma();
         property("handler");
         if (unguarded != null) {
             unguarded.accept(this);
         } else {
             nullValue();
         }
         comma();
         property("finalizer");
         final Node finallyNode = tryNode.getFinallyBody();
         if (finallyNode != null) {
             finallyNode.accept(this);
         } else {
             nullValue();
         }
         return leave();
     }
     @Override
     public boolean enterUnaryNode(final UnaryNode unaryNode) {
         enterDefault(unaryNode);
         final TokenType tokenType = unaryNode.tokenType();
         if (tokenType == TokenType.NEW) {
             type("NewExpression");
             comma();
             final CallNode callNode = (CallNode)unaryNode.getExpression();
             property("callee");
             callNode.getFunction().accept(this);
             comma();
             array("arguments", callNode.getArgs());
         } else {
             final String operator;
             final boolean prefix;
             switch (tokenType) {
             case INCPOSTFIX:
                 prefix = false;
                 operator = "++";
                 break;
             case DECPOSTFIX:
                 prefix = false;
                 operator = "--";
                 break;
             case INCPREFIX:
                 operator = "++";
                 prefix = true;
                 break;
             case DECPREFIX:
                 operator = "--";
                 prefix = true;
                 break;
             default:
                 prefix = true;
                 operator = tokenType.getName();
                 break;
             }
             type(unaryNode.isAssignment()? "UpdateExpression" : "UnaryExpression");
             comma();
             property("operator", operator);
             comma();
             property("prefix", prefix);
             comma();
             property("argument");
             unaryNode.getExpression().accept(this);
         }
         return leave();
     }
     @Override
     public boolean enterVarNode(final VarNode varNode) {
         final Node init = varNode.getInit();
         if (init instanceof FunctionNode && ((FunctionNode)init).isDeclared()) {
             // function declaration - don't emit VariableDeclaration instead
             // just emit FunctionDeclaration using 'init' Node.
             init.accept(this);
             return false;
         }
         enterDefault(varNode);
         type("VariableDeclaration");
         comma();
         arrayStart("declarations");
         // VariableDeclarator
         objectStart();
         location(varNode.getName());
         type("VariableDeclarator");
         comma();
         property("id");
         varNode.getName().accept(this);
         comma();
         property("init");
         if (init != null) {
             init.accept(this);
         } else {
             nullValue();
         }
         // VariableDeclarator
         objectEnd();
         // declarations
         arrayEnd();
         return leave();
     }
     @Override
     public boolean enterWhileNode(final WhileNode whileNode) {
         enterDefault(whileNode);
         type(whileNode.isDoWhile() ? "DoWhileStatement" : "WhileStatement");
         comma();
         if (whileNode.isDoWhile()) {
             property("body");
             whileNode.getBody().accept(this);
             comma();
             property("test");
             whileNode.getTest().accept(this);
         } else {
             property("test");
             whileNode.getTest().accept(this);
             comma();
             property("body");
             whileNode.getBody().accept(this);
         }
         return leave();
     }
     @Override
     public boolean enterWithNode(final WithNode withNode) {
         enterDefault(withNode);
         type("WithStatement");
         comma();
         property("object");
         withNode.getExpression().accept(this);
         comma();
         property("body");
         withNode.getBody().accept(this);
         return leave();
    }
     // Internals below
     private JSONWriter(final boolean includeLocation) {
         this.buf             = new StringBuilder();
         this.includeLocation = includeLocation;
     }
     private final StringBuilder buf;
     private final boolean includeLocation;
     private String getString() {
         return buf.toString();
     }
     private void property(final String key, final String value, final boolean escape) {
         buf.append('"');
         buf.append(key);
         buf.append("\":");
         if (value != null) {
             if (escape) {
                 buf.append('"');
             }
             buf.append(value);
             if (escape) {
                 buf.append('"');
             }
         }
     }
     private void property(final String key, final String value) {
         property(key, value, true);
     }
     private void property(final String key, final boolean value) {
         property(key, Boolean.toString(value), false);
     }
     private void property(final String key, final int value) {
         property(key, Integer.toString(value), false);
     }
     private void property(final String key) {
         property(key, null);
     }
     private void type(final String value) {
         property("type", value);
     }
     private void objectStart(final String name) {
         buf.append('"');
         buf.append(name);
         buf.append("\":{");
     }
     private void objectStart() {
         buf.append('{');
     }
     private void objectEnd() {
         buf.append('}');
     }
     private void array(final String name, final List<? extends Node> nodes) {
         // The size, idx comparison is just to avoid trailing comma..
         final int size = nodes.size();
         int idx = 0;
         arrayStart(name);
         for (final Node node : nodes) {
             if (node != null) {
                 node.accept(this);
             } else {
                 nullValue();
             }
             if (idx != (size - 1)) {
                 comma();
             }
             idx++;
         }
         arrayEnd();
     }
     private void arrayStart(final String name) {
         buf.append('"');
         buf.append(name);
         buf.append('"');
         buf.append(':');
         buf.append('[');
     }
     private void arrayEnd() {
         buf.append(']');
     }
     private void comma() {
         buf.append(',');
     }
     private void nullValue() {
         buf.append("null");
     }
     private void location(final Node node) {
         if (includeLocation) {
             objectStart("loc");
             // source name
             final Source src = lc.getCurrentFunction().getSource();
             property("source", src.getName());
             comma();
             // start position
             objectStart("start");
             final int start = node.getStart();
             property("line", src.getLine(start));
             comma();
             property("column", src.getColumn(start));
             objectEnd();
             comma();
             // end position
             objectStart("end");
             final int end = node.getFinish();
             property("line", src.getLine(end));
             comma();
             property("column", src.getColumn(end));
             objectEnd();
             // end 'loc'
             objectEnd();
             comma();
         }
     }
     private static String quote(final String str) {
         return JSONParser.quote(str);
     }
 }

Mercurial > jdk8-mips64-public > nashorn / annotate

src/jdk/nashorn/internal/ir/debug/JSONWriter.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/ir/debug/JSONWriter.java