写一个你自己的编程语言

写一个你自己的编程语言

do(define(x, 10),
	if(>(x, 5),
		print("large"),
		print("small")))

{
	type: "apply",
	operator: {type: "word", name: ">"},
	args: [
		{type: "word", name: "x"},
		{type: "value", value: 5}
	]
}

do(define(x, 10),
	if(>(x, 5),
		print("large"),
		print("small")))

do
 |--define
     |--x
     |--10
 |--if
     |-->
        |--x
        |--5
     |--print
        |--"large"
     |--print
        |--"small"

function parseExpression(program){
	program = skipSpace(program);
	var match, expr;
	if(match = /^"([^"]*)"/.exec(program)){
		//任何双引号中非双引号字符的都是string
		expr = {type: "value", value: match[1]};
	} else if(match = /^\d+\b/.exec(program)){
		//任何从头到尾都是数字的都是number
		expr = {type: "value", value: Number(match[0])};
	} else if(match = /^[^\s(),"]+/.exec(program)){
		//任何非空白、非括号、非逗号、非双引号的字符
		expr = {type: "word", name: match[0]};
	} else {
		throw new SyntaxError("Unexpected syntax: " + program);
	}

	return parseApply(expr, program.slice(match[0].length));
}

function skipSpace(string){
	var first = string.search(/\S/);
	if(first == -1) {
		return "";
	}
	return string.slice(first);
}

function parseApply(expr, program){
	program = skipSpace(program);
	if(program[0] != "("){
		//这说明不是一个expr不是一个application
		return {expr: expr, rest: program};
	}
	
	//如果expr是一个application，那么就将program开头的括号去掉，然后给expr重新赋值成application类型的表达式对象，原来传入的expr就成了新的表达式对象的operator属性
	program = skipSpace(program.slice(1));
	expr = {type: "apply", operator: expr, args: []};

	while(program[0] != ")"){
		var arg = parseExpression(program);
		expr.args.push(arg.expr);
		//arg为解析好的一个参数，然后解析好的参数与剩余的string就被传入parseApply里面来了。如果args后面不是左括号，则返回{expr: expr, rest: program}对象，这时候可以看到arg.rest就是解析完arg之后剩余的字符串
		program = skipSpace(arg.rest);
		//在参数括号里面，每解析完一个表达式，剩余的在去掉空白之后，都应该是逗号或右括号，否则就语法出错了。
		if(program[0] == ","){
			program = skipSpace(program.slice(1));
		} else if(program[0] != ")"){
			throw new SyntaxError("Expected ',' or ')'");
		}
	}
	return parseApply(expr, program.slice(1));
}

function parse(program){
	var result = parseExpression(program);
	if(skipSpace(result.rest).length > 0){
		throw new SyntaxError("Unexpected text after program");
	}
	return result.expr;
}

console.log(parse("+(a, 10)"));
//{
//	type: "apply",
//	operator: {type: "word", name: "+"},
//	args: [{type: "word", name: "a"},
//		{type: "value", value: 10}]
//}

function evaluate(expr, env){
	switch(expr.type){
		case "value":
			return expr.value;
		case "word":
			if(expr.name in env){
				return env[expr.name];
			} else {
				throw new ReferenceError("Undefined variable: " + expr.name);
			}
		case "apply":
			if(expr.operator.type == "word" && expr.operator.name in specialForms){
				//如果在specialForms中定义过了，那么就直接以expr.operator.name为函数名，将参数和环境变量传入执行，返回数值。
				return specialForms[expr.operator.name](expr.args, env);
			}
			
			//如果没有在specialForms中定义，那么就将expr.operator作为第一个参数，环境变量作为第二个参数传入evaluate，由于expr.operator的type应该是word，所以又走到了evaluate的case "word“这里，返回env[expr.name]给op。如果expr.name不在env中，就报Undefined variable的错。
			var op = evaluate(expr.operator, env);
			//如果在env中找到了expr.name，那么看这个expr.name是否定义为了函数。如果不是函数的话，就根本apply不了，执行不下去了，所以要报Applying a non-function的错。
			if(typeof op != "function"){
				throw new TypeError("Applying a non-function.");
			}
			//如果在env中找到了expr.name，并且expr.name在env中确实被定义为了函数，那么就利用apply，将expr.args转化为实际的参数值，传入这个函数。
			return op.apply(null, expr.args.map(function(arg){
				return evaluate(arg, env);
			}))
	}
}
var specialForms = Object.create(null);

