X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=XmlExpr.cs;h=906057b44501a3adb174182de07e16275ecbc41e;hb=41ffade8cdc252f9c93ac30cda678bedd0def48d;hp=5251080d3f1ae1a14540895e79eec16cee04e2aa;hpb=bee56ed9bc13176a3dfe4547d75e334b55a1f6c1;p=m17n%2Fm17n-lib-cs.git

diff --git a/XmlExpr.cs b/XmlExpr.cs
index 5251080..906057b 100644
--- a/XmlExpr.cs
+++ b/XmlExpr.cs
@@ -2,17 +2,74 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
+using System.Reflection;
 using System.Xml;
 
 namespace System.Xml
 {
-  public class Xexpression
+  public static class Xexpression
   {
-    private static int debug_depth = 0;
+    private static int trace_depth = 0;
 
-    public static int DebugDepth {
-      get { return debug_depth; }
-      set { debug_depth = value; }
+    public static int TraceDepth {
+      get { return trace_depth; }
+      set { trace_depth = value; }
+    }
+
+    public static partial class Error
+    {
+      // Load time errors.
+      public static Symbol UnknownFunction = "unknown-function";
+      public static Symbol TypeConflict = "type-conflict";
+      public static Symbol AlreadyDefined = "already-defined";
+      public static Symbol WrongCallingFormat = "wrong-calling-format";
+      public static Symbol ArgumentMismatch = "argument-mismatch";
+
+      // Run time errors.
+      public static Symbol ArithmeticError = "arithmetic-error";
+      public static Symbol WrongType = "wrong-type";
+      public static Symbol WrongRange = "wrong-range";
+      public static Symbol OutOfRange = "out-of-range";
+
+      public static Symbol InvalidVariableType = "invalid variable type";
+      public static Symbol NoOuterLoop = "no outer loop";
+      public static Symbol UnknownError = "unknown error";
+    }
+
+    public class Exception : System.Exception
+    {
+      public Symbol ErrorName;
+      public string ErrorNode;
+      public Term ErrorTerm;
+
+      internal Exception (Symbol name, string fmt, params object[] args)
+	: this (name, Zero, fmt, args) { }
+
+      internal Exception (Symbol name, XmlNode node,
+			  string fmt, params object[] args)
+	: this (name, node, Zero, fmt, args) { }
+
+      internal Exception (Symbol name, Term term,
+			  string fmt, params object[] args)
+	: this (name, null, term, fmt, args) { }
+
+      internal Exception (Symbol name, XmlNode node, Term term,
+			  string fmt, params object[] args)
+	: base (String.Format (message, args))
+	{
+	  ErrorName = name;
+	  if (node != null)
+	    ErrorNode = node.OuterXml;
+	  ErrorTerm = term;
+	}
+
+      internal Exception (XmlNode node, System.Exception e)
+	: base ("System error", e)
+	{
+	  ErrorName = Qsystem_error;
+	  ErrorNode = node;
+	  ErrorTerm = Zero;
+	}
     }
 
     public struct Symbol : IEquatable<Symbol>
@@ -67,7 +124,9 @@ namespace System.Xml
 
       public override bool Equals (object obj)
       {
-	return Object.ReferenceEquals (this.name, obj);
+	return (obj is Symbol ? this == (Symbol) obj
+		: obj is string ? this.name == (string) obj
+		: false);
       }
 
       public override int GetHashCode ()
@@ -102,18 +161,29 @@ namespace System.Xml
     private static Symbol Qdescription = "description";
     private static Symbol Qrange = "range";
 
+    private static Symbol Qename = "ename";
+
     public abstract class Function
     {
       public Symbol name;
-      public int min_arg, max_arg;
+      // True iff the function can be called with vname="VNAME" attribute.
+      internal readonly  bool with_var;
+      // Minimum number of positional arguments.
+      internal readonly int min_args;
+      // If non-nengative, maximum number of arguments.  If negative,
+      // maxinum number of positional arguments is (-1 - max_args),
+      // and the remaining unlimit number of arguments are given as a
+      // single list.
+      internal readonly int max_args;
 
       public Function () { }
 
-      public Function (Symbol name, int min_arg, int max_arg)
+      public Function (Symbol name, bool with_var, int min_args, int max_args)
       {
 	this.name = name;
-	this.min_arg = min_arg;
-	this.max_arg = max_arg;
+	this.with_var = with_var;
+	this.min_args = min_args;
+	this.max_args = max_args;
       }
 
       public abstract Term Call (Domain domain, Variable vari, Term[] args);
@@ -125,26 +195,25 @@ namespace System.Xml
 
       internal class Subroutine : Function
       {
-	public Builtin builtin;
-	public bool setvar;
+	public Func<Domain, Variable, Term[], Term> builtin;
 
-	public Subroutine (Builtin builtin, Symbol name, bool setvar,
-			   int min_arg, int max_arg)
-	  : base (name, min_arg, max_arg)
+	public Subroutine (Func<Domain, Variable, Term[], Term> builtin,
+			   Symbol name, bool with_var,
+			   int min_args, int max_args)
+	  : base (name, with_var, min_args, max_args)
 	  {
 	    this.builtin = builtin;
-	    this.setvar = setvar;
 	  }
 
 	public override Term Call (Domain domain, Variable vari, Term[] args)
 	{
-	  if (args != null)
+	  if (args.Length > 0)
 	    {
 	      args = (Term[]) args.Clone ();
 	      for (int i = 0; i < args.Length; i++)
 		{
 		  args[i] = args[i].Eval (domain);
-		  if (domain.Thrown)
+		  if (domain.Thrown ())
 		    return args[i];
 		}
 	    }
@@ -154,11 +223,12 @@ namespace System.Xml
 
       internal class SpecialForm : Function
       {
-	public Builtin builtin;
+	public Func<Domain, Variable, Term[], Term> builtin;
 
-	public SpecialForm (Builtin builtin, Symbol name,
-			    int min_arg, int max_arg)
-	  : base (name, min_arg, max_arg)
+	public SpecialForm (Func<Domain, Variable, Term[], Term> builtin,
+			    Symbol name, bool with_var,
+			    int min_args, int max_args)
+	  : base (name, with_var, min_args, max_args)
 	  {
 	    this.builtin = builtin;
 	  }
@@ -169,166 +239,77 @@ namespace System.Xml
 	}
       }
 
-      private static void parse_head (Domain domain, XmlNode node,
-				      out Symbol name,
-				      out int min_arg, out int max_arg,
-				      out Variable[] args)
-      {
-	int nfixed = 0;
-	int noptional = 0;
-	int nrest = 0;
-	name = node.Attributes[Qfname].Value;
-	    
-	node = node.FirstChild;
-	if (node != null && node.Name == Qargs)
-	  {
-	    XmlNode n;
-	    for (n = node.FirstChild; n != null; n = n.NextSibling)
-	      {
-		if (n.Name == Qfixed)
-		  nfixed++;
-		else if (n.Name == Qoptional)
-		  noptional++;
-		else if (n.Name == Qrest)
-		  nrest++;
-		else
-		  throw new Exception ("Invalid argument type: " + n);
-	      }
-	    min_arg = nfixed;
-	    max_arg = nfixed + noptional + nrest;
-	    args = new Variable[max_arg];
-	    n = node.FirstChild;
-	    for (int i = 0; i < max_arg; n = n.NextSibling)
-	      args[i++] = domain.Defvar ((Symbol) n.Attributes[0].Value);
-	    if (nrest == 1)
-	      max_arg = - max_arg;
-	  }
-	else
-	  {
-	    min_arg = max_arg = 0;
-	    args = null;
-	  }
-      }
-
-      private static void parse_body (Domain domain, XmlNode node,
-				      out Term[] body)
-      {
-	for (node = node.FirstChild; node != null; node = node.NextSibling)
-	  if (node.Name != Qdescription
-	      && node.Name != Qargs)
-	    break;
-	int nterms = 0;
-	for (XmlNode n = node; n != null; n = n.NextSibling)
-	  nterms++;
-	if (nterms > 0)
-	  {
-	    body = new Term[nterms];
-	    for (nterms = 0; node != null; node = node.NextSibling, nterms++)
-	      body[nterms] = new Term (domain, node);
-	  }
-	else
-	  body = null;
-      }
-
-      internal class Macro : Function
+      internal class Lambda : Function
       {
-	internal Variable[] args;
-	internal Term[] body;
+	private Variable[] args;
+	private Term[] body;
 
-	public Macro (Domain domain, XmlNode node)
+	public Lambda (Symbol name, int min_args, int max_args, Variable[] args,
+		       Term[] body)
+	  : base (name, false, min_args, max_args)
 	  {
-	    parse_head (domain, node, out name, out min_arg, out max_arg,
-			out args);
+	    this.args = args;
+	    this.body = body;
 	  }
 
-	public void SetBody (Domain domain, XmlNode node)
+	public void SetBody (Term[] body)
 	{
-	  parse_body (domain, node, out body);
+	  this.body = body;
 	}
 
 	public override Term Call (Domain domain, Variable vari, Term[] args)
 	{
 	  Bindings current = domain.bindings;
 	  Term result = Zero;
+	  int limit = max_args >= 0 ? args.Length : args.Length - 1;
 
-	  try {
-	    for (int i = 0; i < min_arg; i++)
-	      domain.Bind (this.args[i], args[i]);
-	    if (body != null)
-	      {
-		try {
-		  domain.Catch (CatchTag.Return);
-		  foreach (Term term in body)
-		    {
-		      result = term.Eval (domain);
-		      if (domain.Thrown)
-			return result;
-		    }
-		} finally {
-		  domain.Uncatch ();
+	  for (int i = 0; i < limit; i++)
+	    {
+	      result = args[i].Eval (domain);
+	      if (domain.Thrown)
+		return result;
+	      domain.Bind (this.args[i], result);
+	    }
+	  if (max_args < 0)
+	    {
+	      List<Term> list = new List<Term> ();
+	      list.InsertRange (0, args[result].Listval);
+
+	      for (int i = 0; i < list.Count; i++)
+		{
+		  result = list[i].Eval (domain);
+		  if (domain.Thrown)
+		    return result;
+		  list[i] = result;
 		}
-	      }
-	  } finally {
-	    domain.UnboundTo (current);
-	  }
+	      domain.Bind (this.args[limit], new Term (list));
+	    }
+	  domain.Catch (CatchTag.Return);
+	  foreach (Term term in body)
+	    {
+	      result = term.Eval (domain);
+	      if (domain.Thrown ())
+		return result;
+	    }
+	  domain.Uncatch ();
+	  domain.UnboundTo (current);
 	  return result;
 	}
       }
 
-      internal class Lambda : Function
+      internal class Macro : Function
       {
-	internal Variable[] args;
-	internal Term[] body;
-
-	public Lambda (Domain domain, XmlNode node)
-	  {
-	    parse_head (domain, node, out name, out min_arg, out max_arg,
-			out args);
-	  }
+	private Variable[] args;
+	private Term[] body;
 
-	public Lambda (Domain domain, Symbol name, Symbol[] args)
+	public Macro (Symbol name, int min_args, int max_args, Variable[] args,
+		      Term[] body)
+	  : base (name, false, min_args, max_args)
 	  {
-	    int nfixed = 0;
-	    int noptional = 0;
-	    int nrest = 0;
-
-	    this.name = name;
-	    if (args != null)
-	      {
-		int i = 0;
-		for (i = 0; i < args.Length; i++, nfixed++)
-		  if (args[i] == Qoptional || args[i] == Qrest)
-		    break;
-		if (i < args.Length)
-		  {
-		    if (args[i] == Qoptional)
-		      {
-			for (i++; i < args.Length; i++, noptional++)
-			  if (args[i] == Qrest)
-			    break;
-			if (i < args.Length)
-			  nrest = 1;
-		      }
-		  }
-		min_arg = nfixed;
-		max_arg = nfixed + noptional + nrest;
-		this.args = new Variable[max_arg];
-		int j;
-		for (i = j = 0; j < this.args.Length; i++)
-		  if (args[i] != Qoptional || args[i] != Qrest)
-		    this.args[j++] = domain.Defvar (args[i]);
-	      }
-	    else
-	      {
-		min_arg = max_arg = 0;
-	      }
+	    this.args = args;
+	    this.body = body;
 	  }
 
-	public void SetBody (Domain domain, XmlNode node)
-	{
-	  parse_body (domain, node, out body);
-	}
-
 	public void SetBody (Term[] body)
 	{
 	  this.body = body;
@@ -339,34 +320,17 @@ namespace System.Xml
 	  Bindings current = domain.bindings;
 	  Term result = Zero;
 
-	  try {
-	    int i;
-	    if (args != null)
-	      {
-		Term[] newargs = new Term[args.Length];
-		for (i = 0; i < min_arg; i++)
-		  newargs[i] = args[i].Eval (domain);
-		args = newargs;
-	      }
-	    for (i = 0; i < min_arg; i++)
-	      domain.Bind (this.args[i], args[i]);
-	    if (body != null)
-	      {
-		try {
-		  domain.Catch (CatchTag.Return);
-		  foreach (Term term in body)
-		    {
-		      result = term.Eval (domain);
-		      if (domain.Thrown)
-			return result;
-		    }
-		} finally {
-		  domain.Uncatch ();
-		}
-	      }
-	  } finally {
-	    domain.UnboundTo (current);
-	  }
+	  for (int i = 0; i < args.Length; i++)
+	    domain.Bind (this.args[i], args[i]);
+	  domain.Catch (CatchTag.Return);
+	  foreach (Term term in body)
+	    {
+	      result = term.Eval (domain);
+	      if (domain.Thrown ())
+		break;
+	    }
+	  domain.Uncatch ();
+	  domain.UnboundTo (current);
 	  return result;
 	}
       }
@@ -394,8 +358,6 @@ namespace System.Xml
 
       public virtual void Reset () { val = Zero; }
 
-      public virtual string Description { get { return null; } }
-
       public Term Value
       {
 	get { return val; }
@@ -435,7 +397,10 @@ namespace System.Xml
 
 	public override void Reset () { val = default_val; }
 
-	public override string Description { get { return desc; } }
+	public string Description {
+	  get { return desc; }
+	  set { desc = value; }
+	}
       }
 
       public class Int : Typed
@@ -462,10 +427,13 @@ namespace System.Xml
 	  : base (domain, name, new Term (n), desc)
 	  {
 	    if (range != null && range.Length % 2 == 1)
-	      throw_exception ("Range length for {0} not even", name);
+	      throw new Exception (Qinvalid_range,
+				   "Range length for {0} not even", name);
 	    this.range = range;
 	    if (! ValueP (val))
-	      throw_exception ("Invalid integer value for {0}: {1}", name, val);
+	      throw new Exception (Qout_of_range,
+				   "Invalid integer value for {0}: {1}",
+				   name, val);
 	  }
 
 	public override bool ValueP (Term term)
@@ -515,7 +483,9 @@ namespace System.Xml
 	  {
 	    this.range = range;
 	    if (! ValueP (val))
-	      throw_exception ("Invalid string value for {0}: {1}", name, val);
+	      throw new Exception (Qout_of_range,
+				   "Invalid string value for {0}: {1}",
+				   name, val);
 	  }
 
 	public override bool ValueP (Term term)
@@ -565,7 +535,9 @@ namespace System.Xml
 	  {
 	    this.range = range;
 	    if (! ValueP (val))
-	      throw_exception ("Invalid symbol value for {0}: {1}", name, val);
+	      throw new Exception (Qout_of_range,
+				   "Invalid symbol value for {0}: {1}",
+				   name, val);
 	  }
 
 	public override bool ValueP (Term term)
@@ -627,36 +599,19 @@ namespace System.Xml
       }
     }
 
-    private static void throw_exception (string msg)
-    {
-      throw new Exception (msg);
-    }
-
-    private static void throw_exception (string fmt, params object[] args)
+    internal struct CatchTag
     {
-      throw new Exception (String.Format (fmt, args));
-    }
+      private Term tag;
 
-    internal class CatchTag : IEquatable<CatchTag>
-    {
-      private object val;
+      public CatchTag (Symbol sym) { tag = new Term (sym); }
+      public CatchTag (Symbol sym, string msg) { tag = new Term (sym, msg); }
+      public CatchTag (ErrorTerm e) { tag = new Term (e); }
+      private CatchTag (int i) { tag = new Term (i); }
 
-      public CatchTag (Symbol sym) { val = (string) sym; }
-      private CatchTag (int i) { val = i; }
+      public Term Tag { get { return tag; } }
 
       public static CatchTag Return = new CatchTag (0);
       public static CatchTag Break = new CatchTag (1);
-
-      public static bool operator== (CatchTag t1, CatchTag t2)
-	{ return t1.val == t2.val; }
-
-      public static bool operator!= (CatchTag t1, CatchTag t2)
-	{ return t1.val != t2.val; }
-
-      public bool Equals (CatchTag tag) { return this.val == tag.val; }
-      public override bool Equals (object val) { return this.val == val; }
-
-      public override int GetHashCode () { return val.GetHashCode (); }
     }
 
     public class Domain
@@ -664,11 +619,14 @@ namespace System.Xml
       public Symbol name;
       public object context;
       public int depth = 0;
+      private Stack<Term> call_stack = new Stack<Term> ();
 
-      internal Dictionary<Symbol, TermType> termtypes
-	= new Dictionary<Symbol, TermType> ();
+      internal Dictionary<Symbol, MethodInfo> termtypes
+	= new Dictionary<Symbol, MethodInfo> ();
       internal Dictionary<Symbol, Function> functions
 	= new Dictionary<Symbol, Function> ();
+      internal Dictionary<Symbol, Function.Macro> macros
+	= new Dictionary<Symbol, Function.Macro> ();
       internal Dictionary<Symbol, Variable> variables
 	= new Dictionary<Symbol, Variable> ();
       internal Bindings bindings;
@@ -682,12 +640,31 @@ namespace System.Xml
 
       public Domain (Symbol name, Domain parent, object context) : this (name)
       {
-	termtypes = new Dictionary<Symbol, TermType> (parent.termtypes);
+	termtypes = new Dictionary<Symbol, MethodInfo> (parent.termtypes);
 	functions = new Dictionary<Symbol, Function> (parent.functions);
+	macros = new Dictionary<Symbol, Function.Macro> (parent.macros);
 	variables = new Dictionary<Symbol, Variable> (parent.variables);
 	this.context = context;
       }
 
+      public int CallStackCount { get { return call_stack.Count; } }
+
+      public void CallStackPush (Term term)
+      {
+	call_stack.Push (term);
+      }
+
+      public void CallStackPop ()
+      {
+	call_stack.Pop ();
+      }
+
+      public void CallStackPop (int count)
+      {
+	while (count < call_stack.Count)
+	  call_stack.Pop ();
+      }
+
       internal void Bind (Variable vari, Term value)
       {
 	bindings = Bindings.Bind (bindings, vari, value);
@@ -712,107 +689,122 @@ namespace System.Xml
 	  catch_count--;
       }
 
-      public bool Thrown {
-	get { return catch_count < catch_stack.Count; }
+      public bool Thrown () { return catch_count < catch_stack.Count; }
+
+      public bool Thrown (out bool caught)
+      {
+	if (catch_count < catch_stack.Count)
+	  {
+	    caught = catch_count == catch_stack.Count - 1;
+	    return true;
+	  }
+	caught = false;
+	return false;
       }
 
       internal void ThrowReturn ()
       {
-	foreach (CatchTag tag in catch_stack)
+	foreach (CatchTag elt in catch_stack)
 	  {
 	    catch_count--;
-	    if (tag == CatchTag.Return)
+	    if (elt.Tag == CatchTag.Return.Tag)
 	      break;
 	  }
       }
 
-      internal void ThrowBreak ()
+      internal bool ThrowBreak ()
       {
-	if (catch_stack.Peek () != CatchTag.Break)
-	  throw_exception ("No outer loop to break");
+	if (catch_stack.Peek ().Tag != CatchTag.Break.Tag)
+	  return false;
 	catch_count--;
+	return true;
       }
 
-      internal void ThrowTag (CatchTag tag)
+      internal void ThrowSymbol (Term tag)
       {
 	foreach (CatchTag elt in catch_stack)
 	  {
 	    catch_count--;
-	    if (elt == tag)
+	    if (elt.Tag.Matches (tag))
 	      break;
 	  }
       }
 
-      public void DefTerm (Symbol name, TermParser parser)
+      internal Term ThrowError (Term tag)
       {
-	if (termtypes.ContainsKey (name)
-	    || functions.ContainsKey (name))
-	  throw new Exception ("already defined: " + name);
-	termtypes[name] = new TermType (name, parser);
+	tag = tag.Clone ();
+	ErrorTerm e = tag.objval as ErrorTerm;
+	e.CallStack = call_stack.ToArray ();
+
+	foreach (CatchTag elt in catch_stack)
+	  {
+	    catch_count--;
+	    if (elt.Tag.Matches (tag))
+	      break;
+	  }
+	return tag;
       }
 
-      public void DefSubr (Builtin builtin, string str, bool setvar,
-			   int min_arg, int max_arg, params string[] aliases)
+      public void DefType (Type type)
       {
-	Symbol name = str;
-	if (termtypes.ContainsKey (name))
-	  throw new Exception ("already defined as termtype: " + name);
-	Function func = new Function.Subroutine (builtin, name, setvar,
-						 min_arg, max_arg);
-	functions[name] = func;
-	foreach (string a in aliases)
-	  functions[(Symbol) a] = func;
+	if (! type.IsSubclassOf (typeof (TermValue)))
+	  throw new Exception ("Not a subclass of TermValue: " + type);
+	BindingFlags flags = BindingFlags.Static | BindingFlags.NonPublic;
+	FieldInfo finfo = type.GetField ("name", flags);
+	if (finfo == null || finfo.FieldType != typeof (Symbol))
+	  throw new Exception ("No \"name\" field of string type: " + type);
+	Symbol name = (Symbol) finfo.GetValue (null);
+	if (termtypes.ContainsKey (name)
+	    || functions.ContainsKey (name)
+	    || macros.ContainsKey (name))
+	  throw new Exception ("already defined: " + name);
+	Type[] types = new Type[] { typeof (Domain), typeof (XmlNode) };
+	MethodInfo minfo = type.GetMethod ("Parser", types);
+	if (minfo == null || minfo.ReturnType != typeof (TermValue))
+	  throw new Exception ("No \"Parser\" method of correct type: " + type);
+	termtypes[name] = minfo;
       }
 
-      public void DefSpecial (Builtin builtin, string str,
-			      int min_arg, int max_arg,
-			      params string[] aliases)
+      static void check_func_head (Symbol name, bool with_var,
+				   int min_args, int max_args)
       {
-	Symbol name = str;
 	if (termtypes.ContainsKey (name))
-	  throw new Exception ("already defined as termtype: " + name);
-	Function func = new Function.SpecialForm (builtin, name,
-						  min_arg, max_arg);
-	functions[name] = func;
-	foreach (string a in aliases)
-	  functions[(Symbol) a] = func;
+	  throw new Exception (Qtype_conflict, "{0} is a Term type", name);
+	else if (macros.ContainsKey (name))
+	  throw new Exception (Qtype_conflict, "{0} is a macro", name);
+
+	Function func;
+	if (functions.TryGetValue (name, out func)
+	    && (func.with_var != with_var
+		|| func.min_args != min_args
+		|| func.max_args != max_args))
+	  throw new Exception (Qargument_mismatch, "");
       }
 
-      public void DefAlias (string alias, string str)
+      public void DefSubr (Func<Domain, Variable, Term[], Term> builtin,
+			   Symbol name, bool with_var,
+			   int min_args, int max_args)
       {
-	functions[(Symbol) alias] = functions[(Symbol) str];
+	check_func_head (name, with_var, min_args, max_args);
+	functions[name] = new Function.Subroutine (builtin, name, with_var,
+						   min_args, max_args);
       }
 
-      public void Defun (Symbol name, Symbol[] args, Term[] body,
-			 bool prototype)
+      public void DefSpecial (Func<Domain, Variable, Term[], Term> builtin,
+			      Symbol name, bool with_var,
+			      int min_args, int max_args)
       {
-	Function func;
-
-	if (termtypes.ContainsKey (name))
-	  throw new Exception ("already defined as termtype: " + name);
-	if (prototype || ! functions.TryGetValue (name, out func))
-	  {
-	    func = new Function.Lambda (this, name, args);
-	    functions[name] = func;
-	  }
-	if (! prototype)
-	  ((Function.Lambda) func).SetBody (body);
+	check_func_head (name, with_var, min_args, max_args);
+	functions[name] = new Function.SpecialForm (builtin, name, with_var,
+						    min_args, max_args);
       }
 
-      public void Defun (XmlNode node, bool prototype)
+      public void Defun (Symbol name, int min_arg, int max_arg,
+			 Variable[] args, Term[] body)
       {
-	Symbol name = node.Attributes[Qfname].Value;
-	if (termtypes.ContainsKey (name))
-	  throw new Exception ("already defined as termtype: " + name);
-	Function func;
-
-	if (prototype || ! functions.TryGetValue (name, out func))
-	  {
-	    func = new Function.Lambda (this, node);
-	    functions[name] = func;
-	  }
-	if (! prototype)
-	  ((Function.Lambda) func).SetBody (this, node);
+	check_func_head (name, false, min_args, max_args);
+	functions[name] = new Function.Lambda (name, min_args, max_args,
+					       args, body);
       }
 
       public void Defun (Function func)
@@ -820,20 +812,33 @@ namespace System.Xml
 	functions[func.name] = func;
       }
 
-      public void Defmacro (XmlNode node, bool prototype)
+      public void Defmacro (Symbol name, int min_arg, int max_arg,
+			    Variable[] args, Term[] body)
       {
-	Symbol name = node.Attributes[Qfname].Value;
 	if (termtypes.ContainsKey (name))
-	  throw new Exception ("already defined as termtype: " + name);
-	Function func;
+	  throw new Exception (Qtype_conflict, "{0} is a Term type", name);
+	else if (function.ContainsKey (name))
+	  throw new Exception (Qtype_conflict, "{0} is a function", name);
 
-	if (prototype || ! functions.TryGetValue (name, out func))
-	  {
-	    func = new Function.Macro (this, node);
-	    functions[name] = func;
-	  }
-	if (! prototype)
-	  ((Function.Macro) func).SetBody (this, node);
+	Function.Macro macro;
+	if (macros.TryGetValue (name, out macro)
+	    && (macro.min_args != min_args
+		|| macro.max_args != max_args))
+	  throw new Exception (Qargument_mismatch, "");
+
+	macros[name] = new Function.Macro (name, min_arg, max_arg, args, body);
+      }
+
+      public void DefAlias (Symbol alias, Symbol fname)
+      {
+	Function func;
+	if (functions.TryGetValue (alias, out func))
+	  throw new Exception (Qalready_defined,
+			       "Alread defined: {0}", alias);
+	if (! functions.TryGetValue (fname, out func))
+	  throw new Exception (Qunknown_function,
+			       "Unknown fucntion: {0}", fname);
+	functions[alias] = func;
       }
 
       public Variable Defvar (XmlNode node)
@@ -855,18 +860,17 @@ namespace System.Xml
 	    Symbol type = node.Name;
 	    XmlNodeList range_list = null;
 	    int nranges = 0;
-	    string val = node.InnerText;
+	    XmlNode n = node.NextSibling;
 
-	    node = node.NextSibling;
-	    if (node != null)
+	    if (n != null)
 	      {
-		range_list = node.ChildNodes;
+		range_list = n.ChildNodes;
 		nranges = range_list.Count;
 	      }
 
 	    if (type == Qinteger)
 	      {
-		int n = parse_integer (val);
+		int val = parse_integer (node);
 		int[] range = null;
 		if (range_list != null)
 		  {
@@ -876,20 +880,17 @@ namespace System.Xml
 			XmlNode nd = range_list[i];
 			if (nd.Name == Qrange)
 			  {
-			    range[i * 2]
-			      = parse_integer (nd.FirstChild.InnerText);
-			    range[i * 2 + 1]
-			      = parse_integer (nd.LastChild.InnerText);
+			    range[i * 2] = parse_integer (nd.FirstChild);
+			    range[i * 2 + 1] = parse_integer (nd.LastChild);
 			  }
 			else
 			  {
-			    range[i * 2]
-			      = range[i * 2 + 1]
-			      = parse_integer (nd.FirstChild.InnerText);
+			    range[i * 2] = range[i * 2 + 1]
+			      = parse_integer (nd.FirstChild);
 			  }
 		      }
 		  }
-		vari = DefvarInt (name, n, desc, range);
+		vari = DefvarInt (name, val, desc, range);
 	      }
 	    else if (type == Qstring)
 	      {
@@ -900,7 +901,7 @@ namespace System.Xml
 		    for (int i = 0; i < nranges; i++)
 		      range[i] = range_list[i].FirstChild.InnerText;
 		  }
-		vari = DefvarStr (name, val, desc, range);
+		vari = DefvarStr (name, node.InnerText, desc, range);
 	      }
 	    else if (type == Qsymbol)
 	      {
@@ -911,10 +912,10 @@ namespace System.Xml
 		    for (int i = 0; i < nranges; i++)
 		      range[i] = range_list[i].FirstChild.InnerText;
 		  }
-		vari = DefvarSym (name, (Symbol) val, desc, range);
+		vari = DefvarSym (name, (Symbol) node.InnerText, desc, range);
 	      }
 	    else
-	      throw new Exception ("Unknown type: " + type);
+	      Exception.Throw (Qparse_error, node, "Unknown type: {0}", type);
 	  }
 	else
 	  {
@@ -924,7 +925,6 @@ namespace System.Xml
 	      vari = new Variable (this, name, Zero);
 	    variables[name] = vari;
 	  }
