解读uglifyJS(转载：http://rapheal.sinaapp.com/2014/05/15/uglifyjs-ast-parse/)

最新推荐文章于 2024-06-11 17:04:59 发布
csj_9_9
最新推荐文章于 2024-06-11 17:04:59 发布
阅读量1.2k
点赞数
javascript
//语法分析 by raphealguo
//得到一个AST树
//parse-js移植于一个Lisp的项目
//所以获得的AST树类似Lisp里边的表，数组套数组：["toplevel", ["stat", [xxxx]]]
 
//@param $TEXT 输入源代码
//@param exigent_mode 严格的模式，这个模式不自动插入分号解析 
//@param embed_tokens @unknowed
function parse($TEXT, exigent_mode, embed_tokens) {
    var S = {
    	//输入，可以自己构造一个token输入器传递进来 否则就用tokenizer返回的next_token作为输入器
        input         : typeof $TEXT == "string" ? tokenizer($TEXT, true) : $TEXT,
 
        //当前token
        token         : null,
 
        //上一个token
        prev          : null,
 
        //向前看一个token
        peeked        : null,
 
        //是不是在一个function里边
        in_function   : 0,
 
        //在函数里边标记"use strict"这种指示性字符串
        in_directives : true,
 
        //是不是在循环里边
        in_loop       : 0,
 
        //labels集合
        labels        : []
    };
 
    S.token = next();//先拿到第一个token
 
	/*
		function is_token(token, type, val) {
		    return token.type == type && (val == null || token.value == val);
		};
	*/
	//看看当前token的类型跟值对不对得上
    function is(type, value) {
        return is_token(S.token, type, value);
    };
 
    //获取当前token
    function peek() { return S.peeked || (S.peeked = S.input()); };
 
    //获取下一个token
    function next() {
        S.prev = S.token;//记录前一个token
        if (S.peeked) {//看看当前已经peek过没 有的话 直接拿它做next token就好了
            S.token = S.peeked;
            S.peeked = null;
        } else {//否则 S.input == tokenizer返回的next_token钩子
            S.token = S.input();
        }
 
        //"use strict";这样才算是指示性字符串
        S.in_directives = S.in_directives && (
            S.token.type == "string" || is("punc", ";")
        );
 
        //返回拿到的token
        return S.token;
    };
 
    //获取上一个token
    function prev() {
        return S.prev;
    };
 
    //辅助函数报错
    function croak(msg, line, col, pos) {
        var ctx = S.input.context();
        js_error(msg,
                 line != null ? line : ctx.tokline,
                 col != null ? col : ctx.tokcol,
                 pos != null ? pos : ctx.tokpos);
    };
 
    function token_error(token, msg) {
        croak(msg, token.line, token.col);
    };
 
    function unexpected(token) {
        if (token == null)
            token = S.token;
        token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")");
    };
 
    //看看当前token是不是符合当前状态，是的话拿出下一个token
    function expect_token(type, val) {
        if (is(type, val)) {
            return next();
        }
        token_error(S.token, "Unexpected token " + S.token.type + ", expected " + type);
    };
 
    function expect(punc) { return expect_token("punc", punc); };
 
    //能不能插入分号
    function can_insert_semicolon() {
    	//插入分号的条件是exigent_mode = false，严格模式：
    	//1. 当前token与上个token之间是否有换行
    	//2. 文件末尾
    	//3. }后边
        return !exigent_mode && (
            S.token.nlb || is("eof") || is("punc", "}")
        );
    };
 
    //状态：分号
    function semicolon() {
        if (is("punc", ";")) next();//如果当前token是分号 则继续
        else if (!can_insert_semicolon()) unexpected();//否则看看能否自动插入分号 否则报错
    };
 
    //前边说的 最后返回的ast树就是数组套数组
    function as() {
        return slice(arguments);
    };
 
    //状态：括号表达式
    function parenthesised() {
        expect("(");
        var ex = expression();
        expect(")");
        return ex;
    };
 
    //@unknowed
    function add_tokens(str, start, end) {
        return str instanceof NodeWithToken ? str : new NodeWithToken(str, start, end);
    };
 
    //辅助函数 返回一个解析当前语法子AST树的钩子
    function maybe_embed_tokens(parser) {
    	//一般embed_tokens是false 
    	//@unknowed
        if (embed_tokens) return function() {
            var start = S.token;
            var ast = parser.apply(this, arguments);
            ast[0] = add_tokens(ast[0], start, prev());
            return ast;
        };
        else return parser;
    };
 
    //状态：语句块
    //这个状态略微复杂
    var statement = maybe_embed_tokens(function() {
        if (is("operator", "/") || is("operator", "/=")) {
        	//强制进入正则表达式解析
        	//语句的开头如果遇到/ 或者/=的时候
        	//不进入正则表达式的状态 会有语法错误
        	//而且显然此时应该是一个正则表达式的状态
            S.peeked = null;
            S.token = S.input(S.token.value.substr(1)); // force regexp
        }
 
        switch (S.token.type) {
          case "string":
            var dir = S.in_directives, stat = simple_statement();
 
            //in_directives = true 表达了在function(){}的body里边
            //此时遇到第一个字符串  看看是不是 "use strict"这样指示性的字符串
            if (dir && stat[1][0] == "string" && !is("punc", ","))
                return as("directive", stat[1][1]);
            return stat;
 
          //简单的表达式
          case "num":
          case "regexp":
          case "operator":
          case "atom":
            return simple_statement();
 
          case "name":
          	//得到一个串，往后看一个token看看是不是: 是的话 认为是一个标签语句
            return is_token(peek(), "punc", ":")
            	//拿到当前的token.value就是标签名字，接着吃掉两个token：label跟冒号
            	//留意prog1的实现 会把所有参数都当做函数执行一次~
                ? labeled_statement(prog1(S.token.value, next, next))
 
                : simple_statement();
 
          //语句块的开头 符号只能是{[(;
          //其他符号都是非法
          case "punc":
            switch (S.token.value) {
              case "{":
                return as("block", block_());
              case "[":
              case "(":
                return simple_statement();
              case ";":
                next();
                return as("block");
              default:
                unexpected();
            }
 
          //轮到关键字
          case "keyword":
            switch (prog1(S.token.value, next)) {
              case "break":
                return break_cont("break");
 
              case "continue":
                return break_cont("continue");
 
              case "debugger":
                semicolon();
                return as("debugger");
 
              case "do":
                return (function(body){
                	//do{ body }while(parenthesised);
                    expect_token("keyword", "while");
                    return as("do", prog1(parenthesised, semicolon), body);
                })(in_loop(statement));
 
              case "for":
                return for_();
 
              case "function":
                return function_(true);
 
              case "if":
                return if_();
 
              case "return":
                if (S.in_function == 0)//不在函数里边不能return
                    croak("'return' outside of function");
                return as("return",
                          is("punc", ";")
                          ? (next(), null)
                          : can_insert_semicolon()
                          ? null
                          : prog1(expression, semicolon));
 
              case "switch":
                return as("switch", parenthesised(), switch_block_());
 
              case "throw":
                if (S.token.nlb)
                    croak("Illegal newline after 'throw'");
                return as("throw", prog1(expression, semicolon));
 
              case "try":
                return try_();
 
              case "var":
                return prog1(var_, semicolon);
 
              case "const":
                return prog1(const_, semicolon);
 
              case "while":
                return as("while", parenthesised(), in_loop(statement));
 
              case "with":
                return as("with", parenthesised(), statement());
 
              default:
                unexpected();
            }
        }
    });
 
	//状态：标签
	//例如 begin: var a = 1;
    function labeled_statement(label) {
    	//深度搜索push
        S.labels.push(label);
        var start = S.token, stat = statement();
 
		//var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
		//在严格模式下 除了for do while switch外，其他语句不许使用label
        if (exigent_mode && !HOP(STATEMENTS_WITH_LABELS, stat[0]))
            unexpected(start);
 
    	//深度搜索pop
        S.labels.pop();
 
        //得到label树枝
        return as("label", label, stat);
    };
 
    //状态：简单语句
    //简单语句 == 表达式+分号
    //返回是表达式的值
    function simple_statement() {
        return as("stat", prog1(expression, semicolon));
    };
 
    //状态：break
    //@param type "continue"/"break"
    function break_cont(type) {
        var name;
        if (!can_insert_semicolon()) {//如果当前不能插入分号 那得看看后边是不是跟一个label了
            name = is("name") ? S.token.value : null;
        }
        if (name != null) {
            next();//吃掉一个token
            if (!member(name, S.labels))//如果当前label不在当前作用域嵌套的labels里边 报错
                croak("Label " + name + " without matching loop or statement");
        }
        else if (S.in_loop == 0)//不在循环中肯定不能用break跟continue~
            croak(type + " not inside a loop or switch");
 
        //break continue后边带分号
        semicolon();
        return as(type, name);
    };
 
    //状态：for
    function for_() {
    	//留意当前状态已经吃掉一个for了，所以for之后应该期待一个左括号
        expect("(");
        var init = null;
        //for(initStat; expr; expr)
        if (!is("punc", ";")) {//如果遇到有initStat的话
        	//拿到初始化表达式
            init = is("keyword", "var")
                ? (next(), var_(true))
                : expression(true, true);
 
            //如果下一个token是in的话
            if (is("operator", "in")) {
            	//语法是不允许：for(var i,j in arr)的
                if (init[0] == "var" && init[1].length > 1)
                    croak("Only one variable declaration allowed in for..in loop");
 
                //进入for in的状态
                return for_in(init);
            }
        }
        return regular_for(init);
    };
 
    //状态：for后边的语法
    function regular_for(init) {
    	//下边映射了左括号之后的状态：for(init; test; step)
 
    	//已经处理过初始化表达式了
        expect(";");
        var test = is("punc", ";") ? null : expression();
        expect(";");
        var step = is("punc", ")") ? null : expression();
 
        //for最后的括号
        expect(")");
 
        //init代表这个for的初始化表达式
        //test表示for的判断表达式
        //step表示下一步的表达式
        //for的主体 in_loop里边还记录了当前嵌套循环的深度
        return as("for", init, test, step, in_loop(statement));
    };
 
    //状态：for in
    function for_in(init) {
    	//下边映射： for (init in obj)
        var lhs = init[0] == "var" ? as("name", init[1][0]) : init;
        next();//吃掉in
        var obj = expression();
        expect(")");
 
        //for in的AST树枝
        return as("for-in", init, lhs, obj, in_loop(statement));
    };
 
    //状态：函数
    var function_ = function(in_statement) {
    	//如有name说明不是匿名函数
        var name = is("name") ? prog1(S.token.value, next) : null;
 
        //function没有作为表达式的时候 不允许匿名！
        if (in_statement && !name)
            unexpected();
        expect("(");
 
        //表达式函数：function
        //明确function声明定义，没有赋值给变量的函数：defun
        /*
        	以下两种属于function：
        		(function a(){})();
				v = function (){};
			以下两种属于defun：
				function d(){}
				c = function d(){};
        */
        return as(in_statement ? "defun" : "function",
                  name,//函数名
 
                  // arguments
                  //函数参数
                  (function(first, a){
                  	  //只要没遇到右括号 就一直扫描
                      while (!is("punc", ")")) {
                      	  //第一个参数前边不用找都好
                          if (first) first = false; else expect(",");
 
                          //必须是变量名
                          if (!is("name")) unexpected();
                          a.push(S.token.value);//加入参数列表数组
                          next();
                      }
                      next();//吃掉右括号
                      return a;//得到参数列表
                  })(true, []),
 
                  // body
                  //函数体
                  (function(){
                  	  //嵌套的函数层+1
                      ++S.in_function;
 
                      var loop = S.in_loop;
 
                      //进入函体，标记in_directives，为了认"use strict"这种指示性字符串
                      S.in_directives = true;
 
                      //函数在循环中的嵌套层数为0！？@unknowed
                      S.in_loop = 0;
 
                      //拿到函数体AST树枝
                      var a = block_();
 
                      //恢复状态
                      --S.in_function;
                      S.in_loop = loop;
                      return a;
                  })());
    };
 
    //状态：if
    function if_() {
    	//if (cond)
        var cond = parenthesised(), body = statement(), belse;
 
        /*
			如果是带else if的
			if (cond) {
 
			}else if(cond2){
 
			}else{
 
			}
			其实可以解析成
			if (cond){
 
			}else{
				//下边这个块可以作为当前else的statement
				if (cond){
 
				}else{
 
				}
			}
         */
        //如果有else
        if (is("keyword", "else")) {
            next();
            belse = statement();
        }
        return as("if", cond, body, belse);
    };
 
    //状态：块
    function block_() {
    	// { block }
        expect("{");
        var a = [];
 
        //块里边都是语句
        while (!is("punc", "}")) {
            if (is("eof")) unexpected();
            a.push(statement());
        }
        next();//吃掉}这个token
        return a;
    };
 
    //状态：switch块
 
    //执行in_loop 记录嵌套深度
    var switch_block_ = curry(in_loop, function(){
        expect("{");
        var a = [], cur = null;
        while (!is("punc", "}")) {
            if (is("eof")) unexpected();
            //以下两种状态：
            //case expression : statement
            //default : statement
 
            if (is("keyword", "case")) {
                next();
                cur = [];
                a.push([ expression(), cur ]);
                expect(":");
            }
            else if (is("keyword", "default")) {
                next();
                expect(":");
                cur = [];
                a.push([ null, cur ]);
            }
            else {
                if (!cur) unexpected();//都没有解析过case跟default 肯定是不对的
                cur.push(statement());
            }
        }
        next();
        //得到一个列表：
        //[ ["case1", [stat1, stat2]], ["case2", [stat1, stat2]], [null, [stat1, stat2]] ]
        return a;
    });
 
    //状态：try
    function try_() {
    	// try {body} catch(name) { bcatch} finally { bfinally }
        var body = block_(), bcatch, bfinally;
        if (is("keyword", "catch")) {
            next();
            expect("(");
            if (!is("name"))
                croak("Name expected");
            var name = S.token.value;
            next();
            expect(")");
            bcatch = [ name, block_() ];
        }
        if (is("keyword", "finally")) {
            next();
            bfinally = block_();
        }
        if (!bcatch && !bfinally)//catch跟finally至少要有一个！
            croak("Missing catch/finally blocks");
        return as("try", body, bcatch, bfinally);
    };
 
    //状态：var声明list
    //@param no_in 不在for in里边
    function vardefs(no_in) {
    	//var a, b, c = 2, d = 1;
    	//这里的状态对应是：a, b, c = 2, d = 1;
        var a = [];
        for (;;) {
            if (!is("name"))
                unexpected();//一定要有变量名
            var name = S.token.value;
            next();
            if (is("operator", "=")) {//如果有=
                next();
                //拿到表达式的值
                a.push([ name, expression(false, no_in) ]);
            } else {
            	//否则变量没有初始化值
                a.push([ name ]);
            }
            //下一个必须是逗号 否则就结束这个var列表定义了
            if (!is("punc", ","))
                break;
            next();
        }
        return a;
    };
 
    //状态：var 
    //var a,b;
    function var_(no_in) {
        return as("var", vardefs(no_in));
    };
 
    //状态：const 
    //const a,b;
    function const_() {
        return as("const", vardefs());
    };
 
    //状态：new 
    //映射成：new newexp(args)
    function new_() {
        var newexp = expr_atom(false), args;
        if (is("punc", "(")) {
            next();
            args = expr_list(")");
        } else {
            args = [];
        }
        return subscripts(as("new", newexp, args), true);
    };
 
    //状态：元表达式 后边可能带下标
    //映射成： new A()  a.b | a["b"] | a.c() | {a:1} | function x(); | /asd/gi.test("xx") | 
    var expr_atom = maybe_embed_tokens(function(allow_calls) {
    	//可以嵌套new
    	//var a = new new A();
        if (is("operator", "new")) {
            next();
            return new_();
        }
        if (is("punc")) {
            switch (S.token.value) {
              //为什么以下都要加subscripts修饰呢
              //因为：[1,2,3][0]   {a:1}.a  ({a:1}).a 后边还需要解析属性！
              case "(":
                next();
                //得到一个括号表达式
                return subscripts(prog1(expression, curry(expect, ")")), allow_calls);
              case "[":
                next();
                //得到一个数组
                return subscripts(array_(), allow_calls);
              case "{":
                next();
                //得到一个对象
                return subscripts(object_(), allow_calls);
            }
            unexpected();//除了([{都出错
        }
        if (is("keyword", "function")) {//匿名函数构造器
            next();
            return subscripts(function_(false), allow_calls);
        }
        if (HOP(ATOMIC_START_TOKEN, S.token.type)) {
            var atom = S.token.type == "regexp"
            	//regexp=/abc/gi 带有两个属性：abc以及gi
                ? as("regexp", S.token.value[0], S.token.value[1])
                : as(S.token.type, S.token.value);
            return subscripts(prog1(atom, next), allow_calls);
        }
        unexpected();
    });
 
	//状态：逗号表达式
	//映射成：a,b,c
	//@param closing 结束token标记
	//@parame allow_trailing_comma 是否允许最末尾加逗号  例如[a,b,c,]
	//@param allow_empty 是否允许空值 例如[a,,v]
    function expr_list(closing, allow_trailing_comma, allow_empty) {
        var first = true, a = [];
        //直到遇到token是closing为止
        while (!is("punc", closing)) {
        	//如果不是第一个 就必须有逗号
            if (first) first = false; else expect(",");
 
            //允许末尾加逗号
            if (allow_trailing_comma && is("punc", closing)) break;
            if (is("punc", ",") && allow_empty) {
                a.push([ "atom", "undefined" ]);
            } else {
                a.push(expression(false));
            }
        }
        next();
        return a;
    };
 
    //状态：数组
    function array_() {
    	//结束必须是]符号
    	//严格模式exigent_mode下不允许最后还有逗号 例如[1,2,3,]
    	//允许空值 例如 [1,,2] == [1, undefined, 2]
        return as("array", expr_list("]", !exigent_mode, true));
    };
 
    //状态：对象
    function object_() {
    	//映射为： { "a" : c, b : 1 }
        var first = true, a = [];
        while (!is("punc", "}")) {//遇到}才结束
        	//如果不是第一个 就必须有逗号
            if (first) first = false; else expect(",");
 
            //允许末尾加逗号
            if (!exigent_mode && is("punc", "}"))
                // allow trailing comma
                break;
 
            var type = S.token.type;
 
            //拿到属性名字token
            var name = as_property_name();
 
            if (type == "name" && (name == "get" || name == "set") && !is("punc", ":")) {
            	//看看是不是get set方法
            	/*
            		get set的语法如下：
            		{
            			get as_name(){  
							return this.value;
            			}
            		}
            	 */
                a.push([ as_name(), function_(false), name ]);
            } else {
                expect(":");
                a.push([ name, expression(false) ]);
            }
        }
        next();
        return as("object", a);
    };
 
    //状态：拿到一个属性名字
    function as_property_name() {
        switch (S.token.type) {
          case "num":
          case "string":
            return prog1(S.token.value, next);
        }
        return as_name();
    };
 
    //状态：拿到一个名字
    function as_name() {
        switch (S.token.type) {
          case "name":
          case "operator"://为什么可以是operator呢？因为token解析出来的操作符是包含"in", "instanceof", "typeof", "new", "void", "delete"关键字的 这些也是可以作为一个名字
          case "keyword":
          case "atom":
            return prog1(S.token.value, next);
          default:
            unexpected();
        }
    };
 
    //状态：获取对象属性
    //分别对应下边的状态：
    //expr 
    //expr.as_name  
    //expr[expression] 
    //expr(expr_list)
    function subscripts(expr, allow_calls) {
        if (is("punc", ".")) {
            next();
            return subscripts(as("dot", expr, as_name()), allow_calls);
        }
        if (is("punc", "[")) {
            next();
            return subscripts(as("sub", expr, prog1(expression, curry(expect, "]"))), allow_calls);
        }
        if (allow_calls && is("punc", "(")) {
            next();
            return subscripts(as("call", expr, expr_list(")")), true);
        }
        return expr;
    };
 
    //状态：可能是一元操作符
    function maybe_unary(allow_calls) {
    	//看看是不是一元操作符
        if (is("operator") && HOP(UNARY_PREFIX, S.token.value)) {
            return make_unary("unary-prefix",
                              prog1(S.token.value, next),
                              maybe_unary(allow_calls));
        }
        var val = expr_atom(allow_calls);
        while (is("operator") && HOP(UNARY_POSTFIX, S.token.value) && !S.token.nlb) {
            val = make_unary("unary-postfix", S.token.value, val);
            next();
        }
        return val;
    };
 
    //状态：一元操作符
    function make_unary(tag, op, expr) {
        if ((op == "++" || op == "--") && !is_assignable(expr))
    		//看看是不是能赋值  例如：++this在严格模式下就不可取
            croak("Invalid use of " + op + " operator");
        return as(tag, op, expr);
    };
 
    //状态：二元操作符
    function expr_op(left, min_prec, no_in) {
        var op = is("operator") ? S.token.value : null;
 
        //要兼容for in的情况 在no_in的情况不要吃掉in这个token
        if (op && op == "in" && no_in) op = null;
 
        //PRECEDENCE 二元操作符一个列表 包含了优先级
        //prec为当前操作符的优先级
        var prec = op != null ? PRECEDENCE[op] : null;
        if (prec != null && prec > min_prec) {//大于当前的优先级 才能解析到当前的表达式
        	//expr = a+b/c;
        	//扫描到a 发现+ 接着向后看到了b 接着递归进去expr_op的时候 发现/优先级比+高 所以继续往后看token
            next();
            var right = expr_op(maybe_unary(true), prec, no_in);
            return expr_op(as("binary", op, left, right), min_prec, no_in);
        }
        //如果是 expr = a/b+c的情况 在递归扫描大b的时候就不会进来上边那个if 直接返回b
        return left;
    };
 
    //辅助函数 只有maybe_conditional用到 感觉应该废弃掉这个
    function expr_ops(no_in) {
        return expr_op(maybe_unary(true), 0, no_in);
    };
 
    //状态：操作数
    //看看是否有三元操作符?: 
    function maybe_conditional(no_in) {
    	//映射成：expr ? yes : no_expr
        var expr = expr_ops(no_in);
        if (is("operator", "?")) {
            next();
            var yes = expression(false);
            expect(":");
            return as("conditional", expr, yes, expression(false, no_in));
        }
        return expr;
    };
 
    //辅助函数 看看expr能否被赋值
    function is_assignable(expr) {
        if (!exigent_mode) return true;
        switch (expr[0]+"") {
          case "dot":
          case "sub":
          case "new":
          case "call":
            return true;
          case "name":
            return expr[1] != "this";
        }
    };
 
    //状态：赋值操作表达式
    function maybe_assign(no_in) {
    	//left = right
        var left = maybe_conditional(no_in), val = S.token.value;
        if (is("operator") && HOP(ASSIGNMENT, val)) {//如果有赋值操作符 例如= += -=
            if (is_assignable(left)) {
                next();
                //可以a=b=c=d=1
                return as("assign", ASSIGNMENT[val], left, maybe_assign(no_in));
            }
            croak("Invalid assignment");
        }
        return left;
    };
 
    //状态：表达式
    //为什么要commas
    //有种情况 a ? b : c,d 这里应该认为是(a ? b : c), d
    //所以在解析c,d的时候 不应该把c,d认为是一个表达式，这里commas应该是false
    var expression = maybe_embed_tokens(function(commas, no_in) {
        if (arguments.length == 0)
            commas = true;
 
        //拿一个表达式，可以是赋值语句
        //var a = 1, b = 2, c;
        //a=1匹配了这里的maybe_assign状态
        var expr = maybe_assign(no_in);
        //根据运算符优先级，看看要不要解析逗号
        if (commas && is("punc", ",")) {
            next();
            return as("seq", expr, expression(true, no_in));
        }
        return expr;
    });
 
    //记录嵌套循环
    function in_loop(cont) {
        try {
            ++S.in_loop;
            return cont();
        } finally {
            --S.in_loop;
        }
    };
 
    //得到一个顶级的AST树枝，然后从statement状态开始递归解析子树
    return as("toplevel", (function(a){
        while (!is("eof"))
            a.push(statement());
        return a;
    })([]));
}