specialForms["if"] = function(args, env){
	if(args.length != 3){
		throw new SyntaxError("Bad number of args to if");
	}

	if(evaluate(args[0], env) !== false){
		return evaluate(args[1], env);
	} else {
		return evaluate(args[2], env);
	}
}

specialForms["while"] = function(args, env){
	if(args.length != 2){
		throw new SyntaxError("Bad number of args to while");
	}

	while(evaluate(args[0], env) !== false){
		evaluate(args[1].env);
	}

	//由于Egg语言中不存在undefined，所以如果没有有意义的结果时，我们返回false
	return false;
}

specialForms["do"] = function(args, env){
	var value = false;
	args.forEach(function(arg){
		value = evaluate(arg, env);
	});

	return value;
}

specialForms["define"] = function(args, env){
	if(args.length != 2 || args[0].type != "word"){
		throw new SyntaxError("Bad use of define");
	}
	var value = evaluate(args[1], env);
	env[args[0].name] = value;
	return value;
};

var topEnv = object.create(null);

topEnv["true"] = true;
topEnv["false"] = false;

var prog = parse("if(true, false, true");
console.log(evaluate(prog, topEnv));
// false

["+", "-", "*", "/", "==", "<", ">"].forEach(function(op) {
  topEnv[op] = new Function("a, b", "return a " + op + " b;");
});

topEnv["print"] = function(value){
	console.log(value);
	return value;
}

function run(){
	var env = Object.create(topEnv);
	var program = Array.prototype.slice.call(arguments, 0).join("\n");
	return evaluate(parse(program), env);
}

run("do(define(total, 0),",
    "   define(count, 1),",
    "   while(<(count, 11),",
    "         do(define(total, +(total, count)),",
    "            define(count, +(count, 1)))),",
    "   print(total))");
//55

specialForms["fun"] = function(args, env){
    if(!args.length){
        throw new SyntaxError("Functions need a body");
    }
    //name函数是用来得到一个expr的name。由于参数都应当是word形式，所以不是word类型就应当报错。
    function name(expr){
        if(expr.type != "word"){
            throw new SyntaxError("Arg names must be words");
        }
        return expr.name;
    }
    var argNames = args.slice(0, args.length - 1).map(name);
    //用name这个函数对除最后一个args以外的所有args进行map，也就得到了一个除最后一个args以外的各个arg的name所组成的数组。这个数组中所放的，就是函数的所有参数。
    var body = args[args.length - 1];
    //args的最后一个就是函数体。

    return function(){ //很明显：fun这个函数返回的是一个函数
        if(arguments.length != argNames.length){
            //如果运行这个函数的时候，传入的实参与参数名的个数不匹配，那么就包括
            throw new TypeError("Wrong number of arguments");
        }
        var localEnv = Object.create(env); 
        //注意：上面这一句是利用传入的env为原型，构建了当前的localEnv，因此出现闭包的情况时，内部的局部环境变量localEnv仍然是可以访问到外部的环境变量env的。
        
        for(var i = 0; i < arguments.length; i++){
            //将一个个参数作为环境变量保存在局部环境对象里面。
            localEnv[argNames[i] = arguments[i]];
        }
        return evaluate(body, localEnv);
    };
};

run("do(define(plusOne, fun(a, +(a, 1))),",
    "    print(plusOne(10)))");
//11

run("do(define(pow, fun(base, exp,",
    "     if(==(exp, 0),",
    "        1,",
    "        *(base, pow(base, -(exp, 1)))))),",
    "   print(pow(2, 10)))");
//1024