-	Console.WriteLine (vari);
 	return vari;
       }
 
@@ -951,15 +951,20 @@ namespace System.Xml
 	    Variable.Int intvari = vari as Variable.Int;
 	    if (intvari == null)
 	      throw new Exception ("Variable type mismatch: " + name);
-	    if (range == null)
-	      range = intvari.Range;
-	    else if (! intvari.IsSubrange (range))
-	      throw new Exception ("Variable range mismatch: " + name);
-	    if (desc == null)
-	      desc = vari.Description;
+	    if (range != null)
+	      {
+		if (! intvari.IsSubrange (range))
+		  throw new Exception ("Variable range mismatch: " + name);
+		intvari.Range = range;;
+	      }
+	    if (desc != null)
+	      intvari.Description = desc;
+	  }
+	else
+	  {
+	    vari = new Variable.Int (this, name, n, desc, range);
+	    variables[name] = vari;
 	  }
-	vari = new Variable.Int (this, name, n, desc, range);
-	variables[name] = vari;
 	return vari;
       }
 
@@ -973,15 +978,20 @@ namespace System.Xml
 	    Variable.Str strvari = vari as Variable.Str;
 	    if (strvari == null)
 	      throw new Exception ("Variable type mismatch: " + name);
-	    if (range == null)
-	      range = strvari.Range;
-	    else if (! strvari.IsSubrange (range))
-	      throw new Exception ("Variable range mismatch: " + name);
-	    if (desc == null)
-	      desc = vari.Description;
+	    if (range != null)
+	      {
+		if (! strvari.IsSubrange (range))
+		  throw new Exception ("Variable range mismatch: " + name);
+		strvari.Range = range;
+	      }
+	    if (desc != null)
+	      strvari.Description = desc;
+	  }
+	else
+	  {
+	    vari = new Variable.Str (this, name, str, desc, range);
+	    variables[name] = vari;
 	  }
