XmlExpr.cs

   1 using System;
   2 using System.Collections;
   3 using System.Collections.Generic;
   4 using System.IO;
   5 using System.Xml;
   6
   7 namespace System.Xml.Expression
   8 {
   9   public class Xexpression
  10   {
  11     public static int debug_level = 0;
  12
  13     public struct Name : IEquatable<Name>
  14     {
  15       private static NameTable nt = new NameTable ();
  16
  17       private string name;
  18
  19       public Name (string str)
  20         {
  21           name = nt.Add (str);
  22         }
  23
  24       public static implicit operator Name (string str)
  25       {
  26         return new Name (str);
  27       }
  28
  29       public static implicit operator string (Name name)
  30       {
  31         return name.name;
  32       }
  33
  34       public static bool operator== (Name n1, Name n2)
  35         {
  36           return (object) n1.name == (object) n2.name;
  37         }
  38
  39       public static bool operator!= (Name n1, Name n2)
  40         {
  41           return (object) n1.name != (object) n2.name;
  42         }
  43
  44       public static bool operator== (Name n1, string n2)
  45         {
  46           return (object) n1.name == (object) n2;
  47         }
  48
  49       public static bool operator!= (Name n1, string n2)
  50         {
  51           return (object) n1.name != (object) n2;
  52         }
  53
  54       public static bool operator== (string n1, Name n2)
  55         {
  56           return (object) n1 == (object) n2.name;
  57         }
  58
  59       public static bool operator!= (string n1, Name n2)
  60         {
  61           return (object) n1 != (object) n2.name;
  62         }
  63
  64       public bool Equals (Name name)
  65       {
  66         return Object.ReferenceEquals (this.name, name.name);
  67       }
  68
  69       public override bool Equals (object obj)
  70       {
  71         return Object.ReferenceEquals (this.name, obj);
  72       }
  73
  74       public override int GetHashCode ()
  75       {
  76         return name.GetHashCode ();
  77       }
  78
  79       public static NameTable Table { get { return nt; } }
  80
  81       public override string ToString () { return name; }
  82     }
  83
  84     private static Name Nexpr = "expr";
  85
  86     private static Name Nfuncall = "funcall";
  87     private static Name Nvariable = "variable";
  88     private static Name Ninteger = "integer";
  89     private static Name Nstring = "string";
  90     private static Name Nsymbol = "symbol";
  91     private static Name Nlist = "list";
  92
  93     private static Name Ndefun = "defun";
  94     private static Name Nfname = "fname";
  95     private static Name Nargs = "args";
  96     private static Name Nargs_unevalled = "args-unevalled";
  97     private static Name Noptional = "optional";
  98     private static Name Nrest = "rest";
  99     private static Name Nbody = "body";
 100
 101     private static Name Ndefvar = "defvar";
 102     private static Name Ndescription = "description";
 103     private static Name Nrange = "range";
 104
 105     private static Name Nprogn = "progn";
 106
 107     internal abstract class Function
 108     {
 109       public Name name;
 110       public int min_arg, max_arg;
 111
 112       public Function () { }
 113
 114       public Function (Name name, int min_arg, int max_arg)
 115       {
 116         this.name = name;
 117         this.min_arg = min_arg;
 118         this.max_arg = max_arg;
 119       }
 120
 121       public abstract Term Call (Domain domain, Term[] args);
 122
 123       public override string ToString ()
 124       {
 125         return name;
 126       }
 127
 128       internal class Subroutine : Function
 129       {
 130         public Builtin builtin;
 131
 132         public Subroutine (Builtin builtin, Name name,
 133                            int min_arg, int max_arg)
 134           : base (name, min_arg, max_arg)
 135           {
 136             this.builtin = builtin;
 137           }
 138
 139         public override Term Call (Domain domain, Term[] args)
 140         {
 141           Term[] newargs = new Term[args.Length];
 142
 143           for (int i = 0; i < args.Length; i++)
 144             newargs[i] = args[i].Eval (domain);
 145           return builtin (domain, newargs);
 146         }
 147       }
 148
 149       internal class SpecialForm : Function
 150       {
 151         public Builtin builtin;
 152
 153         public SpecialForm (Builtin builtin, Name name,
 154                             int min_arg, int max_arg)
 155           : base (name, min_arg, max_arg)
 156           {
 157             this.builtin = builtin;
 158           }
 159
 160         public override Term Call (Domain domain, Term[] args)
 161         {
 162           return builtin (domain, args);
 163         }
 164       }
 165
 166       internal class Lambda : Function
 167       {
 168         internal bool args_evalled;
 169         internal Term[] args;
 170         internal Term[] body;
 171
 172         public Lambda (XmlNode node)
 173         {
 174           int nargs = 0, noptions = 0, nrest = 0;
 175           name = node.Attributes[Nfname].Value;
 176
 177           node = node.FirstChild;
 178           if (node != null
 179               && (node.Name == Nargs || node.Name == Nargs_unevalled))
 180             {
 181               XmlNode n;
 182               args_evalled = node.Name == Nargs;
 183               for (n = node.FirstChild; n != null; n = n.NextSibling)
 184                 {
 185                   if (n.Name != Nsymbol)
 186                     break;
 187                   nargs++;
 188                 }
 189               if (n != null && n.Name == Noptional)
 190                 for (n = n.NextSibling; n != null; n = n.NextSibling)
 191                   {
 192                     if (n.Name == Nrest)
 193                       break;
 194                     noptions++;
 195                   }
 196               if (n != null)
 197                 nrest++;
 198               min_arg = nargs;
 199               max_arg = nargs + noptions + nrest;
 200               args = new Term[max_arg];
 201               n = node.FirstChild;
 202               for (int i = 0; i < max_arg; n = n.NextSibling)
 203                 if (n.Name == Nsymbol)
 204                   args[i++] = new Term (n, null);
 205               if (nrest == 1)
 206                 max_arg = - max_arg;
 207             }
 208           else
 209             {
 210               min_arg = max_arg = 0;
 211             }
 212         }
 213
 214         public void SetBody (XmlNode node, Domain domain)
 215         {
 216
 217           for (node = node.FirstChild; node != null && node.Name != Nbody;
 218                node = node.NextSibling);
 219           if (node != null)
 220             {
 221               XmlNodeList nlist = node.ChildNodes;
 222
 223               body = new Term[nlist.Count];
 224               for (int i = 0; i < nlist.Count; i++)
 225                 body[i] = new Term (nlist[i], domain);
 226             }
 227         }
 228
 229         public override Term Call (Domain domain, Term[] args)
 230         {
 231           Bindings current = domain.bindings;
 232           Term result = Zero;
 233
 234           try {
 235             int i;
 236             if (args_evalled)
 237               {
 238                 Term[] newargs = new Term[args.Length];
 239                 for (i = 0; i < min_arg; i++)
 240                   newargs[i] = args[i].Eval (domain);
 241                 args = newargs;
 242               }
 243             for (i = 0; i < min_arg; i++)
 244               {
 245                 Variable var = domain.GetVar ((Name) this.args[i]);
 246                 domain.Bind (var, args[i]);
 247               }
 248             if (body != null)
 249               foreach (Term term in body)
 250                 result = term.Eval (domain);
 251           } finally {
 252             domain.UnboundTo (current);
 253           }
 254           return result;
 255         }
 256       }
 257     }
 258
 259     internal abstract class Variable
 260     {
 261       public readonly Name name;
 262       internal Term val;
 263
 264       public Variable (Name name, Term term)
 265       {
 266         this.name = name;
 267         Value = term;
 268       }
 269
 270       public Term Value
 271       {
 272         get { return val; }
 273         set
 274           {
 275             if (! ValueP (value))
 276               throw new Exception ("Invalid value of " + name + ": " + value);
 277             val = value;
 278           }
 279       }
 280
 281       public abstract bool ValueP (Term term);
 282
 283       public override string ToString () { return name + "(" + val + ")"; }
 284
 285       internal class Int : Variable
 286       {
 287         public struct Range
 288         {
 289           public int from, to;
 290         }
 291
 292         public Range[] ranges;
 293
 294         public Int (Name name, int i) : base (name, new Term (i)) { }
 295
 296         public override bool ValueP (Term term)
 297         {
 298           int i;
 299
 300           if (term.objval != null)
 301             return false;
 302           if (ranges == null)
 303             return true;
 304           i = term.intval;
 305           foreach (Range r in ranges)
 306             if (i >= r.from && i <= r.to)
 307               return true;
 308           return false;
 309         }
 310       }
 311
 312       internal class Str : Variable
 313       {
 314         public string[] ranges;
 315
 316         public Str (Name name, string str) : base (name, new Term (str)) { }
 317
 318         public override bool ValueP (Term term)
 319         {
 320           if (! (term.objval is string))
 321             return false;
 322           if (ranges == null)
 323             return true;
 324           string str = (string) term.objval;
 325           foreach (string s in ranges)
 326             if (s == str)
 327               return true;
 328           return false;
 329         }
 330       }
 331
 332       internal class Misc : Variable
 333       {
 334         public Misc (Name name, Term term) : base (name, term) { }
 335
 336         public override bool ValueP (Term term) { return true; }
 337       }
 338     }
 339
 340     internal class Bindings
 341     {
 342       private Variable vari;
 343       private Term old_value;
 344       private Bindings next;
 345
 346       private Bindings (Variable vari)
 347       {
 348         this.vari = vari;
 349         old_value = vari.val;
 350       }
 351
 352       public static Bindings Bind (Bindings bindings, Variable vari, Term val)
 353       {
 354         Bindings b = new Bindings (vari);
 355
 356         b.vari.Value = val;
 357         b.next = bindings;
 358         return b;
 359       }
 360
 361       internal Bindings UnboundTo (Bindings boundary)
 362       {
 363         for (Bindings b = this; b != boundary; b = b.next)
 364           b.vari.val = b.old_value;
 365         return boundary;
 366       }
 367
 368       public override string ToString ()
 369       {
 370         string str = "(bindings";
 371         for (Bindings b = this; b != null; b = b.next)
 372           str += " " + vari.name + "=" + b.old_value;
 373         return str + ")";
 374       }
 375     }
 376
 377 #if false
 378     internal class ThrowException : Exception
 379     {
 380       Name tag;
 381       public object value;
 382
 383       public ThrowException (Name tag, object value) : base ()
 384         {
 385           this.tag = tag;
 386           this.value = value;
 387         }
 388     }
 389 #endif
 390
 391     public class Domain
 392     {
 393       public object context;
 394       public int depth = 0;
 395
 396       internal Dictionary<Name, Function> functions;
 397       internal Dictionary<Name, Variable> variables;
 398       internal Bindings bindings;
 399
 400       internal Domain ()
 401       {
 402         functions = new Dictionary<Name, Function> ();
 403         variables = new Dictionary<Name, Variable> ();
 404       }
 405
 406       public Domain (object context) : this (basic, context)
 407       {
 408       }
 409
 410       public Domain (Domain parent, object context)
 411       {
 412         functions = new Dictionary<Name, Function> (parent.functions);
 413         variables = new Dictionary<Name, Variable> (parent.variables);
 414         this.context = context;
 415       }
 416
 417       internal void Bind (Variable vari, Term value)
 418       {
 419         bindings = Bindings.Bind (bindings, vari, value);
 420       }
 421
 422       internal void UnboundTo (Bindings boundary)
 423       {
 424         if (bindings != null)
 425           bindings = bindings.UnboundTo (boundary);
 426       }
 427
 428       public void DefSubr (Builtin builtin, string str,
 429                            int min_arg, int max_arg)
 430       {
 431         Name name = str;
 432         functions[name]
 433           = new Function.Subroutine (builtin, name, min_arg, max_arg);
 434       }
 435
 436       public void DefSpecial (Builtin builtin, string str,
 437                               int min_arg, int max_arg)
 438       {
 439         Name name = str;
 440         functions[name]
 441           = new Function.SpecialForm (builtin, name, min_arg, max_arg);
 442       }
 443
 444       internal Function.Lambda RegisterFunction (XmlNode node)
 445       {
 446         Function.Lambda lambda = new Function.Lambda (node);
 447
 448         functions[lambda.name] = lambda;
 449         return lambda;
 450       }
 451
 452       internal Function Defun (XmlNode node)
 453       {
 454         Name name = node.Attributes[Nfname].Value;
 455         Function func;
 456
 457         if (! functions.TryGetValue (name, out func))
 458           func = RegisterFunction (node);
 459         ((Function.Lambda) func).SetBody (node, this);
 460         return func;
 461       }
 462
 463       public void Defvar (XmlNode node)
 464       {
 465         Name name = node.Attributes[0].Value;
 466         Variable vari;
 467
 468         node = node.FirstChild;
 469         if (node.Name == Ndescription)
 470           node = node.NextSibling;
 471         if (node != null)
 472           {
 473             Name type = node.Name;
 474             XmlNodeList range_list = null;
 475             int nranges = 0;
 476             string val = node.InnerText;
 477
 478             node = node.NextSibling;
 479             if (node != null)
 480               {
 481                 range_list = node.ChildNodes;
 482                 nranges = range_list.Count;
 483               }
 484
 485             if (type == Ninteger)
 486               {
 487                 Variable.Int vi = new Variable.Int (name, parse_integer (val));
 488                 if (range_list != null)
 489                   {
 490                     vi.ranges = new Variable.Int.Range[nranges];
 491
 492                     for (int i = 0; i < nranges; i++)
 493                       {
 494                         XmlNode n = range_list[i];
 495
 496                         if (n.Name == Nrange)
 497                           {
 498                             vi.ranges[i].from =
 499                               parse_integer (n.FirstChild.InnerText);
 500                             vi.ranges[i].to =
 501                               parse_integer (n.LastChild.InnerText);
 502                           }
 503                         else
 504                           {
 505                             int num = parse_integer (n.InnerText);
 506                             vi.ranges[i].from = vi.ranges[i].to = num;
 507                           }
 508                       }
 509                   }
 510                 vari = vi;
 511               }
 512             else if (type == Nstring)
 513               {
 514                 Variable.Str vs = new Variable.Str (name, val);
 515                 if (range_list != null)
 516                   vs.ranges = new string[nranges];
 517                 for (int i = 0; i < nranges; i++)
 518                   vs.ranges[i] = range_list[i].Value;
 519                 vari = vs;
 520               }
 521             else
 522               throw new Exception ("Unknown type: " + type);
 523           }
 524         else
 525           vari = new Variable.Misc (name, Zero);
 526         variables[name] = vari;
 527       }
 528
 529       internal Function GetFunc (Name name)
 530       {
 531         Function func;
 532
 533         if (! functions.TryGetValue (name, out func))
 534           throw new Exception ("Unknown function: " + name);
 535         return func;
 536       }
 537
 538       public bool CopyFunc (Domain domain, Name name)
 539       {
 540         Function func = GetFunc (name);
 541
 542         domain.functions[name] = func;
 543         return true;
 544       }
 545
 546       public void CopyFunc (Domain domain)
 547       {
 548         foreach (KeyValuePair<Name, Function> kv in functions)
 549           domain.functions[kv.Key] = kv.Value;
 550       }
 551
 552       internal Variable GetVar (Name name)
 553       {
 554         Variable vari;
 555
 556         if (! variables.TryGetValue (name, out vari))
 557           variables[name] = vari = new Variable.Misc (name, Zero);
 558         return vari;
 559       }
 560
 561       public override string ToString ()
 562       {
 563         string str = "<(functions";
 564         foreach (KeyValuePair<Name, Function> kv in functions)
 565           str += " " + kv.Key;
 566         str += ") (variabls";
 567         foreach (KeyValuePair<Name, Variable> kv in variables)
 568           str += " " + kv.Key;
 569         str += ")";
 570         if (bindings != null)
 571           str += " " + bindings;
 572         if (context != null)
 573           str += " (" + context + ")";
 574         str += ">";
 575         return str;
 576       }
 577
 578       public void DebugWrite (bool head, string fmt, params string[] arg)
 579       {
 580         if (debug_level > depth)
 581           {
 582             if (head)
 583               {
 584                 Console.WriteLine ();
 585                 for (int i = 0; i < depth; i++)
 586                   Console.Write (" ");
 587               }
 588             Console.Write (fmt, arg);
 589           }
 590       }
 591     }
 592
 593     public delegate Term Builtin (Domain domain, Term[] args);
 594
 595     private static Domain basic = new Domain ();
 596
 597     internal static Function Fprogn;
 598
 599     static Xexpression ()
 600     {
 601       basic.DefSubr (set_value, "set", 2, 2);
 602       basic.DefSubr (set_value, "=", 2, 2);
 603       basic.DefSpecial (and, "and", 1, -1);
 604       basic.DefSpecial (and, "&&", 1, -1);
 605       basic.DefSpecial (or, "or", 1, -1);
 606       basic.DefSpecial (or, "||", 1, -1);
 607       basic.DefSubr (not, "not", 1, 1);
 608       basic.DefSubr (not, "!", 1, 1);
 609       basic.DefSubr (add, "add", 2, -1);
 610       basic.DefSubr (add, "+", 2, -1);
 611       basic.DefSubr (mul, "mul", 2, -1);
 612       basic.DefSubr (mul, "*", 2, -1);
 613       basic.DefSubr (sub, "sub", 1, -1);
 614       basic.DefSubr (sub, "-", 1, -1);
 615       basic.DefSubr (div, "div", 2, -1);
 616       basic.DefSubr (div, "/", 2, -1);
 617       basic.DefSubr (mod, "mod", 2, 2);
 618       basic.DefSubr (mod, "%", 2, 2);
 619       basic.DefSubr (logior, "logior", 2, -1);
 620       basic.DefSubr (logior, "|", 2, -1);
 621       basic.DefSubr (logand, "logand", 2, -1);
 622       basic.DefSubr (logand, "&", 2, -1);
 623       basic.DefSubr (add_set, "add-set", 2, -1);
 624       basic.DefSubr (add_set, "+=", 2, -1);
 625       basic.DefSubr (mul_set, "mul-set", 2, -1);
 626       basic.DefSubr (mul_set, "*=", 2, -1);
 627       basic.DefSubr (sub_set, "sub-set", 2, -1);
 628       basic.DefSubr (sub_set, "-=", 2, -1);
 629       basic.DefSubr (div_set, "div-set", 2, -1);
 630       basic.DefSubr (div_set, "/=", 2, -1);
 631       basic.DefSubr (mod_set, "mod-set", 2, 2);
 632       basic.DefSubr (mod_set, "%=", 2, 2);
 633       basic.DefSubr (logior_set, "logior-set", 2, -1);
 634       basic.DefSubr (logior_set, "|=", 2, -1);
 635       basic.DefSubr (logand_set, "logand-set", 2, -1);
 636       basic.DefSubr (logand_set, "&=", 2, -1);
 637       basic.DefSubr (lsh, "lsh", 2, 2);
 638       basic.DefSubr (lsh, "<<", 2, 2);
 639       basic.DefSubr (rsh, "rsh", 2, 2);
 640       basic.DefSubr (rsh, ">>", 2, 2);
 641       basic.DefSubr (lsh_set, "lsh-set", 2, 2);
 642       basic.DefSubr (lsh_set, "<<=", 2, 2);
 643       basic.DefSubr (rsh_set, "rsh-set", 2, 2);
 644       basic.DefSubr (rsh_set, ">>=", 2, 2);
 645       basic.DefSubr (eq, "eq", 2, -1);
 646       basic.DefSubr (eq, "==", 2, -1);
 647       basic.DefSubr (noteq, "noteq", 2, 2);
 648       basic.DefSubr (noteq, "!=", 2, 2);
 649       basic.DefSubr (less_than, "lt", 2, -1);
 650       basic.DefSubr (less_than, "<", 2, -1);
 651       basic.DefSubr (less_eq, "le", 2, -1);
 652       basic.DefSubr (less_eq, "<=", 2, -1);
 653       basic.DefSubr (greater_than, "gt", 2, -1);
 654       basic.DefSubr (greater_than, ">", 2, -1);
 655       basic.DefSubr (greater_eq, "ge", 2, -1);
 656       basic.DefSubr (greater_eq, ">=", 2, -1);
 657       basic.DefSubr (copy, "copy", 1, 1);
 658       basic.DefSubr (append, "append", 1, -1);
 659       basic.DefSpecial (quote_clause, "quote", 1, 1);
 660       basic.DefSubr (eval_clause, "eval", 1, 1);
 661       basic.DefSpecial (progn_clause, "progn", 0, -1);
 662       basic.DefSpecial (progn_clause, "expr", 0, -1);
 663       basic.DefSpecial (if_clause, "if", 2, -1);
 664       basic.DefSpecial (when_clause, "when", 1, -1);
 665       basic.DefSpecial (while_clause, "while", 1, -1);
 666
 667       Fprogn = basic.GetFunc (Nprogn);
 668     }
 669
 670     private static Term set_value (Domain domain, Term[] args)
 671     {
 672       Variable vari = domain.GetVar ((Name) args[0]);
 673
 674       vari.Value = args[1];
 675       return vari.val;
 676     }
 677
 678     private static Term and (Domain domain, Term[] args)
 679     {
 680       foreach (Term arg in args)
 681         if (! arg.Eval (domain).IsTrue)
 682           return Zero;
 683       return One;
 684     }
 685
 686     private static Term or (Domain domain, Term[] args)
 687     {
 688       foreach (Term arg in args)
 689         if (arg.Eval (domain).IsTrue)
 690           return One;
 691       return Zero;
 692     }
 693
 694     private static Term not (Domain domain, Term[] args)
 695     {
 696       return args[0].IsTrue ? Zero : One;
 697     }
 698
 699     private static Term add (Domain domain, Term[] args)
 700     {
 701       int n = 0;
 702       foreach (Term arg in args)
 703         n += (int) arg;
 704       return n;
 705     }
 706
 707     private static Term mul (Domain domain, Term[] args)
 708     {
 709       int n = 1;
 710       foreach (Term arg in args)
 711         n *= (int) arg;
 712       return n;
 713     }
 714
 715     private static Term sub (Domain domain, Term[] args)
 716     {
 717       int n = (int) args[0];
 718       if (args.Length == 1)
 719         return - n;
 720       for (int i = 1; i < args.Length; i++)
 721         n -= (int) args[i];
 722       return n;
 723     }
 724
 725     private static Term div (Domain domain, Term[] args)
 726     {
 727       int n = (int) args[0];
 728       for (int i = 1; i < args.Length; i++)
 729         n /= (int) args[i];
 730       return n;
 731     }
 732
 733     private static Term mod (Domain domain, Term[] args)
 734     {
 735       return ((int) args[0] % (int) args[1]);
 736     }
 737
 738     private static Term logior (Domain domain, Term[] args)
 739     {
 740       int n = 0;
 741       foreach (Term arg in args)
 742         n |= (int) arg;
 743       return n;
 744     }
 745
 746     private static Term logand (Domain domain, Term[] args)
 747     {
 748       int n = (int) args[0];
 749       for (int i = 1; i < args.Length; i++)
 750         n &= (int) args[i];
 751       return n;
 752     }
 753
 754     private static Term add_set (Domain domain, Term[] args)
 755     {
 756       Variable vari = domain.GetVar ((Name) args[0]);
 757       int n = (int) vari.val;
 758
 759       for (int i = 1; i < args.Length; i++)
 760         n += (int) args[i];
 761       vari.val = n;
 762       return vari.val;
 763     }
 764
 765     private static Term mul_set (Domain domain, Term[] args)
 766     {
 767       Variable vari = domain.GetVar ((Name) args[0]);
 768       int n = (int) vari.val;
 769
 770       for (int i = 1; i < args.Length; i++)
 771         n *= (int) args[i];
 772       vari.val = n;
 773       return vari.val;
 774     }
 775
 776     private static Term sub_set (Domain domain, Term[] args)
 777     {
 778       Variable vari = domain.GetVar ((Name) args[0]);
 779       int n = (int) vari.val;
 780
 781       for (int i = 1; i < args.Length; i++)
 782         n -= (int) args[i];
 783       vari.val = n;
 784       return vari.val;
 785     }
 786
 787     private static Term div_set (Domain domain, Term[] args)
 788     {
 789       Variable vari = domain.GetVar ((Name) args[0]);
 790       int n = (int) vari.val;
 791
 792       for (int i = 1; i < args.Length; i++)
 793         n /= (int) args[i];
 794       vari.val = n;
 795       return vari.val;
 796     }
 797
 798     private static Term mod_set (Domain domain, Term[] args)
 799     {
 800       Variable vari = domain.GetVar ((Name) args[0]);
 801       int n = (int) vari.val;
 802
 803       for (int i = 1; i < args.Length; i++)
 804         n %= (int) args[i];
 805       vari.val = n;
 806       return vari.val;
 807     }
 808
 809     private static Term logior_set (Domain domain, Term[] args)
 810     {
 811       Variable vari = domain.GetVar ((Name) args[0]);
 812       int n = (int) vari.val;
 813
 814       for (int i = 1; i < args.Length; i++)
 815         n |= (int) args[i];
 816       vari.val = n;
 817       return vari.val;
 818     }
 819
 820     private static Term logand_set (Domain domain, Term[] args)
 821     {
 822       Variable vari = domain.GetVar ((Name) args[0]);
 823       int n = (int) vari.val;
 824
 825       for (int i = 1; i < args.Length; i++)
 826         n &= (int) args[i];
 827       vari.val = n;
 828       return vari.val;
 829     }
 830
 831     private static Term lsh (Domain domain, Term[] args)
 832     {
 833       return (int) args[0] << (int) args[1];
 834     }
 835
 836     private static Term lsh_set (Domain domain, Term[] args)
 837     {
 838       Variable vari = domain.GetVar ((Name) args[0]);
 839       int n = (int) vari.val;
 840
 841       n <<= (int) args[1];
 842       vari.val = n;
 843       return vari.val;
 844     }
 845
 846     private static Term rsh (Domain domain, Term[] args)
 847     {
 848       return (int) args[0] >> (int) args[1];
 849     }
 850
 851     private static Term rsh_set (Domain domain, Term[] args)
 852     {
 853       Variable vari = domain.GetVar ((Name) args[0]);
 854       int n = (int) vari.val;
 855
 856       n >>= (int) args[1];
 857       vari.val = n;
 858       return vari.val;
 859     }
 860
 861     private static Term eq (Domain domain, Term[] args)
 862     {
 863       Term o = args[0];
 864
 865       if (o.objval == null)
 866         {
 867           for (int i = 1; i < args.Length; i++)
 868             if (args[i].objval != null || args[i].intval != o.intval)
 869               return Zero;
 870         }
 871       else
 872         {
 873           for (int i = 1; i < args.Length; i++)
 874             if (o.objval.Equals (args[i].objval))
 875               return Zero;
 876         }
 877       return One;
 878     }
 879
 880     private static Term noteq (Domain domain, Term[] args)
 881     {
 882       return eq (domain, args);
 883     }
 884
 885     private static Term less_than (Domain domain, Term[] args)
 886     {
 887       int n = (int) args[0];
 888
 889       for (int i = 1; i < args.Length; i++)
 890         {
 891           int n1 = (int) args[i];
 892           if (n >= n1)
 893             return Zero;
 894           n = n1;
 895         }
 896       return One;
 897     }
 898
 899     private static Term less_eq (Domain domain, Term[] args)
 900     {
 901       int n = (int) args[0];
 902       for (int i = 1; i < args.Length; i++)
 903         {
 904           int n1 = (int) args[i];
 905           if (n > n1)
 906             return Zero;
 907           n = n1;
 908         }
 909       return One;
 910     }
 911
 912     private static Term greater_than (Domain domain, Term[] args)
 913     {
 914       int n = (int) args[0];
 915       for (int i = 1; i < args.Length; i++)
 916         {
 917           int n1 = (int) args[i];
 918           if (n <= n1)
 919             return Zero;
 920           n = n1;
 921         }
 922       return One;
 923     }
 924
 925     private static Term greater_eq (Domain domain, Term[] args)
 926     {
 927       int n = (int) args[0];
 928       for (int i = 1; i < args.Length; i++)
 929         {
 930           int n1 = (int) args[i];
 931           if (n < n1)
 932             return Zero;
 933           n = n1;
 934         }
 935       return One;
 936     }
 937
 938     private static Term copy (Domain domain, Term[] args)
 939     {
 940       object obj = args[0].objval;
 941
 942       if (! (obj is List<Term>))
 943         throw new Exception ("Invalid arg to copy: " + args[0]);
 944       return new Term (new List<Term> ((List<Term>) obj));
 945     }
 946
 947     private static Term append (Domain domain, Term[] args)
 948     {
 949       object obj = args[0].objval;
 950       if (obj is string)
 951         {
 952           string str = "";
 953           foreach (Term arg in args)
 954             str += arg;
 955           return new Term (str);
 956         }
 957       else if (obj is List<Term>)
 958         {
 959           List<Term> list = new List<Term> ();
 960           foreach (Term arg in args)
 961             list.AddRange ((List<Term>) arg.objval);
 962           return new Term (list);
 963         }
 964       throw new Exception ("Invalid term to append: " + obj);
 965     }
 966
 967     private static Term quote_clause (Domain domain, Term[] args)
 968     {
 969       return new Term (args[0]);
 970     }
 971
 972     private static Term eval_clause (Domain domain, Term[] args)
 973     {
 974       return (args[0].Eval (domain));
 975     }
 976
 977     private static Term progn_clause (Domain domain, Term[] args)
 978     {
 979       Term result = One;
 980
 981       foreach (Term arg in args)
 982         result = arg.Eval (domain);
 983       return result;
 984     }
 985
 986     private static Term if_clause (Domain domain, Term[] args)
 987     {
 988       if (args[0].Eval (domain).IsTrue)
 989         return args[1].Eval (domain);
 990
 991       Term result = Zero;
 992       for (int i = 2; i < args.Length; i++)
 993         result = args[i].Eval (domain);
 994       return result;
 995     }
 996
 997     private static Term when_clause (Domain domain, Term[] args)
 998     {
 999       if (! args[0].Eval (domain).IsTrue)
1000         return Zero;
1001
1002       Term result = One;
1003       for (int i = 1; i < args.Length; i++)
1004         result = args[i].Eval (domain);
1005       return result;
1006     }
1007
1008     private static Term while_clause (Domain domain, Term[] args)
1009     {
1010       while (args[0].Eval (domain).IsTrue)
1011         for (int i = 1; i < args.Length; i++)
1012           args[i].Eval (domain);
1013       return Zero;
1014     }
1015
1016     public struct Term
1017     {
1018       public int intval;
1019       public object objval;
1020
1021       public Term (int i) { intval = i; objval = null; }
1022       public Term (Name name) { intval = 0; objval = name; }
1023       public Term (string str) { intval = 0; objval = str; }
1024       public Term (List<Term> list) { intval = 0; objval = list; }
1025       public Term (Term term) { intval = 0; objval = term; }
1026
1027       public Term (XmlNode node, Domain domain)
1028         {
1029           Name name = node.Name;
1030
1031           if (name == Ninteger)
1032             {
1033               intval = parse_integer (node.InnerText);
1034               objval = null;
1035             }
1036           else
1037             {
1038               intval = 0;
1039               if (name == Nsymbol)
1040                 objval = (Name) node.InnerText;
1041               else if (name == Nstring)
1042                 objval = node.InnerText.Clone ();
1043               else if (name == Nvariable)
1044                 objval = domain.GetVar ((Name) node.Attributes[0].Value);
1045               else if (name == Nlist)
1046                 {
1047                   List<Term> list = new List<Term> ();
1048                   for (node = node.FirstChild; node != null;
1049                        node = node.NextSibling)
1050                     list.Add (new Term (node, domain));
1051                   objval = list;
1052                 }
1053               else
1054                 {
1055                   if (name == Nfuncall)
1056                     name = node.Attributes[0].Value;
1057
1058                   Function func = domain.GetFunc (name);
1059                   XmlNodeList nlist = node.ChildNodes;
1060                   int nargs = nlist.Count;
1061
1062                   if (nargs < func.min_arg
1063                       || (func.max_arg >= 0 && nargs > func.max_arg))
1064                     throw new Exception ("Invalid number of arguments to: "
1065                                          + name + " " + nargs);
1066                   Term[] args = new Term[nargs];
1067                   for (int i = 0; i < nlist.Count; i++)
1068                     args[i] = new Term (nlist[i], domain);
1069                   objval = new Funcall (func, args);
1070                 }
1071             }
1072         }
1073
1074       private class Funcall
1075       {
1076         internal Function func;
1077         internal Term[] args;
1078
1079         public Funcall (Function func, Term[] args)
1080         {
1081           this.func = func;
1082           this.args = args;
1083         }
1084
1085         public Term Eval (Domain domain)
1086         {
1087           domain.DebugWrite (true, "(({0}", func.name);
1088           for (int i = 0; i < args.Length; i++)
1089             domain.DebugWrite (false, " {0}", args[i].ToString ());
1090           domain.DebugWrite (false, ")");
1091           domain.depth++;
1092           Term result = func.Call (domain, args);
1093           domain.depth--;
1094           domain.DebugWrite (true, " ==> {0})", result.ToString ());
1095           return result;
1096         }
1097
1098         public override string ToString ()
1099         {
1100           string str = "<funcall fname=\"" + func.name;
1101           if (args == null)
1102             return str + "\"/>";
1103           str += "\">";
1104           foreach (Term e in args)
1105             str += e;
1106           return (str + "</funcall>");
1107         }
1108       }
1109
1110       public bool IsTrue {
1111         get {
1112           return (objval == null
1113                   ? (intval != 0)
1114                   : objval is List<Term>
1115                   ? (((List<Term>) objval).Count != 0)
1116                   : true);
1117         }
1118       }
1119
1120       public Term Eval (Domain domain)
1121       {
1122         if (objval == null || objval is Name || objval is string)
1123           return this;
1124         if (objval is List<Term>)
1125           return new Term ((List<Term>) objval);
1126         if (objval is Funcall)
1127           return ((Funcall) objval).Eval (domain);
1128         if (objval is Variable)
1129           return ((Variable) objval).val;
1130         if (objval is Term)
1131           return (Term) objval;
1132         throw new Exception ("invalid Term object: " + objval);
1133       }
1134
1135       public static explicit operator int (Term term)
1136       {
1137         if (term.objval != null)
1138           throw new Exception ("Not an integer term: " + term);
1139         return term.intval;
1140       }
1141
1142       public static explicit operator Name (Term term)
1143       {
1144         return (Name) term.objval;
1145       }
1146
1147       public static implicit operator Term (int i)
1148       {
1149         return new Term (i);
1150       }
1151
1152       public override string ToString ()
1153       {
1154         string str;
1155
1156         if (objval == null)
1157           str = "<integer>" + intval + "</integer>";
1158         else if (objval is Name)
1159           str = "<symbol>" + objval + "</symbol>";
1160         else if (objval is string)
1161           str = "<string>" + objval + "</string>";
1162         else if (objval is List<Term>)
1163           {
1164             str = "<list>";
1165             foreach (Term e in (List<Term>) objval)
1166               str += e;
1167             str += "</list>";
1168           }
1169         else if (objval is Funcall)
1170           str = "<funcall fname=\"" + ((Funcall) objval).func.name + "\"/>";
1171         else if (objval is Variable)
1172           str = "<variable vname=\"" + ((Variable) objval).name + "\"/>";
1173         else if (objval is Term)
1174           str = "<quote>" + objval + "</quote>";
1175         else
1176           throw new Exception ("invalid Term object: " + objval);
1177         return str;
1178       }
1179     }
1180
1181     static Term Zero = new Term (0);
1182     static Term One = new Term (1);
1183
1184     internal static int parse_integer (string str)
1185     {
1186       int len = str.Length;
1187       bool negative = false;
1188
1189       if (len <= 1)
1190         return (len == 0 ? 0 : str[0] - '0');
1191
1192       int c = str[0];
1193       int i;
1194
1195       if (c == '0' && str[1] == 'x')
1196         {
1197           i = 0;
1198           for (int idx = 2; idx < len; idx++)
1199             {
1200               c = str[idx];
1201               if (c < '0')
1202                 break;
1203               else if (c <= '9')
1204                 i = i * 16 + (c - '0');
1205               else if (c < 'A')
1206                 break;
1207               else if (c <= 'F')
1208                 i = i * 16 + (c - 'A');
1209               else if (c < 'a')
1210                 break;
1211               else if (c <= 'f')
1212                 i = i * 16 + (c - 'a');
1213               else
1214                 break;
1215             }
1216           return i;
1217         }
1218       if (c == '-')
1219         negative = true;
1220       i = c - '0';
1221       for (int idx = 1; idx < len; idx++)
1222         {
1223           c = str[idx];
1224           if (c < '0' || c > '9')
1225             break;
1226           i = i * 10 + (c - '0');
1227         }
1228       return negative ? - i : i;
1229     }
1230
1231     private Term[] terms;
1232
1233     public Xexpression (string url, Domain domain)
1234     {
1235       XmlDocument doc = new XmlDocument (Name.Table);
1236       XmlNode node;
1237
1238       using (XmlTextReader reader = new XmlTextReader (url, Name.Table))
1239         {
1240           do {
1241             reader.Read ();
1242           } while (reader.NodeType != XmlNodeType.None
1243                    && (reader.NodeType != XmlNodeType.Element
1244                        || reader.Name != Nexpr));
1245           if (reader.NodeType == XmlNodeType.None)
1246             throw new Exception ("Node <expr> not found");
1247           node = doc.ReadNode (reader);
1248         }
1249
1250       int nterms = 0;
1251       for (XmlNode n = node.FirstChild; n != null; n = n.NextSibling)
1252         if (n.NodeType == XmlNodeType.Element)
1253           {
1254             if (n.Name == Ndefun)
1255               domain.RegisterFunction (n);
1256             else if (n.Name == Ndefvar)
1257               domain.Defvar (n);
1258             else
1259               nterms++;
1260           }
1261
1262       terms = new Term[nterms];
1263       int i = 0;
1264       for (XmlNode n = node.FirstChild; n != null; n = n.NextSibling)
1265         if (n.NodeType == XmlNodeType.Element)
1266           {
1267             if (n.Name == Ndefun)
1268               domain.Defun (n);
1269             else if (n.Name != Ndefvar)
1270               {
1271                 terms[i]= new Term (n, domain);
1272                 Console.WriteLine ("term="+terms[i]);
1273               }
1274           }
1275     }
1276
1277     public Term Eval (Domain domain)
1278     {
1279       Term result = Zero;
1280
1281       domain.depth = 0;
1282       for (int i = 0; i < terms.Length; i++)
1283         Console.WriteLine (terms[i]);
1284
1285       foreach (Term term in terms)
1286         {
1287           Console.WriteLine (term);
1288           result = term.Eval (domain);
1289           Console.WriteLine ("=>" + result);
1290         }
1291       return result;
1292     }
1293   }
1294 }