极致之美——百行代码实现全新智能语言第5/6页

为了学习,测试上面的ListScript,我写了一个命令环境

<script>
NIL = [];

Array.prototype.toEvalString = function()
{
if(this.length <= 0) return "NIL";
var str = "";
for (var i = 0; i < this.length; i++)
{
  if(this instanceof Array)
   str += "," + this.toEvalString();
  else str += "," + this;
}
return "[" + str.slice(1) + "]";
};

(function(){

LispScript = {
  Run : run
};

function run(code)
{
  if(code instanceof Array)
  {
   var elements = new Array();
   for (var i = 0; i < code.length; i++)
   {
    code = run(code); //递归向下读取
    if(code instanceof Function)  //解析表达式
    {
     if(code.length <= 0) //无参函数可省略[]直接以函数名称调用
     {
      code = code.call(null);
     }
     else if(i == 0)  //调用带参数的函数[funcall,args...]
     {
      return code.apply(null, code.slice(1));
     }
    }
   }

   return code;
  }
  return Element(code);
};
})();

function Assert(msg, cond)
{
if(cond)
  return true;
else
  {
   alert(msg);
   throw new Error(msg);
  }
};

function Element(arg)
{
if(arg == null)
  return [];
else if(arg instanceof Function && arg.length <= 0)
  return arg.call(null);
else
  return arg;
};

__funList = new Array();


/////////////////
quote = _ = function(args)
{
if(arguments.length < 1)
  return [];
else if(arguments.length >= 1)
{
  return arguments[0];
}
};

//[atom,x]返回原子true如果x的值是一个原子或是空表,否则返回[]. 在Lisp中我们按惯例用原子true表示真, 而用空表表示假.
atom = function(arg)
{
var tmp = LispScript.Run(arg); //先对参数求值

if(!(tmp instanceof Array) || tmp.length <= 0)
  return true;
else
  return [];
};

//[eq,x,y]返回t如果x和y的值是同一个原子或都是空表, 否则返回[].
equal = eq = function(arg1, arg2)
{
var tmp1 = LispScript.Run(arg1);
var tmp2 = LispScript.Run(arg2);   //先对参数求值

if(!(tmp1 instanceof Array) && !(tmp2 instanceof Array) && 
  tmp1.toString() == tmp2.toString() || 
  (tmp1 instanceof Function) && (tmp2 instanceof Function) && tmp1.toString() == tmp2.toString() ||
  (tmp1 instanceof Array) && (tmp2 instanceof Array) && (tmp1.length == 0) && (tmp2.length == 0))
  return true;
else
  return [];
};

//[car,x]期望x的值是一个表并且返回x的第一个元素.
car = function(arg)
{
var tmp = LispScript.Run(arg);  //先对参数求值

if(tmp instanceof Array && tmp.length > 0)
  return tmp[0];
else
  return [];
};

//[cdr,x]期望x的值是一个表并且返回x的第一个元素之后的所有元素.
cdr = function(arg)
{
var tmp = LispScript.Run(arg);  //先对参数求值

if(tmp instanceof Array && tmp.length > 0)
  return tmp.slice(1);
else
  return []; 
};

//[cons,x,y]期望y的值是一个表并且返回一个新表,它的第一个元素是x的值, 后面跟着y的值的各个元素.
cons = function(arg1, arg2)
{
var tmp1 = LispScript.Run(arg1);
var tmp2 = LispScript.Run(arg2);   //先对参数求值

if(tmp2 instanceof Array)
{
  var list = new Array();
  list.push(tmp1);
  return list.concat(tmp2);
}
else
  return [];
};

/*
[cond [...] ...[...]] 的求值规则如下. p表达式依次求值直到有一个返回t. 如果能找到这样的p表达式,相应的e表达式的值作为整个cond表达式的返回值.

*/
cond = function(args)
{
for (var i = 0; i < arguments.length; i++)
{
  if(arguments instanceof Array)
  {
   var cond = LispScript.Run(arguments[0]);  //先对参数求值
   //alert(cond);
   if(cond == true && arguments[1] != null)
    return LispScript.Run(arguments[1]);
  }
}
return [];
};

//则称为函数调用.它的值计算如下.每一个表达式先求值,然后e再求值.在e的求值过程中,每个出现在e中的的值是相应的在最近一次的函数调用中的值.
lambda = function(args, code)
{
if(code instanceof Array)
{
  var fun = new Function(args, 
   "for(var i = 0; i < arguments.length; i++) arguments = LispScript.Run(arguments);return LispScript.Run("+code.toEvalString()+");");

  var globalFuncName = __funList.pop();

  fun._funName = globalFuncName;

  if(globalFuncName != null)
   self[globalFuncName] = fun;

  return fun;
}

return [];
};

</script>
<script>
        var prompt = '>';
        function initPrompt()
        {
                if(cmd.value == '')
                        cmd.value = prompt;
        }
        function runLastCmd()
        {
                if(window.event.keyCode == 13)
                {
                        window.event.returnValue = false;

                        var idx = cmd.value.lastIndexOf('\n') + 1;
                        idx += prompt.length;

                        var strCmd = cmd.value.substr(idx);
                        var output = '';
                        try
                        {
                                var lisp = eval(strCmd);
                                if(lisp instanceof Array)
                                {
                                         output = LispScript.Run(lisp);
                                }
                                else
                                {
                                        output = '未知命令';
                                }
                        }
                        catch(e)
                        {
                                output = '语法错误';
                        }
                        if(output instanceof Array)
                        {
                                output = '[' + output + ']';
                        }
                        cmd.value += '\n' + output + '\n' + prompt;
                }

        }
</script>
<textarea id=cmd style="width:600px;height:600px" onkeydown="runLastCmd()" onclick="initPrompt()">
</textarea>