-	vari = new Variable.Str (this, name, str, desc, range);
-	variables[name] = vari;
 	return vari;
       }
 
@@ -995,15 +1005,20 @@ namespace System.Xml
 	    Variable.Sym symvari = vari as Variable.Sym;
 	    if (symvari == null)
 	      throw new Exception ("Variable type mismatch: " + name);
-	    if (range == null)
-	      range = symvari.Range;
-	    else if (! symvari.IsSubrange (range))
-	      throw new Exception ("Variable range mismatch: " + name);
-	    if (desc == null)
-	      desc = vari.Description;
+	    if (range != null)
+	      {
+		if (! symvari.IsSubrange (range))
+		  throw new Exception ("Variable range mismatch: " + name);
+		symvari.Range = range;
+	      }
+	    if (desc != null)
+	      symvari.Description = desc;
+	  }
+	else
+	  {
+	    vari = new Variable.Sym (this, name, sym, desc, range);
+	    variables[name] = vari;
 	  }
-	vari = new Variable.Sym (this, name, sym, desc, range);
-	variables[name] = vari;
 	return vari;
       }
 
@@ -1012,7 +1027,7 @@ namespace System.Xml
 	Function func;
 
 	if (! functions.TryGetValue (name, out func))
-	  throw new Exception ("Unknown function: " + name);
+	  throw new Exception (Qunknown_function, (strign) name);
 	return func;
       }
 
