X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=MExpression.cs;h=d8fbadfce8bac430c1b78f3ac2f6ac324c754fe9;hb=9005c408e8a10f40ea205a7a569e994c778d409f;hp=1affae0c1b3b13161aec7f07dcce39f290d5b662;hpb=a5e3084687ec104febe919adeff34dca72c9797b;p=m17n%2Fm17n-lib-cs.git

diff --git a/MExpression.cs b/MExpression.cs
index 1affae0..d8fbadf 100644
--- a/MExpression.cs
+++ b/MExpression.cs
@@ -2,181 +2,882 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
+using System.Xml;
+
 using M17N;
 using M17N.Core;
 
 namespace M17N.Core
 {
-  public delegate object MEvaluator (object arg, MPlist bindings);
-
-  public class MFunction
+  public class MExpression
   {
-    MSymbol name;
-    internal readonly MEvaluator evaluator;
+    private static MSymbol Mvarref = "symbol-value";
+    private static MSymbol Mdefun = "defun";
+    private static MSymbol Mcond = "cond";
+    private static MSymbol Mprogn = "progn";
+    private static MSymbol Mwhen = "when";
 
-    public static Dictionary<MSymbol, MFunction> CommonTable
-      = new Dictionary<MSymbol, MFunction> ();
-    public static readonly MFunction Identity
-    = new MFunction (MSymbol.nil, null);
-
-    static MFunction ()
+    public class Domain
     {
-      new MFunction (MSymbol.Of ("+"), new MEvaluator (plus));
-      new MFunction (MSymbol.Of ("*"), new MEvaluator (multi));
-      new MFunction (MSymbol.Of ("-"), new MEvaluator (minus));
+      private Domain parent;
+      internal MPlist functions = new MPlist ();
+      internal MPlist bindings = new MPlist ();
+      private Stack<MPlist> boundaries = new Stack<MPlist> ();
+      internal Translator translator;
+      public object context;
+
+      internal Domain ()
+      {
+	boundaries.Push (bindings);
+      }
+
+      public Domain (object context) : this (basic, context) { }
+
+      public Domain (Domain parent, object context)
+      {
+	this.parent = parent;
+	this.context = context;
+	boundaries.Push (bindings);
+      }
+
+      public void AddTranslator (Translator translator)
+      {
+	if (this.translator == null)
+	  this.translator = translator;
+	else
+	  this.translator += translator;
+      }
+
+      public void Bind (MSymbol sym, object value)
+      {
+	bindings = bindings.Cons (sym, value);
+      }
+
+      public MPlist SetBoundary ()
+      {
+	boundaries.Push (bindings);
+	return bindings;
+      }
+
+      public void UnboundTo (MPlist boundary)
+      {
+	while (boundary != boundaries.Pop ());
+	while (bindings != boundary)
+	  bindings = bindings.next;
+      }
+
+      public void Defun (string name, Builtin builtin, int min_arg, int max_arg)
+      {
+	Defun (name, builtin, min_arg, max_arg, false);
+      }
+
+      public void Defun (string name, Builtin builtin, int min_arg, int max_arg,
+			 bool specialp)
+      {
+	MSymbol sym = name;
+	Function func = (Function) functions.Get (sym);
+
+	if (func != null)
+	  {
+	    if (func.min_arg < min_arg || func.max_arg > max_arg)
+	      throw new Exception ("Incompatible argument numbers to override: "
+				   + name);
+	    func.builtin = builtin;
+	    func.lambda = null;
+	    func.min_arg = min_arg;
+	    func.max_arg = max_arg;
+	    func.specialp = specialp;
+	  }
+	else
+	  {
+	    func = new Function (sym, builtin, min_arg, max_arg, specialp);
+	    functions = functions.Cons (sym, func);
+	  }
+      }
+
+      public void Defun (MSymbol sym, MPlist args, MPlist body)
+      {
+	Function func = (Function) functions.Get (sym);
+
+	if (func != null)
+	  {
+	    int nargs = args == null ? 0 : args.Count;
+
+	    if (func.min_arg < nargs || func.max_arg > nargs)
+	      throw new Exception ("Incompatible argument numbers to override: "
+				   + sym);
+	    func.lambda.SetArgs (args);
+	    func.lambda.SetBody (body, this);
+	    func.builtin = null;
+	  }
+	else
+	  {
+	    func = new Function (sym, args, body, this);
+	    functions = functions.Cons (sym, func);
+	  }	    
+      }
+
+      public void Defun (XmlNode node)
+      {
+	MSymbol sym = node.Attributes["id"].Value;
+	Function func = (Function) functions.Get (sym);
+
+	if (func != null)
+	  {
+	    XmlNode args = node.FirstChild;
+	    int nargs = args.Name == "args" ? args.ChildNodes.Count : 0;
+
+	    if (func.min_arg < nargs || func.max_arg > nargs)
+	      throw new Exception ("Incompatible argument numbers to override: "
+				   + sym);
+	    func.lambda.Set (node, this);
+	    func.builtin = null;
+	  }
+	else
+	  {
+	    func = new Function (sym, node, this);
+	    functions = functions.Cons (sym, func);
+	  }	    
+      }
+
+      internal Function GetFunc (MSymbol name)
+      {
+	Function func = (Function) functions.Get (name);
+
+	if (func == null)
+	  {
+	    if (parent != null)
+	      return parent.GetFunc (name);
+	    throw new Exception ("Unknown function: " + name);
+	  }
+	return func;
+      }
+
+      public bool CopyFunc (Domain domain, MSymbol name)
+      {
+	Function func = (Function) functions.Get (name);
+	if (func == null)
+	  return false;
+	domain.functions = domain.functions.Cons (name, func);
+	return true;
+      }
+
+      public void CopyFunc (Domain domain)
+      {
+	foreach (MPlist p in functions)
+	  domain.functions = domain.functions.Cons (p.key, p.val);
+      }
+
+      public object GetValue (MSymbol name)
+      {
+	MPlist slot = bindings.Find (name);
+
+	if (slot == null)
+	  {
+	    if (parent != null)
+	      return parent.GetValue (name);
+	    throw new Exception ("Unbound variable: " + name);
+	  }
+	return slot.val;
+      }
+
+      public object SetValue (MSymbol name, object val)
+      {
+	MPlist boundary = boundaries.Peek ();
+
+	for (MPlist plist = bindings; plist != boundary; plist = plist.next)
+	  if (plist.key == name)
+	    {
+	      plist.val = val;
+	      return val;
+	    }
+	bindings = bindings.Cons (name, val);
+	return val;
+      }
+
+      public bool IsBound (MSymbol name)
+      {
+	return (bindings.Find (name) != null);
+      }
+
+      public void Translate (MPlist plist)
+      {
+	if (parent != null)
+	  parent.Translate (plist);
+	if (translator != null)
+	  for (MPlist p = plist; ! p.IsEmpty; p = p.next)
+	    translator (p, this);
+      }
+
+      public override string ToString ()
+      {
+	string str = "<(functions";
+	foreach (MPlist p in functions)
+	  str += " " + p.key;
+	str += ") (bindings " + bindings + ")";
+	if (context != null)
+	  str += " (" + context + ")";
+	str += ">";
+	return str;
+      }
     }
 
-    internal MFunction (MSymbol name, MEvaluator evaluator)
+    public delegate object Builtin (MExpression[] args, Domain domain);
+    public delegate void Translator (MPlist plist, Domain domain);
+
+    internal class Function
     {
-      this.name = name;
-      this.evaluator = evaluator;
-      CommonTable[name] = this;
+      internal class Lambda
+      {
+	internal MSymbol[] args;
+	internal MExpression[] body;
+
+	public Lambda (MPlist args, MPlist body, Domain domain)
+	{
+	  SetArgs (args);
+	  SetBody (body, domain);
+	}
+
+	public Lambda (XmlNode node, Domain domain)
+	{
+	  Set (node, domain);
+	}
+
+	public void SetArgs (MPlist args)
+	{
+	  int len = args == null ? 0 : args.Count;
+
+	  if (this.args == null)
+	    this.args = new MSymbol[len];
+	  for (int i = 0; i < len; i++, args = args.next)
+	    this.args[i] = args.Symbol;
+	}
+
+	public void SetBody (MPlist body, Domain domain)
+	{
+	  int len = body == null ? 0 : body.Count;
+	  if (this.body == null)
+	    this.body = new MExpression[len];
+	  for (int i = 0; i < len; i++, body = body.next)
+	    {
+	      domain.Translate (body);
+	      this.body[i] = new MExpression (body.key, body.val, domain);
+	    }
+	}
+
+	public void Set (XmlNode node, Domain domain)
+	{
+	  XmlNodeList body = node.ChildNodes;
+	  int idx = 0;
+
+	  if (body[0].Name == "args")
+	    {
+	      XmlNodeList args = body[0].ChildNodes;
+	      if (this.args == null)
+		this.args = new MSymbol[args.Count];
+	      for (int i = 0; i < args.Count; i++)
+		this.args[i] = args[i].InnerText;
+	      idx++;
+	    }
+	  else if (this.args == null)
+	    this.args = new MSymbol[0];
+	  if (this.body == null)
+	    this.body = new MExpression[body.Count - idx];
+	  for (int i = 0; idx < body.Count; i++, idx++)
+	    this.body[i] = new MExpression (body[idx], domain);
+	}
+      }
+
+      public readonly MSymbol Name;
+      public Builtin builtin;
+      public int min_arg, max_arg;
+      internal Lambda lambda;
+      public bool specialp = false;
+
+      internal static Function ignore, varref, block;
+
+      public Function (MSymbol name, Builtin builtin,
+		       int min_arg, int max_arg, bool specialp)
+      {
+	Name = name;
+	this.builtin = builtin;
+	this.min_arg = min_arg;
+	this.max_arg = max_arg;
+	this.specialp = specialp;
+      }
+
+      internal Function (MSymbol name, MPlist args, MPlist body,
+			 Domain domain)
+      {
+	Name = name;
+	lambda = new Lambda (args, body, domain);
+	this.min_arg = this.max_arg = lambda.args.Length;
+      }
+
+      internal Function (MSymbol name, XmlNode node, Domain domain)
+      {
+	Name = name;
+	lambda = new Lambda (node, domain);
+	this.min_arg = this.max_arg = lambda.args.Length;
+      }
+
+      private Function ()
+      {
+	Name = MSymbol.nil;
+      }
+
+      static Function ()
+      {
+	ignore = new Function ();
+	varref = new Function (Mvarref, get_value, 1, 1, true);
+	block = new Function (Mprogn, progn, 0, -1, true);
+      }
+
+      private static object get_value (MExpression[] args, Domain domain)
+      {
+	return domain.GetValue ((MSymbol) args[0].val);
+      }
+
+      public object Call (MExpression[] args, Domain domain)
+      {
+	if (builtin != null)
+	  {
+	    if (! specialp)
+	      foreach (MExpression e in args)
+		e.Eval (domain);
+	    return builtin (args, domain);
+	  }
+	if (lambda == null)
+	  return null;
+	MPlist orig_bindings = domain.bindings;
+	object result = false;
+	try {
+	  int i = 0;
+	  foreach (MSymbol arg in lambda.args)
+	    domain.Bind (arg, args[i++].Eval (domain));
+	  foreach (MExpression e in lambda.body)
+	    result = e.Eval (domain);
+	} finally {
+	  domain.bindings = orig_bindings;
+	}
+	return result;
+      }
     }
 
-    public MFunction (MSymbol name, MEvaluator evaluator,
-		      Dictionary<MSymbol, MFunction> dict)
+    private static Domain basic;
+
+    static MExpression ()
     {
-      this.evaluator = evaluator;
-      dict[name] = this;
+      basic = new Domain ();
+
+      basic.Defun ("set", set_value, 2, 2, true);
+      basic.Defun ("=", set_value, 2, 2, true);
+      basic.Defun ("!", not, 1, 1, false);
+      basic.Defun ("+", plus, 2, -1, false);
+      basic.Defun ("*", multi, 2, -1, false);
+      basic.Defun ("-", minus, 1, -1, false);
+      basic.Defun ("/", divide, 2, -1, false);
+      basic.Defun ("%", percent, 2, -1, false);
+      basic.Defun ("|", logior, 2, -1, false);
+      basic.Defun ("&", logand, 2, -1, false);
+      basic.Defun ("+=", pluseq, 2, -1, true);
+      basic.Defun ("*=", multieq, 2, -1, true);
+      basic.Defun ("-=", minuseq, 2, -1, true);
+      basic.Defun ("/=", divideeq, 2, -1, true);
+      basic.Defun ("%=", percenteq, 2, -1, true);
+      basic.Defun ("|=", logioreq, 2, -1, true);
+      basic.Defun ("&=", logandeq, 2, -1, true);
+      basic.Defun ("<<", lshift, 2, 2, false);
+      basic.Defun (">>", rshift, 2, 2, false);
+      basic.Defun ("<<=", lshifteq, 2, 2, true);
+      basic.Defun (">>=", rshifteq, 2, 2, true);
+      basic.Defun ("==", eq, 2, -1, false);
+      basic.Defun ("!=", noteq, 2, 2, false);
+      basic.Defun ("<", less, 2, -1, false);
+      basic.Defun ("<=", lesseq, 2, -1, false);
+      basic.Defun (">", more, 2, -1, false);
+      basic.Defun (">=", moreeq, 2, -1, false);
+      basic.Defun ("progn", progn, 0, -1, true);
+      basic.Defun ("if", ifclause, 2, -1, true);
+      basic.Defun ("when", whenclause, 1, -1, true);
+      basic.Defun ("while", whileclause, 1, -1, true);
+
+      basic.AddTranslator (new Translator (translate_cond));
     }
 
-    internal static MFunction Find (MSymbol name,
-				  Dictionary<MSymbol, MFunction> Table)
+    private static object set_value (MExpression[] args, Domain domain)
     {
-      if (name == MSymbol.integer
-	  || name == MSymbol.plist
-	  || name == MSymbol.mtext
-	  || name == MSymbol.symbol)
-	return Identity;
-
-      MFunction func;
-      if ((Table == null
-	   || ! Table.TryGetValue (name, out func))
-	  && ! MFunction.CommonTable.TryGetValue (name, out func))
-	throw new Exception ("Unknown function: " + name);
-      return func;
+      return domain.SetValue ((MSymbol) args[0].args[0].val,
+			      args[1].Eval (domain));
     }
 
-    public object Call (object arg, MPlist bindings)
+    private static object not (MExpression[] args, Domain domain)
     {
-      if (name == MSymbol.nil)
-	return arg;
-      return evaluator (arg, bindings);
+      if (args[0].val is int)
+	return (int) args[0].val == 0;
+      if (args[0].val is bool)
+	return ! ((bool) args[0].val);
+      return true;
     }
 
-    private static object plus (object arg, MPlist bindings)
+    private static object plus (MExpression[] args, Domain domain)
     {
-      MExpression expr = (MExpression) arg;
-
-      int n = 0;
-      foreach (MExpression e in expr)
-	n += (int) e.Eval (bindings);
-      return n;
+      if (args[0].val is int)
+	{
+	  int n = 0;
+	  foreach (MExpression e in args)
+	    n += (int) e.val;
+	  return n;
+	}
+      else if (args[0].val is MText)
+	{
+	  MText mt = new MText ();
+	  foreach (MExpression e in args)
+	    mt += (MText) e.val;
+	  return mt;
+	}
+      throw new Exception ("Not an integer nor MText: " + args[0].val);
     }
 
-    private static object multi (object arg, MPlist bindings)
-    {
-      MExpression expr = (MExpression) arg;
+      private static object multi (MExpression[] args, Domain domain)
+      {
+	int n = 1;
+	foreach (MExpression e in args)
+	  n *= (int) e.val;
+	return n;
+      }
 
-      int n = 1;
-      foreach (MExpression e in expr)
-	n *= (int) e.Eval (bindings);
-      return n;
-    }
+      private static object minus (MExpression[] args, Domain domain)
+      {
+	int n = (int) args[0].val;
+	if (args.Length == 1)
+	  return - n;
+	for (int i = 1; i < args.Length; i++)
+	  n -= (int) args[i].val;
+	return n;
+      }
 
-    private static object minus (object arg, MPlist bindings)
+      private static object divide (MExpression[] args, Domain domain)
       {
-	MExpression expr = (MExpression) arg;
+	int n = (int) args[0].val;
+	for (int i = 1; i < args.Length; i++)
+	  n /= (int) args[i].val;
+	return n;
+      }
 
-	int n = (int) expr.Eval (bindings);
-	foreach (MExpression e in expr.next)
-	  n -= (int) e.Eval (bindings);
+      private static object percent (MExpression[] args, Domain domain)
+      {
+	int n = (int) args[0].val;
+	for (int i = 1; i < args.Length; i++)
+	  n %= (int) args[i].val;
 	return n;
       }
 
-#if false
+      private static object logior (MExpression[] args, Domain domain)
+      {
+	int n = 0;
+	foreach (MExpression e in args)
+	  n |= (int) e.val;
+	return n;
+      }
 
-    if (key == Mslash)
+      private static object logand (MExpression[] args, Domain domain)
       {
-	int n = Plist.Eval (env);
-	foreach (MPlist plist in Plist.next)
-	  n /= plist.Eval (env);
+	int n = 0;
+	foreach (MExpression e in args)
+	  n &= (int) e.val;
 	return n;
       }
-    if (key == Mpercent)
+
+      private static object pluseq (MExpression[] args, Domain domain)
       {
-	return Plist.Eval (env) % Plist.next.Eval (env);
+	MSymbol sym = (MSymbol) args[0].args[0].val;
+	object val = domain.GetValue (sym);
+
+	if (val is int)
+	  {
+	    int n = (int) val;
+	    for (int i = 1; i < args.Length; i++)
+	      n += (int) args[i].Eval (domain);
+	    val = n;
+	  }
+	else if (val is MText)
+	  {
+	    MText mt = (MText) val;
+	    for (int i = 1; i < args.Length; i++)
+	      mt.Cat ((MText) args[i].Eval (domain));
+	    val = mt;
+	  }
+	domain.SetValue (sym, val);
+	return val;
       }
-    if (key == Mlogior)
+
+      private static object multieq (MExpression[] args, Domain domain)
       {
-	return Plist.Eval (env) | Plist.next.Eval (env);
+	MSymbol sym = (MSymbol) args[0].args[0].val;
+	int n = (int) domain.GetValue (sym);
+
+	for (int i = 1; i < args.Length; i++)
+	  n *= (int) args[i].Eval (domain);
+	return domain.SetValue (sym, (object) n);
       }
-    if (key == Mlogand)
+
+      private static object minuseq (MExpression[] args, Domain domain)
       {
-	return Plist.Eval (env) & Plist.next.Eval (env);
+	MSymbol sym = (MSymbol) args[0].args[0].val;
+	int n = (int) domain.GetValue (sym);
+
+	for (int i = 1; i < args.Length; i++)
+	  n -= (int) args[i].Eval (domain);
+	return domain.SetValue (sym, (object) n);
       }
-    if (key == Mlshift)
+
+      private static object divideeq (MExpression[] args, Domain domain)
       {
-	return Plist.Eval (env) << Plist.next.Eval (env);
+	MSymbol sym = (MSymbol) args[0].args[0].val;
+	int n = (int) domain.GetValue (sym);
+
+	for (int i = 1; i < args.Length; i++)
+	  n /= (int) args[i].Eval (domain);
+	return domain.SetValue (sym, (object) n);
       }
-    if (key == Mrshift)
+
+      private static object percenteq (MExpression[] args, Domain domain)
       {
-	return Plist.Eval (env) >> Plist.next.Eval (env);
+	MSymbol sym = (MSymbol) args[0].args[0].val;
+	int n = (int) domain.GetValue (sym);
+
+	for (int i = 1; i < args.Length; i++)
+	  n %= (int) args[i].Eval (domain);
+	return domain.SetValue (sym, (object) n);
       }
-    if (key == Mset)
+
+      private static object logioreq (MExpression[] args, Domain domain)
       {
-	MSymbol var = (MSymbol) Plist.val;
+	MSymbol sym = (MSymbol) args[0].args[0].val;
+	int n = (int) domain.GetValue (sym);
 
+	for (int i = 1; i < args.Length; i++)
+	  n |= (int) args[i].Eval (domain);
+	return domain.SetValue (sym, (object) n);
       }
-#endif
-  }
 
-  public class MExpression : MPlist
-  {
-    internal Dictionary<MSymbol, MFunction> FunctionTable;
+      private static object logandeq (MExpression[] args, Domain domain)
+      {
+	MSymbol sym = (MSymbol) args[0].args[0].val;
+	int n = (int) domain.GetValue (sym);
 
-    private MFunction function;
+	for (int i = 1; i < args.Length; i++)
+	  n &= (int) args[i].Eval (domain);
+	return domain.SetValue (sym, (object) n);
+      }
 
-    public MExpression () : base () { }
+      private static object lshift (MExpression[] args, Domain domain)
+      {
+	return (int) args[0].val << (int) args[1].val;
+      }
+
+      private static object lshifteq (MExpression[] args, Domain domain)
+      {
+	MSymbol sym = (MSymbol) args[0].args[0].val;
+	int n = (int) domain.GetValue (sym);
+
+	n <<= (int) args[1].Eval (domain);
+	return domain.SetValue (sym, (object) n);
+      }
+
+      private static object rshift (MExpression[] args, Domain domain)
+      {
+	return (int) args[0].val >> (int) args[1].val;
+      }
 
-    public MExpression (Dictionary<MSymbol, MFunction> function_table)
-      : base () { FunctionTable = function_table; }
+      private static object rshifteq (MExpression[] args, Domain domain)
+      {
+	MSymbol sym = (MSymbol) args[0].args[0].val;
+	int n = (int) domain.GetValue (sym);
+
+	n >>= (int) args[1].Eval (domain);
+	return domain.SetValue (sym, (object) n);
+      }
+
+      private static object eq (MExpression[] args, Domain domain)
+      {
+	int n = (int) args[0].val;
+
+	for (int i = 1; i < args.Length; i++)
+	  if (n != (int) args[i].val)
+	    return false;
+	return true;
+      }
 
-    public new MExpression Add (MPlist plist)
+      private static object noteq (MExpression[] args, Domain domain)
+      {
+	return ((int) args[0].val != (int) args[1].val);
+      }
+
+      private static object less (MExpression[] args, Domain domain)
+      {
+	int n = (int) args[0].val;
+
+	for (int i = 1; i < args.Length; i++)
+	  {
+	    int n1 = (int) args[i].val;
+	    if (n >= n1)
+	      return false;
+	    n = n1;
+	  }
+	return true;
+      }
+
+      private static object lesseq (MExpression[] args, Domain domain)
+      {
+	int n = (int) args[0].val;
+	for (int i = 1; i < args.Length; i++)
+	  {
+	    int n1 = (int) args[i].val;
+	    if (n > n1)
+	      return false;
+	    n = n1;
+	  }
+	return true;
+      }
+
+      private static object more (MExpression[] args, Domain domain)
+      {
+	int n = (int) args[0].val;
+	for (int i = 1; i < args.Length; i++)
+	  {
+	    int n1 = (int) args[i].val;
+	    if (n <= n1)
+	      return false;
+	    n = n1;
+	  }
+	return true;
+      }
+
+      private static object moreeq (MExpression[] args, Domain domain)
+      {
+	int n = (int) args[0].val;
+	for (int i = 1; i < args.Length; i++)
+	  {
+	    int n1 = (int) args[i].val;
+	    if (n < n1)
+	      return false;
+	    n = n1;
+	  }
+	return true;
+      }
+
+      private static object progn (MExpression[] args, Domain domain)
+      {
+	object result = false;
+
+	foreach (MExpression e in args)
+	  result = e.Eval (domain);
+	return result;
+      }
+
+      private static bool check_condition (MExpression condition, Domain domain)
+      {
+	object result = condition.Eval (domain);
+	return (result is bool ? (bool) result
+		: result is int ? ((int) result) != 0
+		: true);
+      }
+
+      private static object ifclause (MExpression[] args, Domain domain)
+      {
+	object result = false;
+
+	if (check_condition (args[0], domain))
+	  result = args[1].Eval (domain);
+	else
+	  for (int i = 2; i < args.Length; i++)
+	    result = args[i].Eval (domain);
+	return result;
+      }
+
+      private static object whenclause (MExpression[] args, Domain domain)
+      {
+	object result = false;
+
+	if (check_condition (args[0], domain))
+	  for (int i = 1; i < args.Length; i++)
+	    result = args[i].Eval (domain);
+	return result;
+      }
+
+      private static object whileclause (MExpression[] args, Domain domain)
+      {
+	while (check_condition (args[0], domain))
+	  for (int i = 1; i < args.Length; i++)
+	    args[i].Eval (domain);
+	return false;
+      }
+
+    // (cond (COND1 ...) (COND2 ...) ...)
+    //   => (cond (when COND1 ...) (when COND2 ...) ...)
+    private static void translate_cond (MPlist plist, Domain domain)
     {
       if (plist.IsPlist)
 	{
-	  MPlist pl = plist.Plist;
-	  
-	  if (! pl.IsSymbol)
-	    throw new Exception ("Invalid expression: " + plist);
-	  MExpression e = new MExpression (FunctionTable);
-	  pl.key = pl.Symbol;
-	  foreach (MPlist p in pl.next)
-	    e.Add (p);
-	  pl.val = e;
-	  return Add (pl);
-	}
-      return Add (plist.key, plist.val);
+	  plist = plist.Plist;
+	  if (plist.IsSymbol && plist.Symbol == Mcond)
+	    {
+	      plist.val = Mprogn;
+	      for (plist = plist.next; ! plist.IsEmpty; plist = plist.next)
+		{
+		  if (! plist.IsPlist)
+		    throw new Exception ("Invalid cond form: " + plist);
+		  plist.Plist.Push (MSymbol.symbol, Mwhen);
+		}		
+	    }
+	}
+    }
+
+    private Function function;
+    private MExpression[] args;
+    private object val;
+
+    public MExpression[] Args { get { return args; } }
+    public object Val { get { return val; } }
+
+    private MExpression (object val)
+    {
+      this.val = val;
+    }
+
+    // EXPR = SYMBOL | MTEXT | INTEGER | FUNCALL | PROGN
+    // FUNCALL = '(' SYMBOL EXPR* ')'
+    // PROGN = '(' EXPR * ')'
+    private MExpression (MSymbol key, object val, Domain domain)
+    {
+      if (key == MSymbol.symbol)
+	{
+	  function = Function.varref;
+	  args = new MExpression[1];
+	  args[0] = new MExpression (val);
+	}
+      else if (key == MSymbol.integer
+	       || key == MSymbol.mtext)
+	{
+	  this.val = val;
+	}
+      else if (key == MSymbol.plist)
+	{
+	  MPlist p = (MPlist) val;
+
+	  if (p.IsSymbol)
+	    {
+	      MSymbol sym = p.Symbol;
+
+	      if (sym == Mdefun)
+		{
+		  p = p.next;
+		  if (! p.IsSymbol)
+		    throw new Exception ("Invalid function argument: "
+					 + p.val);
+		  sym = p.Symbol;
+		  p = p.next;
+		  if (! p.IsPlist)
+		    throw new Exception ("Invalid function argument: "
+					 + p.val);
+		  domain.Defun (sym, p.Plist, p.next);
+		  // This Mexpression is just a dummy.
+		}
+	      else
+		{
+		  function = domain.GetFunc (sym);
+		  p = p.next;
+		  int nargs = p.Count;
+		  if (nargs < function.min_arg
+		      || (function.max_arg >= 0 && nargs > function.max_arg))
+		    throw new Exception ("Invalid number of arguments to: "
+					 + sym + " " + nargs);
+		  args = new MExpression[nargs];
+		  for (int i = 0; i < nargs; i++, p = p.next)
+		    {
+		      domain.Translate (p);
+		      args[i] = new MExpression (p.key, p.val, domain);
+		    }
+		}
+	    }
+	  else
+	    {
+	      args = new MExpression[1];
+	      args[0] = new MExpression (p, domain);
+	    }
+	}
+      else
+	throw new Exception ("Invalid expression: " + key + ":" + val);
     }
 
-    public new MExpression Add (MSymbol function_name, object arg)
+    public MExpression (MPlist plist, Domain domain)
     {
-      MExpression expr = this, e = new MExpression ();
-
-      while (! expr.IsEmpty)
-	expr = (MExpression) expr.next;
-      expr.key = function_name;
-      expr.val = arg;
-      expr.next = e;
-      expr.FunctionTable = FunctionTable;
-      expr.function = MFunction.Find (function_name, FunctionTable);
-      return expr;
+      function = Function.block;
+      args = new MExpression[plist.Count];
+      for (int i = 0; ! plist.IsEmpty; i++, plist = plist.next)
+	{
+	  domain.Translate (plist);
+	  args[i] = new MExpression (plist.key, plist.val, domain);
+	}
     }
 
-    public object Eval (MPlist bindings)
+    public MExpression (XmlNode node, Domain domain)
     {
-      return function.Call (val, bindings);
+      MSymbol sym = node.Name;
+
+      function = domain.GetFunc (sym);
+
+      XmlAttributeCollection attrs = node.Attributes;
+
+      int nargs = attrs.Count + node.ChildNodes.Count;
+      if (nargs < function.min_arg
+	  || (function.max_arg >= 0 && nargs > function.max_arg))
+	throw new Exception ("Invalid number of arguments: " + node.InnerXml);
+      args = new MExpression[nargs];
+      int i;
+      for (i = 0; i < attrs.Count; i++)
+	{
+	  string str = sttrs[i].Value;
+
+	}
+    }
+
+    public object Eval (Domain domain)
+    {
+      if (function == null)
+	{
+	  if (val is MSymbol)
+	    val = domain.GetValue ((MSymbol) val);
+	}
+      else
+	val = function.Call (args, domain);
+      return val;
+    }
+
+    public override string ToString ()
+    {
+      string str;
+
+      if (function != null)
+	{
+	  str = "(" + function.Name.Name;
+	  if (args != null)
+	    foreach (MExpression e in args)
+	      str += " " + e.ToString ();
+	  str += ")";
+	}
+      else if (val != null)
+	{
+	  if (val is MText)
+	    str = "\"" + (string) ((MText) val) + "\"";
+	  else
+	    str = val.ToString ();
+	}
+      else
+	str = "()";
+      return str;
     }
   }
-}
\ No newline at end of file
+}