importGlobal("");

function main()
{
	var code = File.readMapFile("PROMPT_MAP").CODE;
	
	evalFile("d:/rub/esprima.min.js");
	
	var ast = esprima.parse(code);
	
//	println(Str.formatJson(ast));
//	return;

	var scopes = {
		a : function(){
			return "AAAA";
		},
		b : function(){
			return "bbbb";
		}
	}


	var evalAST = new EvalEsprimaAST(ast, scopes);
	evalAST.execute({});

}
function EvalEsprimaAST(astRoot, globalVarbs)
{
	function ASTStackItem()
	{
		this._mapId2Varb = {};
	}
	////////////////////////////////////////////////////////////////////////
	function ASTValueItem(value)
	{
		this._value = value;
		
		this.getValue = function()
		{
			return this._value;
		}
	}

	////////////////////////////////////////////////////////////////////////
	function ASTVarbItem(refObj, refKey)
	{
		this._refObj = refObj;
		this._refKey = refKey;

		this.getValue = function()
		{
			return this._refObj[this._refKey];
		}

		this.setValue = function(value)
		{
			this._refObj[this._refKey] = value;
		}
	}

	////////////////////////////////////////////////////////////////////////
	// 初始化函数
	this._astRoot = astRoot;
	this._mapId2Global = {};
	for(var globalName in globalVarbs)
	{
		this._mapId2Global[globalName] = globalVarbs[globalName];
	}

	// 执行根函数
	this.execute = function(args)
	{
		var stack = new ASTStackItem();
		if(this._astRoot.type != "Program")
			throw new Exception("first node must be Program");

		var stack = new ASTStackItem();
		if(this._astRoot.body[0].type != "FunctionDeclaration")
			throw new Exception("second node must be FunctionDeclaration");

		
		this._execASTNode(this._astRoot.body[0].body, stack);
		var r = stack._mapId2Varb["c"];
		println(r);
	}

	this._isStringType = function(value)
	{
		if(typeof value === "string")
			return true;

		return false;
	}

	this._isNumberType = function(value)
	{
		if(typeof value === "number")
			return true;

		return false;
	}

	this._getAstVarbValue = function(varbName, stack)
	{
		// 如果在局部变量里能找到，则将其返回
		var varbItem = stack._mapId2Varb[varbName];
		if(varbItem !== undefined)
			return new ASTVarbItem(stack._mapId2Varb, varbName);

		// 如果在全局变量里能找到，则返回
		var varbItem = this._mapId2Global[varbName];
		if(varbItem !== undefined)
			return new ASTVarbItem(this._mapId2Global, varbName);

		throw "can't find variable : " + varbName;
	}

	this._getAstVarbNode = function(astNode, stack)
	{
		if(astNode.type == "Identifier")
		{
			var varbName = astNode.name;

			return this._getAstVarbValue(varbName, stack);
		}
		else
		{
			throw "unsupport ast variable type : " + astNode.type;
		}
	}

	// 执行ast节点
	this._execASTNode = function(astNode, stack)
	{
		var execNodeFunc = this["_execASTNode_" + astNode.type];
		if(!execNodeFunc)
			throw "unsupport ast node : " + astNode.type;
		return execNodeFunc.call(this, astNode, stack);
	}

	
	// 执行ast节点: Identifier
	this._execASTNode_Identifier = function(astNode, stack)
	{
		return this._getAstVarbValue(astNode.name, stack);
	}

	// 执行ast节点: BlockStatement
	this._execASTNode_BlockStatement = function(astNode, stack)
	{
		for(var bodyIdx in astNode.body)
		{
			this._execASTNode(astNode.body[bodyIdx], stack);
		}
	}

	// 执行ast节点: ExpressionStatement
	this._execASTNode_ExpressionStatement = function(astNode, stack)
	{
		return this._execASTNode(astNode.expression, stack);
	}

	// 执行ast节点: AssignmentExpression
	this._execASTNode_AssignmentExpression = function(astNode, stack)
	{
		// 获取右值
		var rightValue = this._execASTNode(astNode.right, stack).getValue();

		// 获取左值引用
		var leftVarb = this._getAstVarbNode(astNode.left, stack);

		// 将右值内容赋值到左值变量
		leftVarb.setValue(rightValue);
	}

	// 执行ast节点: CallExpression
	this._execASTNode_CallExpression = function(astNode, stack)
	{
		// 获取所有参数
		var args = [];
		for(var argIdx in astNode.arguments)
		{
			var argValue = this._execASTNode(astNode.arguments[argIdx], stack).getValue();
			args.push(argValue);
		}

		var varbFunc = this._getAstVarbNode(astNode.callee, stack);
		var ret = new ASTValueItem(varbFunc.getValue().apply(varbFunc._varb, args));
		return ret;
	}

	// 执行ast节点: VariableDeclaration
	this._execASTNode_VariableDeclaration = function(astNode, stack)
	{
		for(var astDeclIdx in  astNode.declarations)
		{
			var astDeclNode = astNode.declarations[astDeclIdx];
			var varbName = astDeclNode.id.name;

			// 创建变量
			var varbItem;
			if(astNode.kind == "var")
			{
				varbItem = stack._mapId2Varb[varbName];
				if(varbItem === undefined)
				{
					stack._mapId2Varb[varbName] = null;
					varbItem = new ASTVarbItem(stack._mapId2Varb, varbName);
				}
			}
			else if(astNode.kind == "let")
			{
				varbItem = this._mapId2Global[varbName];
				if(!varbItem === undefined)
				{
					this._mapId2Global[varbName] = null;
					varbItem = new ASTVarbItem(this._mapId2Global, varbName);
				}
			}
			else
			{
				throw "unsupport variable define type : " + astNode.kind;
			}
	
			// 初始化变量
			if(astDeclNode.init)
			{
				var value = this._execASTNode(astDeclNode.init, stack).getValue();
				varbItem.setValue(value);
			}
		}
	}

	// 执行ast节点: Literal
	this._execASTNode_Literal = function(astNode, stack)
	{
		return new ASTValueItem(astNode.value);
	}

	// 执行ast节点: ObjectExpression
	this._execASTNode_ObjectExpression = function(astNode, stack)
	{
		var jsonValue = {};

		for(var propIdx in astNode.properties)
		{
			var propItem = astNode.properties[propIdx];

			// 获取属性key
			var propKey;
			if(propItem.key.type == "Identifier")
				propKey = propItem.key.name;
			else if(propItem.key.type == "Literal")
				propKey = propItem.key.value;
			else
				throw "unsupport property type : " + propItem.key.type;

			// 获取属性值
			var propValue = this._execASTNode(propItem.value, stack).getValue();

			// 设置jsons属性
			jsonValue[propKey] = propValue;
		}

		return new ASTValueItem(jsonValue);
	}

	// 执行ast节点: MemberExpression
	this._execASTNode_MemberExpression = function(astNode, stack)
	{
		// 获取主变量
		var varbItem = this._getAstVarbNode(astNode.object, stack);

		// 获取属性key
		var propKey;
		if(astNode.property.type == "Identifier")
		{
			if(!astNode.computed)
				propKey = astNode.property.name;
			else
				propKey = this._getAstVarbValue(astNode.property.name, stack).getValue();
		}
		else 
			propKey = this._execASTNode(astNode.property, stack).getValue();

		return new ASTVarbItem(varbItem.getValue(), propKey);
	}	

	// 执行ast节点: ArrayExpression
	this._execASTNode_ArrayExpression = function(astNode, stack)
	{
		var jsonValue = [];

		for(var index in astNode.elements)
		{
			var value = this._execASTNode(astNode.elements[index], stack).getValue();
			jsonValue.push(value);
		}

		return new ASTValueItem(jsonValue);
	}

	// 执行ast节点: BinaryExpression
	this._execASTNode_BinaryExpression = function(astNode, stack)
	{
		var leftValue = this._execASTNode(astNode.left, stack).getValue();
		var rightValue = this._execASTNode(astNode.right, stack).getValue();

		var result = null;
		if(astNode.operator == "+")
		{
			result = leftValue + rightValue;
		}
		else if(astNode.operator == "-")
		{
			result = leftValue - rightValue;
		}
		else if(astNode.operator == "*")
		{
			result = leftValue * rightValue;
		}
		else if(astNode.operator == "/")
		{
			result = leftValue / rightValue;
		}
		else if(astNode.operator == "%")
		{
			result = leftValue % rightValue;
		}
		else if(astNode.operator == "<")
		{
			result = leftValue < rightValue;
		}
		else if(astNode.operator == ">")
		{
			result = leftValue > rightValue;
		}
		else if(astNode.operator == "<=")
		{
			result = leftValue <= rightValue;
		}
		else if(astNode.operator == ">=")
		{
			result = leftValue >= rightValue;
		}
		else if(astNode.operator == "==")
		{
			result = leftValue == rightValue;
		}
		else if(astNode.operator == "===")
		{
			result = leftValue === rightValue;
		}
		else if(astNode.operator == "!=")
		{
			result = leftValue != rightValue;
		}
		else if(astNode.operator == "!==")
		{
			result = leftValue !== rightValue;
		}
		else
		{
			throw "unsupport BinaryExpression operate : " + astNode.operator;
		}

		return new ASTValueItem(result);
	}	

	// 执行ast节点: UnaryExpression
	this._execASTNode_UnaryExpression = function(astNode, stack)
	{
		var value = this._execASTNode(astNode.argument, stack).getValue();

		var result = null;
		if(astNode.operator == "!")
		{
			result = !value;
		}

		return new ASTValueItem(result);
	}


	// 执行ast节点: LogicalExpression
	this._execASTNode_LogicalExpression = function(astNode, stack)
	{
		var result = null;
		if(astNode.operator == "&&")
		{
			var leftValue = this._execASTNode(astNode.left, stack).getValue();
			if(!leftValue)
			{
				result = false;
			}
			else
			{
				var rightValue = this._execASTNode(astNode.right, stack).getValue();
				if(!rightValue)
					result = false;
				else
					result = true;
			}
		}
		else if(astNode.operator == "||")
		{
			var leftValue = this._execASTNode(astNode.left, stack).getValue();
			if(!!leftValue)
			{
				result = true;
			}
			else
			{
				var rightValue = this._execASTNode(astNode.right, stack).getValue();
				if(!!rightValue)
					result = true;
				else
					result = false;
			}
		}
		else
		{
			throw "unsupport BinaryExpression operate : " + astNode.operator;
		}

		return new ASTValueItem(result);
	}	

	// 执行ast节点: IfStatement
	this._execASTNode_IfStatement = function(astNode, stack)
	{
		// 计算条件值
		var condValue = this._execASTNode(astNode.test, stack).getValue();

		// 如果条件为真，则执行以下代码
		if(condValue)
		{
			this._execASTNode(astNode.consequent, stack);
		}
		else
		{
			this._execASTNode(astNode.alternate, stack);
		}
	}
	
	// 执行ast节点: ForInStatement
	this._execASTNode_ForInStatement = function(astNode, stack)
	{
		var itorVarbName;

		// 如果迭代变量是定义语句，则创建变量
		if(astNode.left.type == "VariableDeclaration")
		{
			this._execASTNode(astNode.left, stack);
			itorVarbName = astNode.left.declarations[0].id.name;
		}
		// 如果迭代变量不是定义语句，则获取变量名
		else
		{
			itorVarbName = astNode.left.name;
		}
		var itorVarbItem = this._getAstVarbValue(itorVarbName, stack);

		// 获取迭代对象
		var aggValue = this._execASTNode(astNode.right, stack).getValue();

		// 迭代操作
		for(var itor in aggValue)
		{
			// 保存当前进度itor
			itorVarbItem.setValue(itor);

			// 执行后续语句
			this._execASTNode(astNode.body, stack);
		}
	}

	// 执行ast节点: ForStatement
	this._execASTNode_ForStatement = function(astNode, stack)
	{
		// 执行初始化
		this._execASTNode(astNode.init, stack);

		while(true)
		{
			// 执行判断
			var condValue = this._execASTNode(astNode.test, stack).getValue();
			if(!condValue)
				break;

			// 执行循环块
			this._execASTNode(astNode.body, stack);

			// 执行步长
			this._execASTNode(astNode.update, stack);
		}
	}

	
	////////////////////////////////////////////////////////////////////////////////////////////

}
	

main();


/*
 * 
PROMPT_MAP:CODE
function main()
{
	var c = 0;
	for(var i = 0; i < 100; i = i + 1)
	{
		c = i;
	}
}
PROMPT_MAP$

 */