@@ -1060,17 +1075,13 @@ namespace System.Xml
 	return str;
       }
 
-      internal void DebugWrite (bool head, string fmt, params string[] arg)
+      internal void TraceWrite (string fmt, params string[] arg)
       {
-	if (debug_depth > depth)
+	if (trace_depth > depth)
 	  {
-	    if (head)
-	      {
-		Console.WriteLine ();
-		for (int i = 0; i < depth; i++)
-		  Console.Write (" ");
-	      }
-	    Console.Write (fmt, arg);
+	    for (int i = 0; i < depth; i++)
+	      Console.Write ("  ");
+	    Console.WriteLine (fmt, arg);
 	  }
       }
 
@@ -1091,32 +1102,49 @@ namespace System.Xml
       }
     }
 
-    public delegate Term Builtin (Domain domain, Variable vari, Term[] args);
-
     private static Domain basic = new Domain ("basic");
 
     static Xexpression ()
     {
-      basic.DefTerm ("funcall", Funcall.parser);
-      basic.DefTerm ("varref", Varref.parser);
-
-      basic.DefSubr (Fset, "set", true, 1, 1, "=");
-      basic.DefSubr (Fnot, "not", false, 1, 1, "!");
-      basic.DefSubr (Fadd, "add", true, 1, -1, "+");
-      basic.DefSubr (Fmul, "mul", true, 1, -1, "*");
-      basic.DefSubr (Fsub, "sub", true, 1, -1, "-");
-      basic.DefSubr (Fdiv, "div", true, 1, -1, "/");
-      basic.DefSubr (Fmod, "mod", true, 1, 2, "%");
-      basic.DefSubr (Flogior, "logior", true, 1, -1, "|");
-      basic.DefSubr (Flogand, "logand", true, 1, -1, "&");
-      basic.DefSubr (Flsh, "lsh", true, 1, 2, "<<");
-      basic.DefSubr (Frsh, "rsh", true, 1, 2, ">>");
-      basic.DefSubr (Feq, "eq", false, 2, -1, "==");
-      basic.DefSubr (Fnoteq, "noteq", false, 2, 2, "!=");
-      basic.DefSubr (Flt, "lt", false, 2, -1, "<");
-      basic.DefSubr (Fle, "le", false, 2, -1, "<=");
-      basic.DefSubr (Fgt, "gt", false, 2, -1, ">");
-      basic.DefSubr (Fge, "ge", false, 2, -1, ">=");
+      basic.DefType (typeof (Varref));
+      basic.DefType (typeof (Funcall));
+      basic.DefType (typeof (ErrorTerm));
+
+      basic.DefSubr (Fset, "set", true, 1, 1);
+      basic.DefAlias ("=", "set");
+      basic.DefSubr (Fnot, "not", false, 1, 1);
+      basic.DefAlias ("!", "not");
+      basic.DefSubr (Fadd, "add", true, 1, -1);
+      basic.DefAlias ("+", "add");
+      basic.DefSubr (Fmul, "mul", true, 1, -1);
+      basic.DefAlias ("*", "mul");
+      basic.DefSubr (Fsub, "sub", true, 1, -1);
+      basic.DefAlias ("-", "sub");
+      basic.DefSubr (Fdiv, "div", true, 1, -1);
+      basic.DefAlias ("/", "div");
+      basic.DefSubr (Fmod, "mod", true, 1, 2);
+      basic.DefAlias ("%", "mod");
+      basic.DefSubr (Flogior, "logior", true, 1, -1);
+      basic.DefAlias ("|", "logior");
+      basic.DefSubr (Flogand, "logand", true, 1, -1);
+      basic.DefAlias ("&", "logand");
+      basic.DefSubr (Flsh, "lsh", true, 1, 2);
+      basic.DefAlias ("<<", "lsh");
+      basic.DefSubr (Frsh, "rsh", true, 1, 2);
+      basic.DefAlias (">>", "rsh");
+      basic.DefSubr (Feq, "eq", false, 2, -1);
+      basic.DefAlias ("==", "eq");
+      basic.DefSubr (Fnoteq, "noteq", false, 2, 2);
+      basic.DefAlias ("!=", "noteq");
+      basic.DefSubr (Flt, "lt", false, 2, -1);
+      basic.DefAlias ("<", "lt");
+      basic.DefSubr (Fle, "le", false, 2, -1);
+      basic.DefAlias ("<=", "le");
+      basic.DefSubr (Fgt, "gt", false, 2, -1);
+      basic.DefAlias (">", "gt");
+      basic.DefSubr (Fge, "ge", false, 2, -1);
+      basic.DefAlias (">=", "ge");
+
       basic.DefSubr (Fappend, "append", true, 0, -1);
       basic.DefSubr (Fconcat, "concat", true, 0, -1);
       basic.DefSubr (Fnth, "nth", false, 2, 2);
@@ -1126,24 +1154,29 @@ namespace System.Xml
       basic.DefSubr (Feval, "eval", false, 1, 1);
       basic.DefSubr (Fbreak, "break", false, 0, 1);
       basic.DefSubr (Freturn, "return", false, 0, 1);
-
-      basic.DefSpecial (Fand, "and", 1, -1, "&&");
-      basic.DefSpecial (For, "or", 1, -1, "||");
-      basic.DefSpecial (Fprogn, "progn", 0, -1, "expr");
-      basic.DefSpecial (Fif, "if", 2, 3);
-      basic.DefSpecial (Fwhen, "when", 1, -1);
-      basic.DefSpecial (Floop, "loop", 1, -1);
-      basic.DefSpecial (Fwhile, "while", 1, -1);
-      basic.DefSpecial (Fcond, "cond", 1, -1);
-      basic.DefSpecial (Fforeach, "foreach", 2, -1);
-      basic.DefSpecial (Fquote, "quote", 1, 1);
-      basic.DefSpecial (Ftype, "type", 1, 1);
-      basic.DefSpecial (Fcatch, "catch", 2, 2);
-      basic.DefSpecial (Fthrow, "throw", 1, 2);
+      basic.DefSubr (Fthrow, "throw", false, 1, 2);
+
+      basic.DefSpecial (Fand, "and", false, 1, -1);
+      basic.DefAlias ("&&", "and");
+      basic.DefSpecial (For, "or", false, 1, -1);
+      basic.DefAlias ("||", "or");
+      basic.DefSpecial (Fprogn, "progn", false, 0, -1);
+      basic.DefAlias ("expr", "progn");
+      basic.DefSpecial (Fif, "if", false, 2, 3);
+      basic.DefSpecial (Fwhen, "when", false, 1, -1);
+      basic.DefSpecial (Floop, "loop", false, 1, -1);
+      basic.DefSpecial (Fwhile, "while", false, 1, -1);
+      basic.DefSpecial (Fcond, "cond", false, 1, -1);
+      basic.DefSpecial (Fforeach, "foreach", true, 2, -1);
+      basic.DefSpecial (Fquote, "quote", false, 1, 1);
+      basic.DefSpecial (Ftype, "type", false, 1, 1);
+      basic.DefSpecial (Fcatch, "catch", true, 2, -1);
     }
 
     private static Term Fset (Domain domain, Variable vari, Term[] args)
     {
+      if (vari == null)
+	return new Term (new ErrorTerm (Error.NoVariable, ""));
       vari.Value = args[0];
       return args[0];
     }
