1 // -* coding: utf-8; -*
6 Log: function (arg, indent, cont)
12 while (Xex.LogNode.childNodes.length > 0)
13 Xex.LogNode.removeChild (Xex.LogNode.firstChild);
20 Xex.LogNode.lastChild.innerText += arg;
24 if (LogNodeLen >= 1000)
25 node = Xex.LogNode.firstElement ();
27 node = document.createElement ('div');
28 if (indent != undefined)
29 node.style.textIndent = (indent + 1) + 'em';
31 node.style.textIndent = '0px';
32 node.innerText = LogNodeLen + ': ' + arg;
33 Xex.LogNode.appendChild (node);
34 Xex.LogNode.scrollTop = Xex.LogNode.scrollHeight;
41 UnknownError: "unknown-error",
42 WrongArgument: "wrong-argument",
44 InvalidInteger: "invalid-integer",
45 TermTypeInvalid: "term-type-invalid",
46 FunctionConflict: "function-conflict",
47 VariableTypeConflict: "variable-type-conflict",
48 VariableRangeConflict: "variable-range-conflict",
49 VariableWrongRange: "variable-wrong-range",
50 VariableWrongValue: "variable-wrong-value",
52 UnknownFunction: "unknown-function",
53 MacroExpansionError: "macro-expansion-error",
54 NoVariableName: "no-variable-name",
55 NoFunctionName: "no-funcion-name",
58 ArithmeticError: "arithmetic-error",
59 WrongType: "wrong-type",
60 IndexOutOfRange: "index-out-of-range",
61 ValueOutOfRange: "value-out-of-range",
62 NoLoopToBreak: "no-loop-to-break",
63 UncaughtThrow: "uncaught-throw"
66 Xex.Variable = function (domain, name, desc, val, range)
75 Xex.Variable.prototype.clone = function ()
77 return new Xex.Variable (this.domain, this.name, this.desc,
78 this.val, this.range);
81 Xex.Variable.prototype.Equals = function (obj)
83 return ((obj instanceof Xex.Variable)
84 && obj.name == this.name);
87 Xex.Variable.prototype.SetValue = function (term)
93 Xex.Function = function (name, with_var, min_args, max_args)
96 this.with_var = with_var;
97 this.min_args = min_args;
98 this.max_args = max_args;
101 Xex.Subrountine = function (builtin, name, with_var, min_args, max_args)
104 this.with_var = with_var;
105 this.min_args = min_args;
106 this.max_args = max_args;
107 this.builtin = builtin;
110 Xex.Subrountine.prototype.Call = function (domain, vari, args)
112 var newargs = new Array ();
113 for (var i = 0; i < args.length; i++)
115 newargs[i] = args[i].Eval (domain);
116 if (domain.Thrown ())
119 return this.builtin (domain, vari, newargs)
122 Xex.SpecialForm = function (builtin, name, with_var, min_args, max_args)
125 this.with_var = with_var;
126 this.min_args = min_args;
127 this.max_args = max_args;
128 this.builtin = builtin;
131 Xex.SpecialForm.prototype.Call = function (domain, vari, args)
133 return this.builtin (domain, vari, args)
136 Xex.Lambda = function (name, min_args, max_args, args, body)
139 this.min_args = min_args;
140 this.max_args = max_args;
145 Xex.Lambda.prototype.Call = function (domain, vari, args)
147 var current = domain.bindings;
148 var result = Xex.Zero;
149 var limit = max_args >= 0 ? args.length : args.length - 1;
153 for (i = 0; i < limit; i++)
155 result = args[i].Eval (domain);
156 if (domain.Thrown ())
158 domain.Bind (this.args[i], result);
162 var list = new Array ();
163 for (i = 0; i < args[limit].length; i++)
165 result = args[limit].Eval (domain);
166 if (domain.Thrown ())
170 domain.Bind (this.args[limit], list);
173 domain.Catch (Xex.CatchTag.Return);
174 for (var term in this.body)
176 result = term.Eval (domain);
177 if (domain.Thrown ())
184 domain.UnboundTo (current);
189 Xex.Macro = function (name, min_args, max_args, args, body)
192 this.min_args = min_args;
193 this.max_args = max_args;
198 Xex.Macro.prototype.Call = function (domain, vari, args)
200 var current = domain.bindings;
201 var result = Xex.Zero;
205 for (i = 0; i < args.length; i++)
206 domain.Bind (this.args[i], args[i]);
208 domain.Catch (Xex.CatchTag.Return);
209 for (var i in this.body)
211 result = this.body[i].Eval (domain);
212 if (domain.Thrown ())
219 domain.UnboundTo (current);
224 Xex.Bindings = function (vari)
227 this.old_value = vari.val;
230 Xex.Bindings.prototype.UnboundTo = function (boundary)
232 for (var b = this; b != boundary; b = b.next)
233 b.vari.val = b.old_value;
237 Xex.Bind = function (bindings, vari, val)
239 var b = new Xex.Bindings (vari);
250 Xex.Domain = function (name, parent, context)
253 this.context = context;
256 if (name != 'basic' && ! parent)
257 parent = Xex.BasicDomain
258 this.parent = parent;
265 for (elt in parent.termtypes)
266 this.termtypes[elt] = parent.termtypes[elt];
267 for (elt in parent.functions)
268 this.functions[elt] = parent.functions[elt];
269 for (elt in parent.variables)
271 var vari = parent.variables[elt];
272 this.variables[elt] = new Xex.Variable (this, vari.name, vari.desc,
273 vari.val, vari.range);
277 this.call_stack = new Array ();
278 this.bindings = null;
279 this.catch_stack = new Array ();
280 this.catch_count = 0;
284 Xex.Domain.prototype = {
285 CallStackCount: function () { return this.call_stack.length; },
286 CallStackPush: function (term) { this.call_stack.push (term); },
287 CallStackPop: function () { this.call_stack.pop (); },
288 Bind: function (vari, val)
290 this.bindings = Xex.Bind (this.bindings, vari, val);
292 UnboundTo: function (boundary)
295 this.bindings = this.bindings.UnboundTo (boundary);
297 Catch: function (tag) { this.catch_stack.push (tag); this.catch_count++; },
300 this.catch_stack.pop ();
301 if (this.catch_count > this.catch_stack.length)
306 if (this.catch_count < this.catch_stack.length)
308 this.caught = (this.catch_count == this.catch_stack.length - 1);
314 ThrowReturn: function ()
316 for (var i = this.catch_stack.length - 1; i >= 0; i--)
319 if (this.catch_stack[i] == Xex.CatchTag.Return)
323 ThrowBreak: function ()
325 if (this.catch_stack[this.catch_stack.length - 1] != Xex.CatchTag.Break)
326 throw new Xex.ErrTerm (Xex.Error.NoLoopToBreak,
327 "No surrounding loop to break");
330 ThrowSymbol: function (tag)
332 var i = this.catch_count;
333 for (var j = this.catch_stack.length - 1; j >= 0; j--)
336 if (Xex.CatchTag.Matches (this.catch_stack[i], tag))
338 this.catch_count = i;
342 throw new Xex.ErrTerm (Xex.Error.UncaughtThrow,
343 "No corresponding catch: " + tag);
345 DefType: function (obj)
348 if (this.termtypes[type])
349 throw new Xex.ErrTerm (Xex.Error.TermTypeInvalid,
350 "Already defined: " + type);
351 if (this.functions[type])
352 throw new Xex.ErrTerm (Xex.Error.TermTypeInvalid,
353 "Already defined as a funciton or a macro: "
355 this.termtypes[type] = obj.Parser;
357 DefSubr: function (builtin, name, with_var, min_args, max_args)
359 this.functions[name] = new Xex.Subrountine (builtin, name, with_var,
362 DefSpecial: function (builtin, name, with_var, min_args, max_args)
364 this.functions[name] = new Xex.SpecialForm (builtin, name, with_var,
367 Defun: function (name, min_args, max_args, args, body)
369 this.functions[name] = new Xex.Lambda (name, min_args, max_args,
372 DefunByFunc: function (func) { this.functions[func.name] = func; },
373 Defmacro: function (name, min_args, max_args, args, body)
375 this.functions[name] = new Xex.Macro (name, min_args, max_args,
378 DefAlias: function (alias, fname)
380 var func = this.functions[fname];
383 throw new Xex.ErrTerm (Xex.Error.UnknownFunction, fname);
384 if (this.termtypes[alias])
385 throw new Xex.ErrTerm (Xex.Error.FunctionConflict,
386 "Already defined as a term type: " + alias);
387 if (this.functions[alias])
388 throw new Xex.ErrTerm (Xex.Error.FunctionConflict,
389 "Already defined as a function: " + alias);
390 this.functions[alias] = func;
392 Defvar: function (name, desc, val, range)
394 var vari = new Xex.Variable (this, name, desc, val, range);
395 this.variables[name] = vari;
398 GetFunc: function (name)
400 var func = this.functions[name];
402 throw new Xex.ErrTerm (Xex.Error.UnknownFunction,
403 "Unknown function: " + name);
406 CopyFunc: function (domain, name)
408 var func = this.functions[name];
409 domain.DefunByFunc (func);
412 CopyFuncAll: function (domain)
414 for (var elt in this.functions)
415 domain.DefunByFunc (this.functions[elt]);
417 GetVarCreate: function (name)
419 var vari = this.variables[name];
421 vari = this.variables[name] = new Xex.Variable (this, name, null,
425 GetVar: function (name) { return this.variables[name]; },
426 SaveValues: function ()
429 for (var elt in this.variables)
430 values[elt] = this.variables[elt].val.Clone ();
433 RestoreValues: function (values)
438 var vari = this.variables[name];
439 vari.val = values[name];
444 Xex.Term = function (type) { this.type = type; }
445 Xex.Term.prototype = {
446 IsTrue: function () { return true; },
447 Eval: function (domain) { return this.Clone (); },
448 Clone: function (domain) { return this; },
449 Equals: function (obj)
451 return (this.type == obj.type
452 && this.val != undefined
453 && obj.val == this.val);
455 Matches: function (obj) { return this.Equals (obj); },
456 toString: function ()
458 if (this.val != undefined)
459 return '<' + this.type + '>' + this.val + '</' + this.type + '>';
460 return '<' + this.type + '/>';
462 Intval: function () { throw new Xex.ErrTerm (Xex.Error.WrongType,
463 "Not an integer"); },
464 Strval: function () { throw new Xex.ErrTerm (Xex.Error.WrongType,
468 Node.prototype.firstElement = function ()
470 for (var n = this.firstChild; n; n = n.nextSibling)
476 Node.prototype.nextElement = function ()
478 for (var n = this.nextSibling; n; n = n.nextSibling)
485 function parse_defvar (domain, node)
487 var name = node.attributes['vname'].nodeValue;
489 throw new Xex.ErrTerm (Xex.Error.NoVariableName, node, '');
490 var vari = domain.variables[name];
491 var desc, val = null, range;
494 desc = vari.description;
498 node = node.firstElement ();
499 if (node && node.nodeName == 'description')
501 desc = node.firstChild.nodeValue;
502 node = node.nextElement ();
506 val = Xex.Term.Parse (domain, node);
507 node = node.nextElement ();
508 if (node && node.nodeName == 'possible-values')
509 for (node = node.firstElement (); node; node = node.nextElement ())
512 if (node.nodeName == 'range')
515 throw new Xex.ErrTerm (Xex.Error.TermTypeInvalid,
516 'Range not allowed for ' + name);
518 for (var n = node.firstElement (); n; n = n.nextElement ())
520 var v = Xex.Term.Parse (domain, n);
522 throw new Xex.ErrTerm (Xex.Error.TermTypeInvalid,
523 'Invalid range value: ' + val);
529 pval = Xex.Term.Parse (domain, node);
530 if (val.type != pval.type)
531 throw new Xex.ErrTerm (Xex.Error.TermTypeInvalid,
532 'Invalid possible value: ' + pval);
535 range = new Array ();
541 domain.Defvar (name, desc, val, range);
545 function parse_defun_head (domain, node)
547 var name = node.attributes['fname'].nodeValue;
549 throw new Xex.ErrTerm (Xex.Error.NoFunctionName, node, '');
550 var args = new Array ();
551 var nfixed = 0, noptional = 0, nrest = 0;
553 node = node.firstElement ();
554 if (node && node.nodeName == 'args')
557 for (n = n.firstElement (); n; n = n.nextElement ())
559 if (n.nodeName == 'fixed')
561 else if (n.nodeName == 'optional')
563 else if (n.nodeName == 'rest')
566 throw new Xex.ErrTerm (Xex.Error.WrongType, n, n.nodeName);
569 throw new Xex.ErrTerm (Xex.Error.WrongType, n, 'Too many <rest>');
570 for (n = node.firstElement (); n; n = n.nextElement ())
571 args.push (domain.DefVar (n.attributes['vname'].nodeValue));
573 args.min_args = nfixed;
574 args.max_args = nrest == 0 ? nfixed + noptional : -1;
576 if (node.nodeName == 'defun')
577 domain.Defun (name, args, null);
579 domain.Defmacro (name, args, null);
583 function parse_defun_body (domain, node)
585 var name = node.attributes['fname'].nodeValue;
586 var func = domain.GetFunc (name);
588 for (node = node.firstElement (); node; node = node.nextElement ())
589 if (node.nodeName != 'description' && node.nodeName != 'args')
591 body = Xex.Term.Parse (domain, node, null);
595 Xex.Term.Parse = function (domain, node, stop)
597 if (arguments.length == 2)
599 var name = node.nodeName;
600 var parser = domain.termtypes[name];
603 return parser (domain, node);
604 if (name == 'defun' || name == 'defmacro')
606 name = parse_defun_head (domain, node);
607 parse_defun_body (domain, node);
608 return new Xex.StrTerm (name);
610 if (name == 'defvar')
612 name = parse_defvar (domain, node);
613 return new Xex.StrTerm (name);
615 return new Xex.Funcall.prototype.Parser (domain, node);
617 for (var n = node; n && n != stop; n = n.nextElement ())
618 if (n.nodeName == 'defun' || n.nodeName == 'defmacro')
619 parse_defun_head (domain, n);
621 for (var n = node; n && n != stop; n = n.nextElement ())
623 if (n.nodeName == 'defun' || n.nodeName == 'defmacro')
624 parse_defun_body (domain, n);
625 else if (n.nodeName == 'defvar')
626 parse_defvar (domain, n);
630 terms = new Array ();
631 terms.push (Xex.Term.Parse (domain, n));
638 Xex.Varref = function (vname)
644 var proto = new Xex.Term ('varref');
646 proto.Clone = function () { return new Xex.Varref (this.val); }
647 proto.Eval = function (domain)
649 var vari = domain.GetVarCreate (this.val);
650 Xex.Log (this.ToString () + '=>' + vari.val, domain.depth);
654 proto.Parser = function (domain, node)
656 return new Xex.Varref (node.attributes['vname'].nodeValue);
659 proto.ToString = function ()
661 return '<varref vname="' + this.val + '"/>';
664 Xex.Varref.prototype = proto;
667 var null_args = new Array ();
669 Xex.Funcall = function (func, vname, args)
673 this.args = args || null_args;
677 var proto = new Xex.Term ('funcall');
679 proto.Parser = function (domain, node)
681 var fname = node.nodeName;
684 if (fname == 'funcall')
685 fname = node.attributes['fname'].nodeValue;
686 var func = domain.GetFunc (fname);
688 attr = node.attributes['vname'];
689 vname = attr != undefined ? attr.nodeValue : null;
690 var args = Xex.Term.Parse (domain, node.firstElement (), null);
691 return new Xex.Funcall (func, vname, args);
694 proto.New = function (domain, fname, vname, args)
696 var func = domain.GetFunc (fname);
697 var funcall = new Xex.Funcall (func, vname, args);
698 if (func instanceof Xex.Macro)
699 funcall = funcall.Eval (domain);
703 proto.Eval = function (domain)
705 Xex.Log (this, domain.depth);
708 vari = domain.GetVarCreate (this.vname);
712 result = this.func.Call (domain, vari, this.args);
714 Xex.Log (' => ' + result, --domain.depth,
715 this.func instanceof Xex.Subrountine);
720 proto.Clone = function ()
722 return new Xex.Funcall (this.func, this.vari, this.args);
725 proto.Equals = function (obj)
727 return (obj.type == 'funcall'
728 && obj.func == this.func
729 && obj.vari.Equals (this.vari)
730 && obj.args.length == this.func.length);
733 proto.toString = function ()
736 var len = this.args.length;
737 var str = '<' + this.func.name;
739 str += ' vname="' + this.vname + '"';
742 if (this.func instanceof Xex.Subrountine)
743 for (var i = 0; i < len; i++)
744 arglist += this.args[i].toString ();
746 for (var i = 0; i < len; i++)
748 return str + '>' + arglist + '</' + this.func.name + '>';
751 Xex.Funcall.prototype = proto;
754 Xex.ErrTerm = function (ename, message, stack)
757 this.message = message;
762 var proto = new Xex.Term ('error');
764 proto.IsError = true;
766 proto.Parser = function (domain, node)
768 return new Xex.ErrTerm (node.attributes['ename'].nodeValue,
769 node.innerText, false);
772 proto.CallStack = function () { return stack; }
774 proto.SetCallStack = function (value) { statck = value; }
776 proto.Clone = function ()
778 return new Xex.ErrTerm (ename, message, false);
781 proto.Equals = function (obj)
784 && obj.ename == ename && obj.message == message
785 && (obj.stack ? (stack && stack.length == obj.stack.length)
789 proto.Matches = function (obj)
791 return (obj.IsError && obj.ename == ename);
794 proto.toString = function ()
796 return '<error ename="' + this.ename + '">' + this.message + '</error>';
799 Xex.ErrTerm.prototype = proto;
802 Xex.IntTerm = function (num) { this.val = num; };
804 var proto = new Xex.Term ('integer');
806 proto.Intval = function () { return this.val; };
807 proto.IsTrue = function () { return this.val != 0; }
808 proto.Clone = function () { return new Xex.IntTerm (this.val); }
809 proto.Parser = function (domain, node)
811 var str = node.firstChild.nodeValue;
813 if (str.charAt (0) == '?' && str.length == 2)
814 return new Xex.IntTerm (str.charCodeAt (1));
815 return new Xex.IntTerm (parseInt (node.firstChild.nodeValue));
817 Xex.IntTerm.prototype = proto;
820 Xex.StrTerm = function (str) { this.val = str; };
822 var proto = new Xex.Term ('string');
824 proto.Strval = function () { return this.val; };
825 proto.IsTrue = function () { return this.val.length > 0; }
826 proto.Clone = function () { return new Xex.StrTerm (this.val); }
827 proto.Parser = function (domain, node)
829 return new Xex.StrTerm (node.firstChild ? node.firstChild.nodeValue : '');
831 Xex.StrTerm.prototype = proto;
834 Xex.SymTerm = function (str) { this.val = str; };
836 var proto = new Xex.Term ('symbol');
837 proto.IsSymbol = true;
838 proto.IsTrue = function () { return this.val != 'nil'; }
839 proto.Clone = function () { return new Xex.SymTerm (this.val); }
840 proto.Parser = function (domain, node)
842 return new Xex.SymTerm (node.firstChild.nodeValue);
844 Xex.SymTerm.prototype = proto;
847 Xex.LstTerm = function (list) { this.val = list; };
849 var proto = new Xex.Term ('list');
851 proto.IsTrue = function () { return this.val.length > 0; }
852 proto.Clone = function () { return new Xex.LstTerm (this.val.slice (0)); }
854 proto.Equals = function (obj)
856 if (obj.type != 'list' || obj.val.length != this.val.length)
858 var i, len = this.val.length;
859 for (i = 0; i < len; i++)
860 if (! this.val[i].Equals (obj.val[i]))
865 proto.Parser = function (domain, node)
867 var list = Xex.Term.Parse (domain, node.firstElement (), null);
868 return new Xex.LstTerm (list);
871 proto.toString = function ()
873 var len = this.val.length;
878 for (var i = 0; i < len; i++)
879 str += this.val[i].toString ();
880 return str + '</list>';
882 Xex.LstTerm.prototype = proto;
886 var basic = new Xex.Domain ('basic', null, null);
888 function Fset (domain, vari, args)
891 throw new Xex.ErrTerm (Xex.Error.NoVariableName,
892 'No variable name to set');
893 vari.SetValue (args[0]);
897 function Fnot (domain, vari, args)
899 return (args[0].IsTrue () ? Xex.Zero : Xex.One);
902 function maybe_set_intvar (vari, n)
904 var term = new Xex.IntTerm (n);
906 vari.SetValue (term);
910 function Fadd (domain, vari, args)
912 var n = vari ? vari.val.Intval () : 0;
913 var len = args.length;
915 for (var i = 0; i < len; i++)
916 n += args[i].Intval ();
917 return maybe_set_intvar (vari, n);
920 function Fmul (domain, vari, args)
922 var n = vari ? vari.val.Intval () : 1;
923 for (var i = 0; i < args.length; i++)
924 n *= args[i].Intval ();
925 return maybe_set_intvar (vari, n);
928 function Fsub (domain, vari, args)
934 n = args[0].Intval ();
939 n = vari.val.Intval ();
942 while (i < args.length)
943 n -= args[i++].Intval ();
944 return maybe_set_intvar (vari, n);
947 function Fdiv (domain, vari, args)
953 n = args[0].Intval ();
958 n = vari.val.Intval ();
961 while (i < args.length)
962 n /= args[i++].Intval ();
963 return maybe_set_intvar (vari, n);
966 function Fmod (domain, vari, args)
968 return maybe_set_intvar (vari, args[0].Intval () % args[1].Intval ());
971 function Flogior (domain, vari, args)
973 var n = vari == null ? 0 : vari.val;
974 for (var i = 0; i < args.length; i++)
976 return maybe_set_intvar (vari, n);
979 function Flogand (domain, vari, args)
984 Xex.Log ("logand arg args[0]" + args[0]);
985 n = args[0].Intval ()
990 Xex.Log ("logand arg var " + vari);
991 n = vari.val.Intval ();
994 while (n > 0 && i < args.length)
996 Xex.Log ("logand arg " + args[i]);
999 return maybe_set_intvar (vari, n);
1002 function Flsh (domain, vari, args)
1004 return maybe_set_intvar (vari, args[0].Intval () << args[1].Intval ());
1007 function Frsh (domain, vari, args)
1009 return maybe_set_intvar (vari, args[0].Intval () >> args[1].Intval ());
1012 function Fand (domain, vari, args)
1014 var len = args.length;
1015 for (var i = 0; i < len; i++)
1017 var result = args[i].Eval (domain);
1018 if (domain.Thrown ())
1020 if (! result.IsTrue ())
1026 function For (domain, vari, args)
1028 var len = args.length;
1029 for (var i = 0; i < len; i++)
1031 var result = args[i].Eval (domain);
1032 if (domain.Thrown ())
1034 if (result.IsTrue ())
1040 function Feq (domain, vari, args)
1042 for (var i = 1; i < args.length; i++)
1043 if (! args[i - 1].Equals (args[i]))
1048 function Fnoteq (domain, vari, args)
1050 return (Feq (domain, vari, args) == Xex.One ? Xex.Zero : Xex.One);
1053 function Flt (domain, vari, args)
1055 var n = args[0].Intval ();
1057 for (var i = 1; i < args.length; i++)
1059 var n1 = args[i].Intval ();
1067 function Fle (domain, vari, args)
1069 var n = args[0].Intval ();
1070 for (var i = 1; i < args.length; i++)
1072 var n1 = args[i].Intval ();
1080 function Fgt (domain, vari, args)
1082 var n = args[0].Intval ();
1083 for (var i = 1; i < args.length; i++)
1085 var n1 = args[i].Intval ();
1093 function Fge (domain, vari, args)
1095 var n = args[0].Intval ();
1096 for (var i = 1; i < args.length; i++)
1098 var n1 = args[i].Intval ();
1106 function Fprogn (domain, vari, args)
1108 var result = Xex.One;
1109 var len = args.length;
1111 for (var i = 0; i < len; i++)
1113 result = args[i].Eval (domain);
1114 if (domain.Thrown ())
1120 function Fif (domain, vari, args)
1122 var result = args[0].Eval (domain);
1124 if (domain.Thrown ())
1126 if (result.IsTrue ())
1127 return args[1].Eval (domain);
1128 if (args.length == 2)
1130 return args[2].Eval (domain);
1133 function Fcond (domain, vari, args)
1135 for (var i = 0; i < args.length; i++)
1138 var result = list.val[0].Eval (domain);
1139 if (result.IsTrue ())
1141 for (var j = 1; j < list.val.length; j++)
1144 result = list.val[j].Eval (domain);
1146 if (domain.Thrown ())
1155 function eval_terms (domain, terms, idx)
1157 var result = Xex.Zero;
1158 domain.caught = false;
1159 for (var i = idx; i < terms.length; i++)
1161 result = terms[i].Eval (domain);
1162 if (domain.Thrown ())
1168 function Fcatch (domain, vari, args)
1173 if (args[0].IsError)
1176 result = eval_terms (domain, args, 1);
1178 if (e instanceof Xex.ErrTerm)
1180 if (! args[0].Matches (e))
1188 else if (args[0].IsSymbol)
1191 domain.Catch (args[0].val);
1192 result = eval_terms (domain, args, 1);
1196 vari.SetValue (result);
1204 throw new Xex.ErrTerm (Xex.Error.WrongArgument,
1205 "Not a symbol nor an error: " + args[0]);
1208 function Fthrow (domain, vari, args)
1210 if (args[0].IsSymbl)
1212 domain.ThrowSymbol (args[0]);
1213 return (args[args.length - 1]);
1215 if (args[0].IsError)
1219 throw new Xex.ErrTerm (Xex.Error.WrongArgument,
1220 "Not a symbol nor an error:" + args[0]);
1223 Xex.BasicDomain = basic;
1225 basic.DefSubr (Fset, "set", true, 1, 1);
1226 basic.DefAlias ("=", "set");
1227 basic.DefSubr (Fnot, "not", false, 1, 1);
1228 basic.DefAlias ("!", "not");
1229 basic.DefSubr (Fadd, "add", true, 1, -1);
1230 basic.DefSubr (Fmul, "mul", true, 1, -1);
1231 basic.DefAlias ("*", "mul");
1232 basic.DefSubr (Fsub, "sub", true, 1, -1);
1233 basic.DefAlias ("-", "sub");
1234 basic.DefSubr (Fdiv, "div", true, 1, -1);
1235 basic.DefAlias ("/", "div");
1236 basic.DefSubr (Fmod, "mod", true, 1, 2);
1237 basic.DefAlias ("%", "mod");
1238 basic.DefSubr (Flogior, "logior", true, 1, -1);
1239 basic.DefAlias ('|', "logior");
1240 basic.DefSubr (Flogand, "logand", true, 1, -1);
1241 basic.DefAlias ("&", "logand");
1242 basic.DefSubr (Flsh, "lsh", true, 1, 2);
1243 basic.DefAlias ("<<", "lsh");
1244 basic.DefSubr (Frsh, "rsh", true, 1, 2);
1245 basic.DefAlias (">>", "rsh");
1246 basic.DefSubr (Feq, "eq", false, 2, -1);
1247 basic.DefAlias ("==", "eq");
1248 basic.DefSubr (Fnoteq, "noteq", false, 2, 2);
1249 basic.DefAlias ("!=", "noteq");
1250 basic.DefSubr (Flt, "lt", false, 2, -1);
1251 basic.DefAlias ("<", "lt");
1252 basic.DefSubr (Fle, "le", false, 2, -1);
1253 basic.DefAlias ("<=", "le");
1254 basic.DefSubr (Fgt, "gt", false, 2, -1);
1255 basic.DefAlias (">", "gt");
1256 basic.DefSubr (Fge, "ge", false, 2, -1);
1257 basic.DefAlias (">=", "ge");
1258 basic.DefSubr (Fthrow, "throw", false, 1, 2);
1260 //basic.DefSubr (Fappend, "append", true, 0, -1);
1261 //basic.DefSubr (Fconcat, "concat", true, 0, -1);
1262 //basic.DefSubr (Fnth, "nth", false, 2, 2);
1263 //basic.DefSubr (Fcopy, "copy", false, 1, 1);
1264 //basic.DefSubr (Fins, "ins", true, 2, 2);
1265 //basic.DefSubr (Fdel, "del", true, 2, 2);
1266 //basic.DefSubr (Feval, "eval", false, 1, 1);
1267 //basic.DefSubr (Fbreak, "break", false, 0, 1);
1268 //basic.DefSubr (Freturn, "return", false, 0, 1);
1269 //basic.DefSubr (Fthrow, "throw", false, 1, 2);
1271 basic.DefSpecial (Fand, "and", false, 1, -1);
1272 basic.DefAlias ("&&", "and");
1273 basic.DefSpecial (For, "or", false, 1, -1);
1274 basic.DefAlias ("||", "or");
1275 basic.DefSpecial (Fprogn, "progn", false, 1, -1);
1276 basic.DefAlias ("expr", "progn");
1277 basic.DefSpecial (Fif, "if", false, 2, 3);
1278 //basic.DefSpecial (Fwhen, "when", false, 1, -1);
1279 //basic.DefSpecial (Floop, "loop", false, 1, -1);
1280 //basic.DefSpecial (Fwhile, "while", false, 1, -1);
1281 basic.DefSpecial (Fcond, "cond", false, 1, -1);
1282 //basic.DefSpecial (Fforeach, "foreach", true, 2, -1);
1283 //basic.DefSpecial (Fquote, "quote", false, 1, 1);
1284 //basic.DefSpecial (Ftype, "type", false, 1, 1);
1285 basic.DefSpecial (Fcatch, "catch", true, 2, -1);
1287 basic.DefType (Xex.Funcall.prototype);
1288 basic.DefType (Xex.Varref.prototype);
1289 basic.DefType (Xex.ErrTerm.prototype);
1290 basic.DefType (Xex.IntTerm.prototype);
1291 basic.DefType (Xex.StrTerm.prototype);
1292 basic.DefType (Xex.SymTerm.prototype);
1293 basic.DefType (Xex.LstTerm.prototype);
1297 Xex.Zero = new Xex.IntTerm (0);
1298 Xex.One = new Xex.IntTerm (1);
1299 Xex.nil = new Xex.SymTerm ('nil');
1301 Xex.Load = function (server, file)
1303 var obj = new XMLHttpRequest ();
1304 var url = server ? server + '/' + file : file;
1305 obj.open ('GET', url, false);
1306 obj.overrideMimeType ('text/xml');
1308 return obj.responseXML.firstChild;