MExpression.cs

   1 using System;
   2 using System.Collections;
   3 using System.Collections.Generic;
   4 using System.IO;
   5 using M17N;
   6 using M17N.Core;
   7
   8 namespace M17N.Core
   9 {
  10   public class MExpression
  11   {
  12     public delegate object Evaluator (object[] args, MPlist bindings);
  13
  14     internal delegate void PrettyPrinter (Function func,
  15                                           string indent, object[] args);
  16
  17     internal class Function
  18     {
  19       internal readonly MSymbol name;
  20       internal readonly Evaluator eval;
  21       internal readonly int min_arg;
  22       internal readonly int max_arg;
  23       internal readonly Type[] arg_types;
  24       internal object[] data;
  25
  26       public PrettyPrinter pp;
  27
  28       private static PrettyPrinter default_pretty_printer;
  29       private static PrettyPrinter set_pretty_printer;
  30       internal static Function literal, varref, block, defun;
  31
  32       public Function (MSymbol name, Evaluator eval,
  33                        int min_arg, int max_arg, params Type[] arg_types)
  34       {
  35         this.name = name;
  36         this.eval = eval;
  37         this.min_arg = min_arg;
  38         this.max_arg = max_arg;
  39         this.arg_types = (Type []) arg_types.Clone ();
  40         if (arg_types.Length == 2 && arg_types[0] == typeof (MSymbol))
  41           pp = set_pretty_printer;
  42         else
  43           pp = default_pretty_printer;
  44       }
  45
  46       static Function ()
  47       {
  48         default_pretty_printer = new PrettyPrinter (default_pp);
  49         set_pretty_printer = new PrettyPrinter (set_pp);
  50         literal = Defun ("nil", null, 1, 1);
  51         varref = Defun ("symbol", new Evaluator (get_value), 1, 1);
  52         block = Defun ("plist", new Evaluator (progn), 1, -1);
  53
  54         Defun ("set", new Evaluator (set_value), 2, 2,
  55                typeof (MSymbol), typeof (MExpression));
  56         Defun ("=", new Evaluator (set_value), 2, 2,
  57                typeof (MSymbol), typeof (MExpression));
  58         Defun ("+", new Evaluator (plus), 1, -1);
  59         Defun ("*", new Evaluator (multi), 2, -1);
  60         Defun ("-", new Evaluator (minus), 1, -1);
  61         Defun ("/", new Evaluator (divide), 2, -1);
  62         Defun ("%", new Evaluator (percent), 2, -1);
  63         Defun ("|", new Evaluator (logior), 2, -1);
  64         Defun ("&", new Evaluator (logand), 2, -1);
  65         Defun ("+=", new Evaluator (pluseq), 2, -1,
  66                typeof (MSymbol), typeof (MExpression));
  67         Defun ("*=", new Evaluator (multieq), 2, -1,
  68                typeof (MSymbol), typeof (MExpression));
  69         Defun ("-=", new Evaluator (minuseq), 2, -1,
  70                typeof (MSymbol), typeof (MExpression));
  71         Defun ("/=", new Evaluator (divideeq), 2, -1,
  72                typeof (MSymbol), typeof (MExpression));
  73         Defun ("%=", new Evaluator (percenteq), 2, -1,
  74                typeof (MSymbol), typeof (MExpression));
  75         Defun ("|=", new Evaluator (logioreq), 2, -1,
  76                typeof (MSymbol), typeof (MExpression));
  77         Defun ("&=", new Evaluator (logandeq), 2, -1,
  78                typeof (MSymbol), typeof (MExpression));
  79         Defun ("<<", new Evaluator (lshift), 2, 2);
  80         Defun (">>", new Evaluator (rshift), 2, 2);
  81         Defun ("<<=", new Evaluator (lshifteq), 2, 2,
  82                typeof (MSymbol), typeof (MExpression));
  83         Defun (">>=", new Evaluator (rshifteq), 2, 2,
  84                typeof (MSymbol), typeof (MExpression));
  85         Defun ("==", new Evaluator (eq), 2, -1);
  86         Defun ("!=", new Evaluator (noteq), 2, 2);
  87         Defun ("<", new Evaluator (less), 2, -1);
  88         Defun ("<=", new Evaluator (lesseq), 2, -1);
  89         Defun (">", new Evaluator (more), 2, -1);
  90         Defun (">=", new Evaluator (moreeq), 2, -1);
  91         block = Defun ("progn", new Evaluator (progn), 1, -1);
  92         block.pp = new PrettyPrinter (block_pp);
  93         Defun ("cond", new Evaluator (cond), 1, -1,
  94                typeof (MExpression[])).pp = new PrettyPrinter (cond_pp);
  95         Defun ("if", new Evaluator (ifclause), 2, -1,
  96                typeof (MExpression)).pp = new PrettyPrinter (if_pp);
  97         Defun ("while", new Evaluator (whileclause), 1, -1,
  98                typeof (MExpression)).pp = new PrettyPrinter (while_pp);
  99         defun = Defun ("defun", new Evaluator (define_function), 4, -1,
 100                        typeof (FunctionTable),
 101                        typeof (MSymbol),
 102                        typeof (MPlist),
 103                        typeof (MExpression));
 104         defun.pp = new PrettyPrinter (defun_pp);
 105       }
 106
 107       private static MPlist find_binding (object[] args, MPlist bindings)
 108       {
 109         MSymbol var = (MSymbol) args[0];
 110         MPlist slot = bindings.Find (var);
 111
 112         if (slot == null)
 113           throw new Exception ("Unbound variable: " + var);
 114         return slot;
 115       }
 116
 117       public object Call (object[] args, MPlist bindings)
 118       {
 119         if (name == MSymbol.nil)
 120           return args[0];
 121         if (eval != null)
 122           return eval (args, bindings);
 123
 124         MPlist arg_symbols = (MPlist) data[0];
 125         for (int i = 0; i < args.Length; i++, arg_symbols = arg_symbols.next)
 126           bindings = bindings.Cons (arg_symbols.Symbol,
 127                                     ((MExpression) args[i]).Eval (bindings));
 128         object result = 0;
 129         for (int i = 1; i < data.Length; i++)
 130           result = ((MExpression) data[i]).Eval (bindings);
 131         return result;
 132       }
 133
 134       // Commonly used pretty-printers.
 135
 136       public static void default_pp (Function func,
 137                                      string indent, object[] args)
 138       {
 139         Console.Write ("(" + func.name);
 140         indent += "  ";
 141         foreach (object o in args)
 142           {
 143             Console.Write (" ");
 144             if (o is MExpression)
 145               ((MExpression) o).pp (indent);
 146             else
 147               Console.Write (o);
 148           }
 149         Console.Write (")");
 150       }
 151
 152       private static void set_pp (Function func, string indent, object[] args)
 153       {
 154         Console.Write ("(" + func.name + " " + (MSymbol) args[0] + " ");
 155         ((MExpression) args[1]).pp (indent);
 156         Console.Write (")");
 157       }
 158
 159       private static object get_value (object[] args, MPlist bindings)
 160       {
 161         return find_binding (args, bindings).val;
 162       }
 163
 164       private static object set_value (object[] args, MPlist bindings)
 165       {
 166         MSymbol var = (MSymbol) args[0];
 167         MPlist slot = bindings.Find (var);
 168
 169         if (slot == null)
 170           slot = bindings.Push (var, null);
 171         slot.val = ((MExpression) args[1]).Eval (bindings);
 172         if (slot.val is MText)
 173           slot.val = ((MText) slot.val).Dup ();
 174         return slot.val;
 175       }
 176
 177       private static object plus (object[] args, MPlist bindings)
 178       {
 179         object val = ((MExpression) args[0]).Eval (bindings);
 180
 181         if (val is int)
 182           {
 183             int n = 0;
 184             foreach (MExpression e in args)
 185               n += (int) e.Eval (bindings);
 186             val = n;
 187           }
 188         else if (val is MText)
 189           {
 190             MText mt = new MText ();
 191             foreach (MExpression e in args)
 192               mt += (MText) e.Eval (bindings);
 193             val = mt;
 194           }
 195         return val;
 196       }
 197
 198       private static object multi (object[] args, MPlist bindings)
 199       {
 200         int n = 1;
 201         foreach (MExpression e in args)
 202           n *= (int) e.Eval (bindings);
 203         return n;
 204       }
 205
 206       private static object minus (object[] args, MPlist bindings)
 207       {
 208         int n = (int) ((MExpression) args[0]).Eval (bindings);
 209         if (args.Length == 1)
 210           return - n;
 211         for (int i = 1; i < args.Length; i++)
 212           n -= (int) ((MExpression) args[i]).Eval (bindings);
 213         return n;
 214       }
 215
 216       private static object divide (object[] args, MPlist bindings)
 217       {
 218         int n = (int) ((MExpression) args[0]).Eval (bindings);
 219         for (int i = 1; i < args.Length; i++)
 220           n /= (int) ((MExpression) args[i]).Eval (bindings);
 221         return n;
 222       }
 223
 224       private static object percent (object[] args, MPlist bindings)
 225       {
 226         int n = (int) ((MExpression) args[0]).Eval (bindings);
 227         for (int i = 1; i < args.Length; i++)
 228           n %= (int) ((MExpression) args[i]).Eval (bindings);
 229         return n;
 230       }
 231
 232       private static object logior (object[] args, MPlist bindings)
 233       {
 234         int n = (int) ((MExpression) args[0]).Eval (bindings);
 235         for (int i = 1; i < args.Length; i++)
 236           n |= (int) ((MExpression) args[i]).Eval (bindings);
 237         return n;
 238       }
 239
 240       private static object logand (object[] args, MPlist bindings)
 241       {
 242         int n = (int) ((MExpression) args[0]).Eval (bindings);
 243         for (int i = 1; i < args.Length; i++)
 244           n &= (int) ((MExpression) args[i]).Eval (bindings);
 245         return n;
 246       }
 247
 248       private static object pluseq (object[] args, MPlist bindings)
 249       {
 250         MPlist slot = find_binding (args, bindings);
 251         object val = slot.val;
 252
 253         if (val is int)
 254           {
 255             int n = (int) val;
 256             for (int i = 1; i < args.Length; i++)
 257               n += (int) ((MExpression) args[i]).Eval (bindings);
 258             slot.val = n;
 259           }
 260         else if (val is MText)
 261           {
 262             MText mt = (MText) val;
 263             for (int i = 1; i < args.Length; i++)
 264               mt.Cat ((MText) ((MExpression) args[i]).Eval (bindings));
 265           }
 266         return slot.val;
 267       }
 268
 269       private static object multieq (object[] args, MPlist bindings)
 270       {
 271         MPlist slot = find_binding (args, bindings);
 272         int n = (int) slot.val;
 273         for (int i = 1; i < args.Length; i++)
 274           n *= (int) ((MExpression) args[i]).Eval (bindings);
 275         return (slot.val = n);
 276       }
 277
 278       private static object minuseq (object[] args, MPlist bindings)
 279       {
 280         MPlist slot = find_binding (args, bindings);
 281         int n = (int) slot.val;
 282         for (int i = 1; i < args.Length; i++)
 283           n -= (int) ((MExpression) args[i]).Eval (bindings);
 284         return (slot.val = n);
 285       }
 286
 287       private static object divideeq (object[] args, MPlist bindings)
 288       {
 289         MPlist slot = find_binding (args, bindings);
 290         int n = (int) slot.val;
 291         for (int i = 1; i < args.Length; i++)
 292           n /= (int) ((MExpression) args[i]).Eval (bindings);
 293         return (slot.val = n);
 294       }
 295
 296       private static object percenteq (object[] args, MPlist bindings)
 297       {
 298         MPlist slot = find_binding (args, bindings);
 299         int n = (int) slot.val;
 300         for (int i = 1; i < args.Length; i++)
 301           n %= (int) ((MExpression) args[i]).Eval (bindings);
 302         return (slot.val = n);
 303       }
 304
 305       private static object logioreq (object[] args, MPlist bindings)
 306       {
 307         MPlist slot = find_binding (args, bindings);
 308         int n = (int) slot.val;
 309         for (int i = 1; i < args.Length; i++)
 310           n |= (int) ((MExpression) args[i]).Eval (bindings);
 311         return (slot.val = n);
 312       }
 313
 314       private static object logandeq (object[] args, MPlist bindings)
 315       {
 316         MPlist slot = find_binding (args, bindings);
 317         int n = (int) slot.val;
 318         for (int i = 1; i < args.Length; i++)
 319           n &= (int) ((MExpression) args[i]).Eval (bindings);
 320         return (slot.val = n);
 321       }
 322
 323       private static object lshift (object[] args, MPlist bindings)
 324       {
 325         int n1 = (int) ((MExpression) args[0]).Eval (bindings);
 326         int n2 = (int) ((MExpression) args[1]).Eval (bindings);
 327         return n1 << n2;
 328       }
 329
 330       private static object lshifteq (object[] args, MPlist bindings)
 331       {
 332         MPlist slot = find_binding (args, bindings);
 333         int n1 = (int) slot.val;
 334         int n2 = (int) ((MExpression) args[1]).Eval (bindings);
 335         return (slot.val = (n1 << n2));
 336       }
 337
 338       private static object rshift (object[] args, MPlist bindings)
 339       {
 340         int n1 = (int) ((MExpression) args[0]).Eval (bindings);
 341         int n2 = (int) ((MExpression) args[1]).Eval (bindings);
 342         return n1 >> n2;
 343       }
 344
 345       private static object rshifteq (object[] args, MPlist bindings)
 346       {
 347         MPlist slot = find_binding (args, bindings);
 348         int n1 = (int) slot.val;
 349         int n2 = (int) ((MExpression) args[1]).Eval (bindings);
 350         return (slot.val = (n1 >> n2));
 351       }
 352
 353       private static object eq (object[] args, MPlist bindings)
 354       {
 355         int n = (int) ((MExpression) args[0]).Eval (bindings);
 356         for (int i = 1; i < args.Length; i++)
 357           if (n != (int) ((MExpression) args[i]).Eval (bindings))
 358             return 0;
 359         return 1;
 360       }
 361
 362       private static object noteq (object[] args, MPlist bindings)
 363       {
 364         int n1 = (int) ((MExpression) args[0]).Eval (bindings);
 365         int n2 = (int) ((MExpression) args[1]).Eval (bindings);
 366         return (n1 != n2);
 367       }
 368
 369       private static object less (object[] args, MPlist bindings)
 370       {
 371         int n = (int) ((MExpression) args[0]).Eval (bindings);
 372         for (int i = 1; i < args.Length; i++)
 373           {
 374             int n1 = (int) ((MExpression) args[i]).Eval (bindings);
 375             if (n >= n1)
 376               return 0;
 377             n = n1;
 378           }
 379         return 1;
 380       }
 381
 382       private static object lesseq (object[] args, MPlist bindings)
 383       {
 384         int n = (int) ((MExpression) args[0]).Eval (bindings);
 385         for (int i = 1; i < args.Length; i++)
 386           {
 387             int n1 = (int) ((MExpression) args[i]).Eval (bindings);
 388             if (n > n1)
 389               return 0;
 390             n = n1;
 391           }
 392         return 1;
 393       }
 394
 395       private static object more (object[] args, MPlist bindings)
 396       {
 397         int n = (int) ((MExpression) args[0]).Eval (bindings);
 398         for (int i = 1; i < args.Length; i++)
 399           {
 400             int n1 = (int) ((MExpression) args[i]).Eval (bindings);
 401             if (n <= n1)
 402               return 0;
 403             n = n1;
 404           }
 405         return 1;
 406       }
 407
 408       private static object moreeq (object[] args, MPlist bindings)
 409       {
 410         int n = (int) ((MExpression) args[0]).Eval (bindings);
 411         for (int i = 1; i < args.Length; i++)
 412           {
 413             int n1 = (int) ((MExpression) args[i]).Eval (bindings);
 414             if (n < n1)
 415               return 0;
 416             n = n1;
 417           }
 418         return 1;
 419       }
 420
 421       private static object progn (object[] args, MPlist bindings)
 422       {
 423         object result = null;
 424
 425         foreach (MExpression e in args)
 426           result = e.Eval (bindings);
 427         return result;
 428       }
 429
 430       private static void block_pp (Function func,
 431                                     string indent, object[] args)
 432       {
 433         bool first = true;
 434
 435         Console.Write ("(");
 436         indent += " ";
 437         foreach (MExpression e in args)
 438           {
 439             if (first)
 440               first = false;
 441             else
 442               Console.Write ("\n" + indent);
 443             e.pp (indent);
 444           }
 445         Console.Write (")");
 446       }
 447
 448       private static bool check_condition (MExpression e, MPlist bindings)
 449       {
 450         object result = e.Eval (bindings);
 451         return (! (result is int) || (int) result != 0);
 452       }
 453
 454       private static object cond (object[] args, MPlist bindings)
 455       {
 456         foreach (MExpression[] elist in args)
 457           if (check_condition (elist[0], bindings))
 458             {
 459               object result = 0;
 460               for (int i = 1; i < elist.Length; i++)
 461                 result = elist[i].Eval (bindings);
 462               return result;
 463             }
 464         return 0;
 465       }
 466
 467       private static void cond_pp (Function func,
 468                                    string indent, object[] args)
 469       {
 470         Console.Write ("(cond");
 471         indent += "  ";
 472         foreach (MExpression[] expr_list in args)
 473           {
 474             Console.Write ("\n" + indent + "(");
 475             bool first = true;
 476             foreach (MExpression e in expr_list)
 477               {
 478                 if (first)
 479                   first = false;
 480                 else
 481                   Console.Write (" ");
 482                 e.pp (indent);
 483               }
 484             Console.Write (")");
 485           }
 486         Console.Write (")");
 487       }
 488
 489       private static object ifclause (object[] args, MPlist bindings)
 490       {
 491         object result = 0;
 492
 493         if (check_condition ((MExpression) args[0], bindings))
 494           result = ((MExpression) args[1]).Eval (bindings);
 495         else
 496           for (int i = 2; i < args.Length; i++)
 497             result = ((MExpression) args[i]).Eval (bindings);
 498         return result;
 499       }
 500
 501       private static void if_pp (Function func,
 502                                  string indent, object[] args)
 503       {
 504         Console.Write ("(if ");
 505         ((MExpression) args[0]).pp (indent + "    ");
 506         Console.Write ("\n" + indent + "    ");
 507         ((MExpression) args[1]).pp (indent + "    ");
 508         indent += "  ";
 509         for (int i = 2; i < args.Length; i++)
 510           {
 511             Console.Write ("\n" + indent);
 512             ((MExpression) args[i]).pp (indent);
 513           }
 514         Console.Write (")");
 515       }
 516
 517       private static object whileclause (object[] args, MPlist bindings)
 518       {
 519         object result = 0;
 520
 521         while (check_condition ((MExpression) args[0], bindings))
 522           for (int i = 1; i < args.Length; i++)
 523             result = ((MExpression) args[i]).Eval (bindings);
 524         return result;
 525       }
 526
 527       private static void while_pp (Function func,
 528                                     string indent, object[] args)
 529       {
 530         Console.Write ("(while ");
 531         ((MExpression) args[0]).pp (indent + "       ");
 532         bool first = true;
 533         indent += "  ";
 534         for (int i = 1; i < args.Length; i++)
 535           {
 536             if (first)
 537               {
 538                 Console.Write ("\n" + indent);
 539                 first = false;
 540               }
 541             else
 542               Console.Write (" ");
 543             ((MExpression) args[i]).pp (indent);
 544           }
 545         Console.Write (")");
 546       }
 547
 548       public static object define_function (object[] args, MPlist bindings)
 549       {
 550         FunctionTable table = (FunctionTable) args[0];
 551         MSymbol sym = (MSymbol) args[1];
 552         MPlist arg_symbols = (MPlist) args[2];
 553         int nargs = arg_symbols.Count;
 554         object[] data = new object[args.Length - 2];
 555
 556         data[0] = args[2];
 557         for (int i = 3; i < args.Length; i++)
 558           data[i - 2] = args[i];
 559
 560         Function func = new Function (sym, null, nargs, nargs,
 561                                       typeof (MExpression));
 562         table.table[sym] = func;
 563         func.data = data;
 564         return null;
 565       }
 566
 567       private static void defun_pp (Function func,
 568                                     string indent, object[] args)
 569       {
 570         Console.Write ("(defun " + args[1] + " " + args[2]);
 571         bool first = true;
 572         indent += "  ";
 573         for (int i = 3; i < args.Length; i++)
 574           {
 575             if (first)
 576               {
 577                 Console.Write ("\n" + indent);
 578                 first = false;
 579               }
 580             else
 581               Console.Write (" ");
 582             ((MExpression) args[i]).pp (indent);
 583           }
 584         Console.Write (")");
 585       }
 586     }
 587
 588     public class FunctionTable
 589     {
 590       internal Dictionary<MSymbol, Function> table;
 591
 592       public FunctionTable ()
 593       {
 594         table = new Dictionary<MSymbol, Function> ();
 595       }
 596
 597       public FunctionTable (FunctionTable table)
 598       {
 599         this.table = new Dictionary<MSymbol, Function> (table.table);
 600       }
 601
 602       public void Copy (FunctionTable table)
 603       {
 604         foreach (KeyValuePair<MSymbol, Function> kv in this.table)
 605           table.table[kv.Key] = kv.Value;
 606       }
 607
 608       public void Copy (MSymbol name, FunctionTable table)
 609       {
 610         Function func;
 611         if (this.table.TryGetValue (name, out func))
 612           table.table[name] = func;
 613       }
 614     }
 615
 616     private static FunctionTable basic_table = new FunctionTable ();
 617
 618     public static void Defun (FunctionTable table, string name,
 619                               Evaluator evaluator, int min_arg, int max_arg,
 620                               params Type[] arg_types)
 621     {
 622       Function func = Defun (name, evaluator, min_arg, max_arg, arg_types);
 623       table.table[func.name] = func;
 624     }
 625
 626     public static void Defmacro (FunctionTable table, MSymbol name,
 627                                  MExpression expr)
 628     {
 629       object[] args = new object[4];
 630       args[0] = table;
 631       args[1] = name;
 632       args[2] = new MPlist ();
 633       args[3] = expr;
 634       Function.define_function (args, null);
 635     }
 636
 637     private static Function Defun (string name, Evaluator evaluator,
 638                                    int min_arg, int max_arg,
 639                                    params Type[] arg_types)
 640     {
 641       MSymbol sym = MSymbol.Of (name);
 642       Function func = new Function (sym, evaluator, min_arg, max_arg,
 643                                     arg_types);
 644       basic_table.table[sym] = func;
 645       return func;
 646     }
 647
 648     private static Function Defun (string name, Evaluator evaluator,
 649                                    int min_arg, int max_arg)
 650     {
 651       return Defun (name, evaluator, min_arg, max_arg, typeof (MExpression));
 652     }
 653
 654     private static Function Find (MSymbol name, FunctionTable table)
 655     {
 656       if (name == MSymbol.integer
 657           || name == MSymbol.mtext)
 658         return Function.literal;
 659
 660       Function func;
 661       if ((table == null
 662            || ! table.table.TryGetValue (name, out func))
 663           && ! basic_table.table.TryGetValue (name, out func))
 664         return null;
 665       return func;
 666     }
 667
 668     private void invalid_expression (object o)
 669     {
 670       throw new Exception ("Invalid expresssion: " + o);
 671     }
 672
 673     private void invalid_argument (object o)
 674     {
 675       throw new Exception (String.Format ("Invalid argument to {0}: {1}",
 676                                           function.name, o));
 677     }
 678
 679     private Function function;
 680     private object[] args;
 681
 682     public MExpression (MSymbol function_name, object[] args,
 683                         FunctionTable function_table)
 684     {
 685       function = Find (function_name, function_table);
 686       int nargs = args.Length;
 687       if (nargs < function.min_arg
 688           || (function.max_arg >= 0 && nargs > function.max_arg))
 689         throw new Exception (String.Format ("Invalid number of arguments to {0}: {1}", function.name, nargs));
 690       this.args = (object[]) args.Clone ();
 691     }
 692
 693     private MExpression[] expression_list (MPlist plist, FunctionTable table)
 694     {
 695       int len = plist.Count;
 696       MExpression[] expr_list = new MExpression[len];
 697
 698       for (int i = 0; i < len; i++, plist = plist.next)
 699         {
 700           if (plist.IsSymbol)
 701             expr_list[i] = new MExpression (plist.Symbol);
 702           else if (plist.IsMText || plist.IsInteger)
 703             expr_list[i] = new MExpression (plist.val);
 704           else if (plist.IsPlist)
 705             {
 706               MPlist p = plist.Plist;
 707               if (p.IsSymbol)
 708                 expr_list[i] = new MExpression (p.Symbol, p.next, table);
 709               else
 710                 expr_list[i] = new MExpression (p, table);
 711             }
 712           else
 713             invalid_expression (plist.val);
 714         }
 715       return expr_list;
 716     }
 717
 718     // EXPR = SYMBOL | MTEXT | INTEGER | FUNCALL | EXPRLIST
 719     // FUNCALL = '(' SYMBOL EXPR* ')'
 720     // EXPRLIST = '(' EXPR* ')'
 721
 722     // EXPRLIST: PLIST = EXPR ...
 723     public MExpression (MPlist plist, FunctionTable table)
 724     {
 725       function = Function.block;
 726       args = expression_list (plist, table);
 727     }
 728
 729     // FUNCALL: NAME = FUNCTION-NAME, ARG-LIST = EXPR ...
 730     private MExpression (MSymbol name, MPlist arg_list, FunctionTable table)
 731     {
 732       function = Find (name, table);
 733       if (function == null)
 734         throw new Exception ("Unknown function: " + name);
 735
 736       int nargs = arg_list.Count;
 737       if (nargs < function.min_arg
 738           || (function.max_arg >= 0 && nargs > function.max_arg))
 739         throw new Exception (String.Format
 740                              ("Invalid number of arguments to {0}: {1}",
 741                               function.name, nargs));
 742
 743       int i = 0;
 744       Type arg_type = typeof (MExpression);
 745       if (function.arg_types.Length > 0)
 746         {
 747           arg_type = function.arg_types[0];
 748           if (arg_type == typeof (FunctionTable))
 749             {
 750               nargs++;
 751               args = new object[nargs];
 752               args[i++] = table;
 753             }
 754           else
 755             args = new object[nargs];
 756         }
 757       else
 758         args = new object[nargs];
 759
 760       foreach (MPlist p in arg_list)
 761         {
 762           if (i < function.arg_types.Length)
 763             arg_type = function.arg_types[i];
 764           if (arg_type == typeof (MExpression))
 765             {
 766               if (p.IsSymbol)
 767                 args[i++] = new MExpression (p.Symbol);
 768               else if (p.IsMText || p.IsInteger)
 769                 args[i++] = new MExpression (p.val);
 770               else if (p.IsPlist)
 771                 {
 772                   MPlist p0 = p.Plist;
 773                   if (p0.IsSymbol)
 774                     args[i++] = new MExpression (p0.Symbol, p0.next, table);
 775                   else
 776                     args[i++] = new MExpression (p0, table);
 777                 }
 778               else
 779                 invalid_expression (p.val);
 780             }
 781           else if (arg_type == typeof (MExpression[]))
 782             {
 783               if (! p.IsPlist)
 784                 invalid_argument (p.val);
 785               args[i++] = expression_list (p.Plist, table);
 786             }
 787           else if (arg_type == typeof (MSymbol))
 788             {
 789               if (! p.IsSymbol)
 790                 invalid_argument (p.val);
 791               args[i++] = p.Symbol;
 792             }
 793           else
 794             args[i++] = p.val;
 795         }
 796       if (function == Function.defun)
 797         function.Call (args, null);
 798     }
 799
 800     public MExpression (MSymbol sym)
 801     {
 802       function = Function.varref;
 803       args = new object[1];
 804       args[0] = sym;
 805     }
 806
 807     public MExpression (object obj)
 808     {
 809       function = Function.literal;
 810       args = new object[1];
 811       args[0] = obj;
 812     }
 813
 814     public object Eval (MPlist bindings)
 815     {
 816       return function.Call (args, bindings);
 817     }
 818
 819     private void pp (string indent)
 820     {
 821       if (function == Function.varref
 822           || function == Function.literal)
 823         {
 824           if (args[0] is MText)
 825             Console.Write ("\"{0}\"", args[0]);
 826           else
 827             Console.Write (args[0]);
 828         }
 829       else
 830         function.pp (function, indent, args);
 831     }
 832
 833     public void PrettyPrint () { pp (""); }
 834   }
 835 }