@@ -1401,7 +1434,8 @@ namespace System.Xml
 	  result = ((List<Term>) args[1].objval)[args[0].Intval];
 	}
       else
-	throw new Exception ("Term is not enumelable: " + args[1]);
+	throw new Exception (Qwrong_type,
+			     "{0} is not a string nor a list", args[1]);
       return result;
     }
 
@@ -1416,8 +1450,9 @@ namespace System.Xml
 
     private static Term Fins (Domain domain, Variable vari, Term[] args)
     {
+      if (vari == null)
+	throw new Exception (Qwrong_calling_format, "No vname attribute");
       Term term = vari.Value;
-
       if (term.IsStr)
 	{
 	  string str = term.Strval.Insert (args[0].Intval, args[1].Strval);
@@ -1426,12 +1461,15 @@ namespace System.Xml
       else if (vari.Value.IsList)
 	vari.Value.Listval.InsertRange (args[0].Intval, args[1].Listval);
       else
-	throw new Exception ("term is not collection: " + vari.Value);
+	throw new Exception (Qwrong_type, "{0} is not a string nor list",
+			     vari.Value);
       return vari.Value;
     }
 
     private static Term Fdel (Domain domain, Variable vari, Term[] args)
     {
+      if (vari == null)
+	throw new Exception (Qwrong_calling_format, "No vname attribute");
       if (vari.Value.IsStr)
 	{
 	  string str
@@ -1443,7 +1481,8 @@ namespace System.Xml
 	vari.Value.Listval.RemoveRange (args[0].Intval,
 				      args[1].Intval - args[0].Intval);
       else
-	throw new Exception ("term is not collection: " + vari.Value);
+	throw new Exception (Qwrong_type, "{0} is not a string nor a list",
+			     vari.Value);
       return vari.Value;
     }
 
@@ -1504,7 +1543,8 @@ namespace System.Xml
 
     private static Term Fbreak (Domain domain, Variable vari, Term[] args)
     {
-      domain.ThrowBreak ();
+      if (! domain.ThrowBreak ())
+	return domain.ThrowError (new Term (Error.NoOuterLoop, null));
       return args.Length == 0 ? Zero : args[0];
     }	  
 
@@ -1513,11 +1553,11 @@ namespace System.Xml
       Term result = Zero;
       try {
 	domain.Catch (CatchTag.Break);
-	while (! domain.Thrown)
+	while (! domain.Thrown ())
 	  foreach (Term arg in args)
 	    {
 	      result = arg.Eval (domain);
-	      if (domain.Thrown)
+	      if (domain.Thrown ())
 		return result;
 	    }
       } finally {
@@ -1531,11 +1571,11 @@ namespace System.Xml
       Term result = Zero;
       try {
 	domain.Catch (CatchTag.Break);
-	while (! domain.Thrown && args[0].Eval (domain).IsTrue)
+	while (! domain.Thrown () && args[0].Eval (domain).IsTrue)
 	  for (int i = 1; i < args.Length; i++)
 	    {
 	      result = args[i].Eval (domain);
-	      if (domain.Thrown)
+	      if (domain.Thrown ())
 		return result;
 	    }
       } finally {
@@ -1554,18 +1594,23 @@ namespace System.Xml
 	  if (result.IsTrue)
 	    {
 	      for (int i = 1; i < list.Count; i++)
-		result = list[i].Eval (domain);
+		{
+		  domain.depth++;
+		  result = list[i].Eval (domain);
+		  domain.depth--;
+		  if (domain.Thrown ())
+		    return result;
+		}		  
 	      return result;
 	    }
 	}
       return Zero;
     }
 
-    private static Term Fforeach (Domain domain, Variable vari,
-					Term[] args)
+    private static Term Fforeach (Domain domain, Variable vari, Term[] args)
     {
       Term result = args[0].Eval (domain);
-      if (domain.Thrown)
+      if (domain.Thrown ())
 	return result;
       List<Term> list = result.Listval;
       Bindings current = domain.bindings;
@@ -1579,7 +1624,7 @@ namespace System.Xml
 	      for (int i = 1; i < args.Length; i++)
 		{
 		  result = args[i].Eval (domain);
-		  if (domain.Thrown)
+		  if (domain.Thrown ())
 		    return result;
 		}
 	    } finally {
@@ -1594,7 +1639,7 @@ namespace System.Xml
 
     private static Term Fquote (Domain domain, Variable vari, Term[] args)
     {
-      return new Term (args[0]);
+      return args[0];
     }
 
     private static Term Ftype (Domain domain, Variable vari, Term[] args)
@@ -1610,116 +1655,174 @@ namespace System.Xml
       return TermTerm;
     }
 
-    public static Term Fcatch (Domain domain, Variable vari, Term[] args)
+    private static Term eval_terms (Domain domain, Term[] terms, int idx,
+				    out bool caught)
     {
-      Term result = Zero;
-      try {
-	domain.Catch (new CatchTag (args[0].Symval));
-	result = args[1].Eval (domain);
-      } finally {
-	domain.Uncatch ();
-      }
+      Term result= Zero;
+
+      caught = false;
+      for (int i = idx; i < args.Length; i++)
+	{
+	  result = args[i].Eval (domain);
+	  if (domain.Thrown (out caught))
+	    break;
+	}
       return result;
     }
 
-    public static Term Fthrow (Domain domain, Variable vari, Term[] args)
+    public static Term Fcatch (Domain domain, Variable vari, Term[] args)
     {
-      domain.ThrowTag (new CatchTag (args[0].Symval));
-      return (args.Length == 1 ? Zero : args[1]);
-    }
+      Term result;
+      bool caught = false;
 
-    public delegate TermValue TermParser (Domain domain, XmlNode node);
+      if (args.Length < 2)
+	throw new Exception (Error.WrongCallingFormat,
+			     "too fee arguments: {0}", args.Length);
+      if (args[0].IsError)
+	{
+	  int count = domain.CallStackCount;
 
-    public class TermType
-    {
-      public readonly Symbol type;
-      internal readonly TermParser parser;
+	  try {
+	    result = evaluate_terms (domain, args, 1, out caught);
+	  } catch (Exception e) {
+	    if (! args[0].Matches (e.ErrorTerm))
+	      throw e;
+	    ((ErrorTerm) e.ErrorTerm.objval).
+	    if (vari != null)
+	      vari.Value = e.ErrorTerm;
+	    domain.CallStackPop (count);
+	    return One;
+	  }
+	}
+      else if (args[0].IsSymbol)
+	{
+	  domain.Catch (new CatchTag (args[0].Symval));
+	  result = evaluate_terms (domain, args, 1, out caught);
+	  domain.Uncatch ();
+	}
+      if (vari != null)
+	vari.Value = result;
+      return Zero;
+    }
 
-      public TermType (Symbol type, TermParser parser)
-      {
-	this.type = type;
-	this.parser = parser;
-      }
+    public static Term Fthrow (Domain domain, Variable vari, Term[] args)
+    {
+      if (args[0].IsSymbol)
+	{
+	  domain.ThrowSymbol (args[0]);
+	  return (args[args.Length - 1]);
+	}
+      if (args[0].IsError)
+	return domain.ThrowError (args[0]);
+      return domain.ThrowError (new Term (Error.InvalidArgumentType,
+					  args[0].ToString ()));
     }
 
     public abstract class TermValue
     {
-      public virtual Term Eval (Domain domain) { return new Term (this); }
+      public virtual Term Eval (Domain domain) { return this; }
       public virtual TermValue Clone () { return this; }
+      public virtual bool IsTrue { get { return true; } }
+      public virtual bool Matches (TermValue other) { return Equals (other); }
+      public override abstract bool Equals (object obj);
+      public override abstract int GetHashCode ();
+      public abstract string ToString (bool detail);
     }
 
     private class Varref : TermValue
     {
-      private Symbol name;
+      private static Symbol name = "varref";
+      public static Symbol Name { get { return name; } }
+
+      private Symbol vname;
       private Variable vari;
 
-      public Varref (Symbol name) { this.name = name; }
+      public Varref (Symbol vname) { this.vname = vname; }
 
       public override Term Eval (Domain domain)
       {
 	if (vari == null || vari.domain != domain)
-	  vari = domain.GetVar (name, true);
+	  vari = domain.GetVar (vname, true);
 	return vari.Value;
       }
 
-      internal static TermValue parser (Domain domain, XmlNode node)
+      public static TermValue Parser (Domain domain, XmlNode node)
       {
 	return new Varref ((Symbol) node.Attributes[Qvname].Value);
       }
 
-      public override string ToString ()
+      public override bool Equals (object obj)
+      {
+	Varref varref = obj as Varref;
+	return (varref != null && varref.vari.name == vari.name);
+      }
+
+      public override int GetHashCode ()
       {
-	return "<varref vname=\"" + name + "\"/>";
+	return vari.name.GetHashCode ();
+      }	
+
+      public override string ToString () { return ToString (true); }
+
+      public override string ToString (bool detail)
+      {
+	return "<varref vname=\"" + vname + "\"/>";
       }
     }
 
     private class Funcall : TermValue
     {
+      private static Symbol name = "funcall";
+      public static Symbol Name { get { return name; } }
+
       internal Function func;
       internal Variable vari;
       internal Term[] args;
 
       public Funcall (Function func, Variable vari, Term[] args)
 	{
-	  if (args != null)
-	    {
-	      int nargs = args.Length;
-	      if (nargs < func.min_arg
-		  || (func.max_arg >= 0 && nargs > func.max_arg))
-		throw_exception ("Invalid number of arguments to {0}: ",
+	  int nargs = args.Length;
+
+	  if (nargs < func.min_args
+	      || (func.max_args >= 0 && nargs > func.max_args))
+	    throw new Exception (Qwrong_calling_format,
+				 "Wrong number of arguments to {0}: {1}",
 				 func.name, nargs);
-	    }
+	  if (! func.with_var && vari != null)
+	    throw new Exception (Qwrong_calling_format,
+				 "Wrong vname attribute to {0}: {1}",
+				 func.name, vari.name);
 	  this.func = func;
 	  this.vari = vari;
 	  this.args = args;
 	}
 
-      internal static TermValue parser (Domain domain, XmlNode node)
-	{
-	  Symbol fname = node.Name;
-	  XmlAttribute attr;
+      public static TermValue Parser (Domain domain, XmlNode node)
+      {
+	Symbol fname = node.Name;
+	XmlAttribute attr;
 
-	  if (fname == Qfuncall)
-	    fname = node.Attributes[Qfname].Value;
-	  Function func = domain.GetFunc (fname);
-	  Variable vari;
-	  attr = node.Attributes[Qvname];
-	  vari = attr == null ? null : domain.GetVar (attr.Value, true);
-	  XmlNodeList nlist = node.ChildNodes;
-	  int nargs = nlist.Count;
-	  Term[] args = new Term[nargs];
-	  for (int i = 0; i < nargs; i++)
-	    args[i] = new Term (domain, nlist[i]);
-	  return new Funcall (func, vari, args);
-	}
+	if (fname == Qfuncall)
+	  fname = node.Attributes[Qfname].Value;
+	Function func = domain.GetFunc (fname);
+	Variable vari;
+	attr = node.Attributes[Qvname];
+	vari = attr == null ? null : domain.GetVar (attr.Value, true);
+	XmlNodeList nlist = node.ChildNodes;
+	int nargs = nlist.Count;
+	Term[] args = new Term[nargs];
+	for (int i = 0; i < nargs; i++)
+	  args[i] = new Term (domain, nlist[i]);
+	return new Funcall (func, vari, args);
+      }
 
       public override Term Eval (Domain domain)
       {
-	domain.DebugWrite (true, ToString ());
+	domain.TraceWrite (ToString ());
 	domain.depth++;
 	Term result = func.Call (domain, vari, args);
 	domain.depth--;
-	domain.DebugWrite (true, " ==> {0}", result.ToString ());
+	domain.TraceWrite ("=> {0}", result.ToString ());
 	return result;
       }
 
@@ -1728,16 +1831,35 @@ namespace System.Xml
 	return new Funcall (func, vari, args);
       }
 
-      public override string ToString ()
+      public override bool Equals (object obj)
+      {
+	Funcall funcall = obj as Funcall;
+	return (obj != null
+		&& funcall.func == func
+		&& funcall.vari == vari
+		&& funcall.args.Length == args.Length);
+      }
+
+      public override int GetHashCode ()
+      {
+	return func.GetHashCode () ^ args.Length;
+      }
+
+      public override string ToString () { return ToString (true); }
+
+      public override string ToString (bool detail)
       {
 	string str = "<" + func.name;
 	if (vari != null)
 	  str += " vname=\"" + vari.name + "\"";
-	if (args == null)
+	if (args.Length == 0 || ! detail)
 	  return str + "/>";
 	str += ">";
 	if (func is Function.SpecialForm)
-	  str += String.Format ("({0})...", args.Length);
+	  {
+	    for (int i = 0; i < args.Length; i++)
+	      str += ".";
+	  }
 	else
 	  foreach (Term e in args)
 	    str += e;
@@ -1745,6 +1867,75 @@ namespace System.Xml
       }
     }
 
+    internal class ErrorTerm : TermValue
+    {
+      private static Symbol name = "error";
+      public static Symbol Name { get { return name; } }
+      
+      private readonly Symbol ename;
+      private string message;
+      private Term[] stack;
+
+      public ErrorTerm (Symbol ename, string message)
+	{
+	  this.ename = ename;
+	  this.message = message;
+	}
+
+      public static TermValue Parser (Domain domain, XmlNode node)
+      {
+	XmlAttribute attr = node.Attributes[Qename];
+	Symbol ename = attr == null ? Qnull : (Symbol) attr.Value;
+	string message = node.InnerText;
+	return new ErrorTerm (ename, message);
+      }
+
+      public Term[] CallStack {	get { return stack; } set { stack = value; } }
+
+      public override TermValue Clone ()
+      {
+	return new ErrorTerm (ename, message);
+      }
+
+      public override bool Equals (object obj)
+      {
+	ErrorTerm e = obj as ErrorTerm;
+	if (e == null || e.ename != ename || e.message != message
+	    || (e.stack == null ? stack != null
+		: (stack == null || e.stack.Length != stack.Length)))
+	  return false;
+	if (stack != null)
+	  for (int i = 0; i < stack.Length; i++)
+	    if (! stack[i].Equals (e.stack[i]))
+	    return false;
+	return true;
+      }
+
+      public override int GetHashCode ()
+      {
+	return ename.GetHashCode ();
+      }
+
+      public override bool Matches (TermValue term)
+      {
+	ErrorTerm e = term as ErrorTerm;
+	return (e != null && (ename == Qnull || e.ename == ename));
+      }
+
+      public override string ToString () { return ToString (true); }
+
+      public override string ToString (bool detail)
+	{
+	  string str = "<error type=\"" + ename + "\">";
+	  if (message != null)
+	    str += message;
+	  if (stack != null)
+	    for (int i = 0; i < stack.Length; i++)
+	      str += stack[i].ToString (false);
+	  return str + "</error>";
+	}
+    }
+
     public struct Term
     {
       public int intval;
@@ -1758,8 +1949,13 @@ namespace System.Xml
       public Term (string str) { intval = 0; objval = str; }
       // <list>...</list>
       public Term (List<Term> list) { intval = 0; objval = list; }
+      // <error ename="ERROR-NAME">ERROR-MESSASGE</error>
+      public Term (Symbol name, string message)
+	{
+	  intval = 0;
+	  objval = new ErrorTerm (name, message);
+	}
 
-      public Term (Term term) { intval = term.intval; objval = term.objval; }
       public Term (TermValue obj) { intval = 0; objval = obj; }
 
       public Term (Domain domain, XmlNode node)
@@ -1768,7 +1964,7 @@ namespace System.Xml
 
 	  if (name == Qinteger)
 	    {
-	      intval = parse_integer (node.InnerText);
+	      intval = parse_integer (node);
 	      objval = null;
 	    }
 	  else
@@ -1788,13 +1984,13 @@ namespace System.Xml
 		}
 	      else
 		{
-		  TermType term_type;
+		  MethodInfo minfo;
 
-		  if (domain.termtypes.TryGetValue (name, out term_type))
-		    objval = term_type.parser (domain, node);
+		  if (domain.termtypes.TryGetValue (name, out minfo))
+		    objval = (TermValue) minfo.Invoke (null, new Object[] { domain, node});
 		  else
 		    {
-		      Funcall funcall = (Funcall) Funcall.parser (domain, node);
+		      Funcall funcall = (Funcall) Funcall.Parser (domain, node);
 		      if (funcall.func is Function.Macro)
 			{
 			  Term result = funcall.Eval (domain);
@@ -1840,7 +2036,8 @@ namespace System.Xml
       public object Objval {
 	get {
 	  if (objval == null)
-	    throw new Exception ("term is an integer: " + this);
+	    throw new Exception (Qwrong_type,
+				 "term is an integer: {0}", this);
 	  return objval;
 	}
       }
@@ -1848,7 +2045,7 @@ namespace System.Xml
       public int Intval {
 	get {
 	  if (objval != null)
-	    throw new Exception ("term is not integer: " + this);
+	    throw new Exception (Qwrong_type, "{0} is not an integer", this);
 	  return intval;
 	}
       }
@@ -1856,7 +2053,7 @@ namespace System.Xml
       public string Strval {
 	get {
 	  if (! IsStr)
-	    throw new Exception ("term is not string: " + this);
+	    throw new Exception (Qwrong_type, "{0} is not a string", this);
 	  return (string) objval;
 	}
       }
@@ -1864,7 +2061,7 @@ namespace System.Xml
       public string Symval {
 	get {
 	  if (! IsSymbol)
-	    throw new Exception ("term is not symbol: " + this);
+	    throw new Exception (Qwrong_type, "{0} is not a symbol", this);
 	  return (Symbol) objval;
 	}
       }
@@ -1872,7 +2069,7 @@ namespace System.Xml
       public List<Term> Listval {
 	get {
 	  if (! IsList)
-	    throw new Exception ("term is not list: " + this);
+	    throw new Exception (Qwrong_type, "{0} is not a list");
 	  return (List<Term>) objval;
 	}
       }
@@ -1883,27 +2080,27 @@ namespace System.Xml
 		  ? (intval != 0)
 		  : objval is List<Term>
 		  ? (((List<Term>) objval).Count != 0)
+		  : objval is TermValue
+		  ? ((TermValue) objval).IsTrue
 		  : true);
 	}
       }
+
       public bool IsInt { get { return (objval == null); } }
       public bool IsStr { get { return (objval is string); } }
       public bool IsSymbol { get { return (objval is Symbol); } }
       public bool IsList { get { return (objval is List<Term>); } }
+      public bool IsError { get { return (objval is ErrorTerm); } }
 
-      public bool IsType (Type type)
-      {
-	return (objval == null ? type == typeof (int)
-		: type == objval.GetType ());
-      }
-
-      public Term Eval (Domain domain)
+      private Term Eval (Domain domain)
       {
-	if (objval == null || objval is Symbol || objval is string)
+	if (objval == null || objval is Symbol || objval is string
+	    || objval is List<Term>)
 	  return this;
-	if (objval is List<Term>)
-	  return new Term ((List<Term>) objval);
-	return ((TermValue) objval).Eval (domain);
+	domain.CallStackPush (this);
+	Term result = ((TermValue) objval).Eval (domain);
+	domain.CallStackPop ();
+	return result;
       }
 
       public Term Clone ()
@@ -1919,7 +2116,71 @@ namespace System.Xml
 	return new Term (((TermValue) objval).Clone ());
       }
 
-      public override string ToString ()
+      public static bool operator== (Term t1, Term t2)
+	{
+	  return t1.Equals (t2);
+	}
+
+      public static bool operator!= (Term t1, Term t2) { return ! (t1 == t2); }
+
+      public override bool Equals (object obj)
+      {
+	if (! (obj is Term))
+	  return false;
+	Term term = (Term) obj;
+	if (IsInt)
+	  return term.IsInt && term.Intval == Intval;
+	if (IsStr)
+	  return term.IsStr && term.Strval == Strval;
+	if (IsSymbol)
+	  return term.IsSymbol && term.Symval == Symval;
+	if (IsList)
+	  {
+	    if (! term.IsList)
+	      return false;
+	    List<Term> l1 = objval as List<Term>;
+	    List<Term> l2 = term.objval as List<Term>;
+
+	    if (l1.Count != l2.Count)
+	      return false;
+	    for (int i = 0; i < l1.Count; i++)
+	      if (! l1[i].Equals (l2[i]))
+		return false;
+	    return true;
+	  }
+	return ((TermValue) objval).Equals (obj);
+      }
+
+      public override int GetHashCode () { return intval; }
+
+      public bool Matches (Term term)
+      {
+	if (IsInt)
+	  return term.IsInt && term.Intval == Intval;
+	if (IsStr)
+	  return term.IsStr && term.Strval == Strval;
+	if (IsSymbol)
+	  return term.IsSymbol && term.Symval == Symval;
+	if (IsList)
+	  {
+	    if (! term.IsList)
+	      return false;
+	    List<Term> l1 = objval as List<Term>;
+	    List<Term> l2 = term.objval as List<Term>;
+
+	    if (l1.Count > l2.Count)
+	      return false;
+	    for (int i = 0; i < l1.Count; i++)
+	      if (! l1[i].Equals (l2[i]))
+		return false;
+	    return true;
+	  }
+	return ((TermValue) objval).Matches ((TermValue) term.objval);
+      }
+
+      public override string ToString () { return ToString (true); }
+
+      public string ToString (bool detail)
       {
 	string str;
 
@@ -1931,129 +2192,226 @@ namespace System.Xml
 	  str = "<string>" + objval + "</string>";
 	else if (objval is List<Term>)
 	  {
-	    str = "<list>";
-	    foreach (Term e in (List<Term>) objval)
-	      str += e;
-	    str += "</list>";
+	    if (detail)
+	      {
+		str = "<list>";
+		foreach (Term e in (List<Term>) objval)
+		  str += e;
+		str += "</list>";
+	      }
+	    else
+	      str = "<list/>";
 	  }
 	else if (objval is Term)
 	  str = "<quote>" + objval + "</quote>";
-	else if (objval is TermValue)
-	  str = ((TermValue) objval).ToString ();
 	else
-	  throw new Exception ("invalid Term object: " + objval);
+	  str = ((TermValue) objval).ToString (detail);
 	return str;
       }
     }
 
-    static private Term Zero = new Term (0);
-    static private Term One = new Term (1);
-    static private Term TermInt = new Term (Qinteger);
-    static private Term TermStr = new Term (Qstring);
-    static private Term TermSymbol = new Term (Qsymbol);
-    static private Term TermList = new Term (Qlist);
-    static private Term TermTerm = new Term ((Symbol) "term");
+    private static Term Zero = new Term (0);
+    private static Term One = new Term (1);
+    private static Term TermInt = new Term (Qinteger);
+    private static Term TermStr = new Term (Qstring);
+    private static Term TermSymbol = new Term (Qsymbol);
+    private static Term TermList = new Term (Qlist);
+    private static Term TermTerm = new Term ((Symbol) "term");
 
-    internal static int parse_integer (string str)
+    private static int parse_integer (XmlNode node)
     {
+      str = node.InnerText;
       int len = str.Length;
       bool negative = false;
+      int i, c;
+
+      if (len == 1 && str[0] == '?')
+	return str[1];
+      if (len > 2
+	  && str[1] == 'x' && ((c = str[0]) == '0' || c == '#'))
+	{
+	  if (! int.TryParse (str.SubString (2), NumberStyles.HexNumber, null,
+			      out i))
+	    Exception.Throw (Qparse_error, node, "Invalid integer");
+	  return i;
+	}
+      if (! int.TryParse (str, out i))
+	Exception.Throw (Qparse_error, node, "Invalid integer");
+      return i;
+    }
+
+    static bool parse_error (XmlNode node, out Term term)
+    {
+      try {
+	term = new Term (node.OuterXml);
+      } catch {
+	term = memory_error;
+      }
+      return false;
+    }
 
-      if (len <= 1)
-	return (len == 0 ? 0 : str[0] - '0');
+    static bool parse_error (XmlNode node, out Term[] terms)
+    {
+      try {
+	terms = new Term[] { new Term (node.OuterXml) };
+      } catch {
+	terms = new Term[] { memory_error };
+      }
+      return false;
+    }
 
-      int c = str[0];
-      int i;
+    private static Variable[] parse_args (Domain domain, XmlNode node,
+					  out int min_args, out int max_args)
+    {
+      int nfixed = 0;
+      int noptional = 0;
+      int nrest = 0;
+      Variable[] args;
 
-      if (c == '?')
-	return str[1];
-      if ((c == '0' || c == '#') && str[1] == 'x')
+      node = node.FirstChild;
+      if (node != null && node.Name == Qargs)
 	{
-	  i = 0;
-	  for (int idx = 2; idx < len; idx++)
+	  XmlNode n;
+	  for (n = node.FirstChild; n != null; n = n.NextSibling)
 	    {
-	      c = str[idx];
-	      if (c < '0')
-		break;
-	      else if (c <= '9')
-		i = i * 16 + (c - '0');
-	      else if (c < 'A')
-		break;
-	      else if (c <= 'F')
-		i = i * 16 + (c - 'A');
-	      else if (c < 'a')
-		break;
-	      else if (c <= 'f')
-		i = i * 16 + (c - 'a');
+	      if (n.Name == Qfixed)
+		nfixed += n.ChildNodes.Count;
+	      else if (n.Name == Qoptional)
+		noptional += n.ChildNodes.Count;
+	      else if (n.Name == Qrest)
+		nrest++;
 	      else
-		break;
+		throw new Exception (Qinvalid_argument_type, n);
 	    }
-	  return i;
+	  min_args = nfixed;
+	  max_args = nfixed + noptional + nrest;
+	  args = new Variable[max_args];
+	  n = node.FirstChild;
+	  for (int i = 0; i < max_args; n = n.NextSibling)
+	    {
+	      for (XmlNode nn = n.FirstChild; nn != null; nn = nn.NextSibling)
+		args[i++] = domain.Defvar ((Symbol) nn.Attributes[0].Value);
+	    }
+	  if (nrest == 1)
+	    max_args = - max_args;
 	}
-      if (c == '-')
-	negative = true;
-      i = c - '0';
-      for (int idx = 1; idx < len; idx++)
+      else
 	{
-	  c = str[idx];
-	  if (c < '0' || c > '9')
-	    break;
-	  i = i * 10 + (c - '0');
+	  min_args = max_args = 0;
+	  args = new Variable[0];
 	}
-      return negative ? - i : i;
+      return args;
     }
 
-    private Term[] terms;
+    public static Symbol parse_defun_head (Domain domain, XmlNode node)
+    {
+      Symbol name = node.Attributes[Qfname].Value;
+      int min_args, max_args;
+      Variable[] args;
+
+      try {
+	args = parse_head (domain, node, out min_args, out max_args);
+	if (node.Name == Qdefun)
+	  domain.Defun (name, min_args, max_args, args, null);
+	else
+	  domain.Defmacro (name, min_args, max_args, args, null);
+      } catch (Exception e) {
+	if (e.ErrorNode == null)
+	  e.ErrorNode = node;
+	throw e;
+      } catch (System.Exception e) {
+	throw new Exception (node, e);
+      }
+      return name;
+    }
 
-    public static Term[] ParseTerms (Domain domain, XmlNode node)
+    public static void parse_defun_body (Domain domain, XmlNode node)
     {
-      int nterms = 0;
-      for (XmlNode n = node; n != null; n = n.NextSibling)
-	if (n.NodeType == XmlNodeType.Element)
-	  {
-	    if (n.Name == Qdefun)
-	      domain.Defun (n, true);
-	    else if (n.Name == Qdefmacro)
-	      domain.Defmacro (n, true);
-	    else if (n.Name == Qdefvar)
-	      domain.Defvar (n);
-	    else
-	      nterms++;
-	  }
-      Term[] terms = new Term[nterms];
-      int i = 0;
-      for (XmlNode n = node; n != null; n = n.NextSibling)
-	if (n.NodeType == XmlNodeType.Element)
-	  {
-	    if (n.Name == Qdefun)
-	      domain.Defun (n, false);
-	    else if (n.Name == Qdefmacro)
-	      domain.Defmacro (n, false);
-	    else if (n.Name != Qdefvar)
-	      terms[i++]= new Term (domain, n);
-	  }
-      return terms;
+      Symbol name = node.Attributes[Qfname].Value;
+      Function func = domain.GetFunc (name);
+
+      for (node = node.FirstChild; node != null; node = node.NextSibling)
+	if (node.Name != Qdescription
+	    && node.Name != Qargs)
+	  break;
+      Term[] body = Parse (domain, node, null);
+      if (node.Name == Qdefun)
+	((Function.Lambda) func).SetBody (body);
+      else
+	((Function.Macro) func).SetBody (body);
     }
 
-    public static Term Eval (Domain domain, Term[] terms)
+    public static Term Parse (Domain domain, XmlNode node)
     {
-      Term result = new Term (0);
-      foreach (Term term in terms)
+      Symbol name = node.Name;
+
+      if (name == Qinteger)
+	return new Term (parse_integer (node));
+      if (name == Qsymbol)
+	return new Term ((Symbol) node.InnerText);
+      if (name == Qstring)
+	return new Term (node.InnerText);
+      if (name == Qlist)
 	{
-	  result = term;
-	  if (result.Objval is Funcall)
-	    while ((result = result.Eval (domain)).Objval is Funcall);
+	  List<Term> list = new List<Term> ();
+	  for (node = node.FirstChild; node != null;
+	       node = node.NextSibling)
+	    list.Add (Parse (domain, node));
+	  return new Term (list);
 	}
-      return result;
+      if (name == Qdefun || name == Qdefmacro)
+	{
+	  name = parse_defun_head (domain, node);
+	  parse_defun_body (domain, node);
+	  return new Term (name);
+	}
+      if (name == Qdefvar)
+	{
+	  name = parse_defvar (domain, node);
+	  return new Term (name);
+	}
+      MethodInfo minfo;
+      if (domain.termtypes.TryGetValue (name, out minfo))
+	{
+	  object[] arg = new object[] { domain, node };
+	  return new Term ((TermValue) minfo.Invoke (null, arg));
+	}
+
+      Funcall funcall = (Funcall) Funcall.Parser (domain, node);
+      if (funcall.func is Function.Macro)
+	return funcall.Eval (domain);
+      return new Term (funcall);
     }
 
+    private static bool default_stop (XmlNode n) { return n == null; }
 
-    public Xexpression (Domain domain, XmlNode node)
+    public static List<Term> Parse (Domain domain, XmlNode node,
+				    Func<XmlNode, bool> stop)
     {
-      terms = ParseTerms (domain, node);
+      if (stop == null)
+	stop = default_stop;
+
+      XmlNode n;
+      for (n = node; ! stop (n); n = n.NextSibling)
+	if (n.NodeType == XmlNodeType.Element
+	    && (n.Name == Qdefun || n.Name == Qdefmacro))
+	  parse_defun_head (domain, n);
+
+      List<Term> terms = new List<Term> ();
+      for (; node != n; node = node.NextSibling)
+	if (node.NodeType == XmlNodeType.Element)
+	  {
+	    if (node.Name == Qdefun || node.Name == Qdefmacro)
+	      parse_defun_body (domain, node);
+	    else if (node.Name == Qdefvar)
+	      parse_defvar (domain, node);
+	    else
+	      terms.Add (Parse (domain, node));
+	  }
+      return terms;
     }
 
-    public Xexpression (Domain domain, string url)
+    public static List<Term> Parse (Domain domain, string url)
     {
       XmlDocument doc = new XmlDocument (Symbol.NameTable);
       XmlNode node;
@@ -2069,34 +2427,20 @@ namespace System.Xml
 	    throw new Exception ("Node <expr> not found");
 	  node = doc.ReadNode (reader);
 	}
-      terms = ParseTerms (domain, node.FirstChild);
+      return Parse (domain, node.FirstChild, null);
     }
 
-    public Term Eval (Domain domain)
+    public static Term Eval (Domain domain, List<Term> terms)
     {
       Term result = Zero;
 
-      domain.depth = 0;
-      try {
-	domain.Catch (CatchTag.Return);
-	foreach (Term term in terms)
-	  {
-	    result = term.Eval (domain);
-	    if (domain.Thrown)
-	      return result;
-	  }
-      } finally {
-	domain.Uncatch ();
-      }
+      foreach (Term term in terms)
+	{
+	  result = term.Eval (domain);
+	  if (domain.Thrown)
+	    return result;
+	}
       return result;
     }
-
-    public override string ToString ()
-    {
-      string str = "";
-      for (int i = 0; i < terms.Length; i++)
-	str += terms[i];
-      return str;
-    }
   }
 }