Index: xotcl/ChangeLog
===================================================================
diff -u -r0fb94b7893b3423b536af13fa081e7190e0ec0a2 -r225b8b992e16760eca2a7fa7bf51533499c7cc84
--- xotcl/ChangeLog	(.../ChangeLog)	(revision 0fb94b7893b3423b536af13fa081e7190e0ec0a2)
+++ xotcl/ChangeLog	(.../ChangeLog)	(revision 225b8b992e16760eca2a7fa7bf51533499c7cc84)
@@ -1,3 +1,10 @@
+2004-07-20 Gustaf.Neumann@wu-wien.ac.at
+        * fixed a potential crash when a instmixin was registered on itself
+
+2004-07-19  Uwe Zdun <uwe.zdun@wu-wien.ac.at>
+        * added checkoptions to non pos args
+	* added tests & documentation of non pos args
+
 2004-07-18 Gustaf.Neumann@wu-wien.ac.at
         * added removal of autom4te.cache to distclean
         * make doc added to "all" target
Index: xotcl/Makefile
===================================================================
diff -u -r0fb94b7893b3423b536af13fa081e7190e0ec0a2 -r225b8b992e16760eca2a7fa7bf51533499c7cc84
--- xotcl/Makefile	(.../Makefile)	(revision 0fb94b7893b3423b536af13fa081e7190e0ec0a2)
+++ xotcl/Makefile	(.../Makefile)	(revision 225b8b992e16760eca2a7fa7bf51533499c7cc84)
@@ -12,7 +12,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: Makefile,v 1.11 2004/07/18 09:49:03 neumann Exp $
+# RCS: @(#) $Id: Makefile,v 1.12 2004/07/20 12:57:59 neumann Exp $
 
 #========================================================================
 # Add additional lines to handle any additional AC_SUBST cases that
@@ -118,7 +118,7 @@
 PACKAGE_NAME	= xotcl
 PACKAGE_VERSION	= 1.2.1
 CC		= gcc -pipe
-CFLAGS_DEFAULT	= -O
+CFLAGS_DEFAULT	= -O -g
 CFLAGS_WARNING	= -Wall -Wconversion -Wno-implicit-int
 CLEANFILES	= *.o *.a *.so *~ core gmon.out config.*
 EXEEXT		= 
Index: xotcl/doc/langRef.xotcl
===================================================================
diff -u -rf7894d9be99a8da3a04218abcdb9bd46b6d625c8 -r225b8b992e16760eca2a7fa7bf51533499c7cc84
--- xotcl/doc/langRef.xotcl	(.../langRef.xotcl)	(revision f7894d9be99a8da3a04218abcdb9bd46b6d625c8)
+++ xotcl/doc/langRef.xotcl	(.../langRef.xotcl)	(revision 225b8b992e16760eca2a7fa7bf51533499c7cc84)
@@ -1,4 +1,4 @@
-# $Id: langRef.xotcl,v 1.1 2004/05/23 22:50:39 neumann Exp $
+# $Id: langRef.xotcl,v 1.2 2004/07/20 12:57:59 neumann Exp $
 package provide XOTcl-langRef 1.2
 package require Tcl
 
@@ -63,7 +63,7 @@
     <@/p>
 
   }
-  date { $Date: 2004/05/23 22:50:39 $ }
+  date { $Date: 2004/07/20 12:57:59 $ }
 }
 
 ##
@@ -376,6 +376,9 @@
 
       <@li><@TT>objName info invar</@TT>: Returns object invariants.
 
+      <@li><@TT>objName info nonposargs methodName</@TT>: Returns
+      non-positional arg list of methodName
+
       <@li><@TT>objName info metadata ?pattern?</@TT>: 
       Returns available metadata options.
 
@@ -575,6 +578,7 @@
 
 @ Object instproc proc {
   name "method name"
+  ?non-pos-args?" "optinal non-positional arguments"
   args "method arguments"
   body "method body"
   "?preAssertion?" "optional assertions that must hold before the proc executes"
@@ -826,6 +830,9 @@
 
       <@li><@TT>ClassName info instinvar</@TT>: 
       Returns class invariants.
+	
+      <@li><@TT>ClassName info instmixin methodName</@TT>: returns list of 
+      non-positional args of methodName
 
       <@li><@TT>ClassName info instmixin</@TT>: 
       Returns the list of instmixins of this class.
@@ -966,6 +973,7 @@
 
 @ Class instproc instproc {
   name "instance method name"
+  ?non-pos-args?" "optinal non-positional arguments"
   args "instance method arguments"
   body "instance method body"
   "?preAssertion?" "optional assertions that must hold before the proc executes"
Index: xotcl/doc/tutorial.html
===================================================================
diff -u -rf7894d9be99a8da3a04218abcdb9bd46b6d625c8 -r225b8b992e16760eca2a7fa7bf51533499c7cc84
--- xotcl/doc/tutorial.html	(.../tutorial.html)	(revision f7894d9be99a8da3a04218abcdb9bd46b6d625c8)
+++ xotcl/doc/tutorial.html	(.../tutorial.html)	(revision 225b8b992e16760eca2a7fa7bf51533499c7cc84)
@@ -1,10 +1,10 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-<!-- $Id: tutorial.html,v 1.1 2004/05/23 22:50:39 neumann Exp $ -->
+<!-- $Id: tutorial.html,v 1.2 2004/07/20 12:57:59 neumann Exp $ -->
 <HTML>
 <HEAD>
 	<TITLE>XOTcl - Tutorial</TITLE>
 	<META NAME="AUTHOR" CONTENT="Gustaf Neumann and Uwe Zdun">
-	<META NAME="DOCNUMBER" CONTENT="1.2.0">
+	<META NAME="DOCNUMBER" CONTENT="1.2.1">
 	<META NAME="CHANGEDBY" CONTENT="Gustaf ">
 <STYLE>
 BODY	{
@@ -98,6 +98,7 @@
 	      Relationships</A> 
 		<LI><A HREF="#meta-classes">Meta-Classes</A>
                 <LI><A HREF="#destroy-logic">Create, Destroy, and Recreate Methods</A>
+	        <LI><A HREF="#non-pos-args">Non-positional Arguments</A>
 	</UL>
         </P>
 	<LI><P STYLE="margin-bottom: 0in"><A HREF="#interceptors">Message
@@ -1650,6 +1651,7 @@
 </pre>
 </p>
 
+
 <H2>
 <A NAME="destroy-logic"></A>Create, Destroy, and Recreate Methods
 </H2>
@@ -1758,8 +1760,150 @@
   <tt>puts</tt> class=[c2 <tt>info</tt> class]
 </pre>
 
+<H2>
+<A NAME="non-pos-args"></A>Non-positional Arguments
+</H2>
+<P>
+<P>
+So far we have introduces methods only with positional arguments: that
+is, the position of an argument in the argument list determines to
+which local variable the argument is bound, when the method is
+invoked. Sometimes non-positional arguments -- arguments that carry
+both a name and a value when the method is invoked -- are
+useful. Before a non-positional argument can be used, it must be
+defined in the method definition using the following syntax:
+</P>
+<pre CLASS="code">
+ <em>className</em> <tt>instproc</tt> methodName <em>?non-pos-args?</em> args body ?assertions
+ <em>objName</em> <tt>proc</tt> methodName <em>?non-pos-args?</em> args body ?assertions
+</pre>
+<P>
+The non-positional arguments are defined with the following syntax:
+</P>
+<pre CLASS="code">
+ {-name?:checkoption1, checkoption2, ...? default value} {-name?:checkoption1, checkoption2, ...? ?default value?} ...
+</pre>
+<p>
+Only the name of the non-positional argument is really required, all
+other parts of this syntax are optional.
+</p>
+<p>
+Let's consider a simple example, where a method with two
+non-positional args is defined; one has only a name ("a"), and one has
+a name and a default value (b):
+</p>
+<pre CLASS="code">
+ <tt>Object</tt> o
+ o <tt>proc</tt> y {-a {-b {1 2 3}}} {x y} {
+     puts "$a $b $x $y"
+ }
+</pre><P>
+We can invoke this method as follows:
+</p>
+<pre CLASS="code">
+ o y -b 4 5 -a 1 3 4
+</pre><P>
 
+Here, the order of "a" and "b" can be changed; hence the name
+non-positional arguments.  As "b" has a default value, we do not need
+to provide a value for it. In the following invocation "b" has the
+value "1 2 3":
+</p>
+<pre CLASS="code">
+ o y -a 1 3 4
+</pre><P>
 
+The ordinary arguments start after the last non-positional argument
+(here: "3 4").  We can explicitly end the non-positional arguments by
+using "--". This is useful if we want to provide arguments that contain dashes ("-"), e.g.:
+</p>
+<pre CLASS="code">
+ o y -a 1 -- -b -c
+</pre><P>
+
+Sometimes we want to check or control the non-positional
+arguments. For instance, in the above invocation, we might want to
+check that "a" is not forgotten, because otherwise the method cannot
+execute properly. This is the role of the checkoptions. There are two
+predefined checkoptions: "required" and "boolean". "required" checks
+whether a non-positional argument is given, "boolean" checks that a
+non-positional argument is of boolean type. For instance:
+</p>
+<pre CLASS="code">
+<tt>Class</tt> P
+ P <tt>instproc</tt> y {-a:required {-b:boolean {true}}} {} {
+     puts "$a $b"
+ }
+ P p
+</pre><P>
+
+This method requires "a", and "b" needs to be of type boolean (is has
+the default value "true"). This invocation is valid:
+</p>
+<pre CLASS="code">
+ p y -a 1 -b 0
+</pre><P>
+
+This invocation is invalid, because "a" is missing, and "b" is not a
+Tcl boolean type:
+</p>
+<pre CLASS="code">
+ p y -b " a b v"
+</pre><P>
+
+The checkoptions are extensible. In fact, they are defined in an
+object "xotcl::nonPosArgs". We can extend this object with new
+methods and we can provide other checkobjects. A check option method
+has the following syntax:
+</P>
+<pre CLASS="code">
+ <em>object|class</em> <tt>proc|instproc</tt> methodName {?optional arguments argName args} {
+  ...
+ }
+</pre>
+<p>
+
+"argName" is here used to denote the name of the argument, and "args"
+get the argument's current value after all non-positional arguments
+have been applied. If the argument it is not given and has no default
+value, "args" is empty.
+
+</p>
+
+<p>
+In seldom cases, more flexiblity might be required. Using the
+checkoption "checkobj" we can switch the object that is used for
+checking the options. This can be done at any place in the checkoption
+list. The following example defines new checkoptions in a separate
+object and switches to this object for checking. Then the check is
+switched back to "xotcl::nonPosArgs" to invoke the predefined option
+"required":
+
+</P>
+<pre CLASS="code">
+Object colorchecker
+colorchecker proc color {a b c argName args} {
+    puts "$a $b $c"
+}
+colorchecker proc reddish {argName args} {
+    puts "reddish"
+}
+o proc color {{{-color:checkobj colorchecker,color must be red,reddish,checkobj xotcl::nonPosArgs, required} red}} {} {
+    puts "$b $arg"
+}
+</pre></p>
+
+Of course, the non-positional arguments can also be introspected. The
+following "info" options return the non-positional arguments of a
+method:
+
+</P>
+<pre CLASS="code">
+ <em>objName</em> <tt>info</tt> <em>nonposargs</em> methodName
+ <em>className</em> <tt>info</tt> <em>instnonposargs</em> methodName
+</pre></p>
+
+
 <!-- PAGE BREAK -->
 
 <TABLE COLS=2 WIDTH=100% BORDER=0 CELLPADDING=2 CELLSPACING=0 BGCOLOR="#000055">
Index: xotcl/generic/predefined.h
===================================================================
diff -u -r0fb94b7893b3423b536af13fa081e7190e0ec0a2 -r225b8b992e16760eca2a7fa7bf51533499c7cc84
--- xotcl/generic/predefined.h	(.../predefined.h)	(revision 0fb94b7893b3423b536af13fa081e7190e0ec0a2)
+++ xotcl/generic/predefined.h	(.../predefined.h)	(revision 225b8b992e16760eca2a7fa7bf51533499c7cc84)
@@ -1,5 +1,5 @@
 static char cmd[] = 
-"# $Id: predefined.h,v 1.4 2004/07/18 09:49:03 neumann Exp $\n"
+"# $Id: predefined.h,v 1.5 2004/07/20 12:57:59 neumann Exp $\n"
 "::xotcl::Object instproc init args {}\n"
 "::xotcl::Object create ::xotcl::@\n"
 "::xotcl::@ proc unknown args {}\n"
Index: xotcl/generic/predefined.xotcl
===================================================================
diff -u -r5ce5a10c82bc948f50fc4542f844dcd50de1eae3 -r225b8b992e16760eca2a7fa7bf51533499c7cc84
--- xotcl/generic/predefined.xotcl	(.../predefined.xotcl)	(revision 5ce5a10c82bc948f50fc4542f844dcd50de1eae3)
+++ xotcl/generic/predefined.xotcl	(.../predefined.xotcl)	(revision 225b8b992e16760eca2a7fa7bf51533499c7cc84)
@@ -1,4 +1,4 @@
-# $Id: predefined.xotcl,v 1.3 2004/07/03 21:19:39 neumann Exp $
+# $Id: predefined.xotcl,v 1.4 2004/07/20 12:57:59 neumann Exp $
 
 # init must exist on Object. per default it is empty.
 ::xotcl::Object instproc init args {}
@@ -34,7 +34,7 @@
   puts stderr "the method [::xotcl::self proc] is deprecated; use instead '$cmd'"
   eval $cmd
 }
-# define commenad for relations between classes and methods
+# define relations between classes and methods
 ::xotcl::Class ::xotcl::Relations
 ::xotcl::Relations instproc get {obj prop} {$obj info $prop}
 ::xotcl::Relations instproc set {obj prop value} {::xotcl::setrelation $obj $prop $value}
@@ -61,7 +61,6 @@
 ::xotcl::Class instforward instfilter -default [list get set] xotcl::relmgr %1 %self %proc
 
 
-
 ::xotcl::Object instproc self {} {return [::xotcl::self]}
 ::xotcl::Object instproc defaultmethod {} {
   #if {[string compare "::" [::xotcl::my info parent]]} {
Index: xotcl/generic/xotcl.c
===================================================================
diff -u -r5ce5a10c82bc948f50fc4542f844dcd50de1eae3 -r225b8b992e16760eca2a7fa7bf51533499c7cc84
--- xotcl/generic/xotcl.c	(.../xotcl.c)	(revision 5ce5a10c82bc948f50fc4542f844dcd50de1eae3)
+++ xotcl/generic/xotcl.c	(.../xotcl.c)	(revision 225b8b992e16760eca2a7fa7bf51533499c7cc84)
@@ -1,8 +1,8 @@
-/* $Id: xotcl.c,v 1.11 2004/07/03 21:19:39 neumann Exp $
+/* $Id: xotcl.c,v 1.12 2004/07/20 12:57:59 neumann Exp $
  *
  *  XOTcl - Extended OTcl
  *
- *  Copyright (C) 1999-2004 Gustaf Neumann (a), Uwe Zdun (b)
+ *  Copyright (C) 1999-2004 Gustaf Neumann (a), Uwe Zdun (a,b)
  *
  * (a) Vienna University of Economics and Business Administration
  *     Dept. of Information Systems / New Media
@@ -11,7 +11,8 @@
  *
  * (b) University of Essen
  *     Specification of Software Systems
- *     Altendorferstra�e 97-101 *     D-45143 Essen, Germany
+ *     Altendorferstra�e 97-101 
+ *     D-45143 Essen, Germany
  *
  *  Permission to use, copy, modify, distribute, and sell this
  *  software and its documentation for any purpose is hereby granted
@@ -688,7 +689,6 @@
 }
 */
 
-
 static Tcl_Obj*
 NameInNamespaceObj(Tcl_Interp *in, char *name, Tcl_Namespace *ns) {
   Tcl_Obj *objName;
@@ -4173,61 +4173,235 @@
 }
 
 /*
- *  Proc-Creation
+ * Non Positional Args
  */
 
-static int
-MakeProc(Tcl_Namespace* ns, XOTclAssertionStore* aStore,
-	 Tcl_Interp *in, int objc, Tcl_Obj *objv[], XOTclObject *obj) {
-    int result, oc = objc;
-    Tcl_CallFrame frame;
-    Tcl_Obj *oldBody;
-    char *body;
+static void
+NonPosArgsDeleteHashEntry(Tcl_HashEntry* hPtr) {
+  XOTclNonPosArgs* nonPosArg = (XOTclNonPosArgs*) Tcl_GetHashValue(hPtr);
+  if (nonPosArg) {
+    DECR_REF_COUNT(nonPosArg->nonPosArgs);
+    DECR_REF_COUNT(nonPosArg->ordinaryArgs);
+    MEM_COUNT_FREE("nonPosArg",nonPosArg);
+    ckfree ((char*) nonPosArg);
+    Tcl_DeleteHashEntry(hPtr);
+  }
+}
 
-    oldBody = objv[3];
-    body = ObjStr(oldBody);
+static Tcl_HashTable*
+NonPosArgsCreateTable() {
+  Tcl_HashTable* nonPosArgsTable = 
+    (Tcl_HashTable *) ckalloc(sizeof(Tcl_HashTable));
+  MEM_COUNT_ALLOC("Tcl_HashTable",nonPosArgsTable);
+  Tcl_InitHashTable(nonPosArgsTable, TCL_STRING_KEYS);
+  MEM_COUNT_ALLOC("Tcl_InitHashTable",nonPosArgsTable);
+  return nonPosArgsTable;
+}
 
-    objv[3] = Tcl_NewStringObj("", 0);
-    INCR_REF_COUNT(objv[3]);
+static void
+NonPosArgsFreeTable(Tcl_HashTable* nonPosArgsTable) {
+  Tcl_HashSearch hSrch;
+  Tcl_HashEntry* hPtr = nonPosArgsTable ?
+    Tcl_FirstHashEntry(nonPosArgsTable, &hSrch) : 0;
+  for (; hPtr != 0; hPtr = Tcl_NextHashEntry(&hSrch)) {
+    NonPosArgsDeleteHashEntry(hPtr);
+  }
+}
 
-    Tcl_AppendStringsToObj(objv[3], "::xotcl::initProcNS\n", NULL);
+static XOTclNonPosArgs* 
+NonPosArgsGet(Tcl_HashTable* nonPosArgsTable, char* methodName) {
+  Tcl_HashEntry* hPtr = nonPosArgsTable ? Tcl_FindHashEntry(nonPosArgsTable, 
+							    methodName) : 0;
+  if (hPtr) {
+    return (XOTclNonPosArgs*) Tcl_GetHashValue(hPtr);
+  }
+  return NULL;
+}
 
-#ifdef AUTOVARS
-    { char *p;
-      if ((p = strstr(body, "self")) && p != body && *(p-1) != '[')
-	Tcl_AppendStringsToObj(objv[3], "::set self [self]\n", NULL);
-      if (strstr(body, "proc"))
-	Tcl_AppendStringsToObj(objv[3], "::set proc [self proc]\n", NULL);
-      if (strstr(body, "class"))
-	Tcl_AppendStringsToObj(objv[3], "::set class [self class]\n", NULL);
+static Tcl_Obj* 
+NonPosArgsFormat(Tcl_Interp *in, Tcl_Obj* nonPosArgsData) {
+  int r1, npalistc, npac, checkc, i, j, first;
+  Tcl_Obj **npalistv, **npav, **checkv, 
+    *list = Tcl_NewListObj(0, NULL), *innerlist,
+    *nameStringObj;
+  
+  r1 = Tcl_ListObjGetElements(in, nonPosArgsData, &npalistc, &npalistv);
+  if (r1 == TCL_OK) {
+    for (i=0; i < npalistc; i++) {
+      r1 = Tcl_ListObjGetElements(in, npalistv[i], &npac, &npav);
+      if (r1 == TCL_OK) {
+	nameStringObj = Tcl_NewStringObj("-", 1);
+	Tcl_AppendStringsToObj(nameStringObj, ObjStr(npav[0]), 
+			       (char *) NULL);
+	if (npac > 1 && *(ObjStr(npav[1])) != '\0') {
+	  first = 1;
+	  r1 = Tcl_ListObjGetElements(in, npav[1], &checkc, &checkv);
+	  if (r1 == TCL_OK) {
+	    for (j=0; j < checkc; j++) {
+	      if (first) {
+		Tcl_AppendToObj(nameStringObj,":",1);
+		first = 0;
+	      } else {
+		Tcl_AppendToObj(nameStringObj,",",1);
+	      }
+	      Tcl_AppendToObj(nameStringObj, ObjStr(checkv[j]), -1);
+	    }
+	  }
+	}
+	innerlist = Tcl_NewListObj(0, NULL);
+	Tcl_ListObjAppendElement(in, innerlist, nameStringObj);
+	if (npac > 2) {
+	  Tcl_ListObjAppendElement(in, innerlist, npav[2]);
+	}
+	Tcl_ListObjAppendElement(in, list, innerlist);
+      }
     }
-#endif
+  }
+  return list;
+}
 
-    Tcl_AppendStringsToObj(objv[3], body, NULL);
-    Tcl_PushCallFrame(in,&frame,ns,0);
+/*
+ *  Proc-Creation
+ */
 
-    if (objc > 4) oc = 4;
-    result = Tcl_ProcObjCmd(0, in, oc, objv) != TCL_OK;
-#if defined(NAMESPACEINSTPROCS)
-    {
-      Proc *procPtr = TclFindProc((Interp *)in, ObjStr(objv[1]));
-      Command *cmd = (Command *)obj->id;
-      /*fprintf(stderr,"proc=%p cmd=%p ns='%s' objns=%s\n",procPtr,procPtr->cmdPtr, 
-	procPtr->cmdPtr->nsPtr->fullName,cmd->nsPtr->fullName);*/
-      /*** patch the command ****/
-      procPtr->cmdPtr = cmd;
+static int
+MakeProc(Tcl_Namespace* ns, XOTclAssertionStore* aStore, 
+	 Tcl_HashTable* nonPosArgsTable,
+	 Tcl_Interp *in, int objc, Tcl_Obj *objv[], XOTclObject *obj) {
+  int result, incr, start;
+  Tcl_CallFrame frame;
+  char *body, * arg;
+  Tcl_Obj *ov[4], *nonPosArgsObj, *npaObj, **nonPosArgsDefv, **npav, *list;
+  int nw = 0, r1, nonPosArgsDefc, length, i, j, l, npac;
+  Tcl_HashEntry* hPtr = NULL;
+  XOTclNonPosArgs* nonPosArg;
+  
+  hPtr = nonPosArgsTable ? Tcl_FindHashEntry(nonPosArgsTable, 
+					     ObjStr(objv[1])) : 0;
+  if (hPtr) NonPosArgsDeleteHashEntry(hPtr);
+
+  ov[0] = objv[0];
+  ov[1] = objv[1];
+  if (objc == 5 || objc == 7) {
+    r1 = Tcl_ListObjGetElements(in, objv[2], &nonPosArgsDefc, &nonPosArgsDefv);
+    if (r1 == TCL_OK) {
+      nonPosArgsObj = Tcl_NewListObj(0, NULL);
+      INCR_REF_COUNT(nonPosArgsObj);
+      for (i=0; i < nonPosArgsDefc; i++) {
+	r1 = Tcl_ListObjGetElements(in, nonPosArgsDefv[i], &npac, &npav);
+	if (r1 == TCL_ERROR || npac < 1 || npac > 2) {
+	  DECR_REF_COUNT(nonPosArgsObj);
+	  return XOTclVarErrMsg(in, "wrong # of elements in non-positional args ",
+				"(should be 1 or 2 list elements): ", 
+				ObjStr(objv[2]), (char *)NULL);
+	}
+	npaObj = Tcl_NewListObj(0, NULL);
+	arg = ObjStr(npav[0]);
+	if (arg[0] != '-') {
+	  INCR_REF_COUNT(npaObj);
+	  DECR_REF_COUNT(npaObj);
+	  DECR_REF_COUNT(nonPosArgsObj);
+	  return XOTclVarErrMsg(in, "non-positional args does not start with '-': ", 
+				arg, " in: ", 
+				ObjStr(objv[2]), (char *)NULL);
+	}
+	
+	length = strlen(arg);
+	for (j=0; j<length; j++) {
+	  if (arg[j] == ':') break;
+	}
+	if (arg[j] == ':') {
+	  Tcl_ListObjAppendElement(in, npaObj, Tcl_NewStringObj(arg+1, j-1));
+	  list = Tcl_NewListObj(0, NULL);
+	  start = j+1;
+	  for (l=start; l<length;l++) {
+	    if (arg[l] == ',') {
+	      Tcl_ListObjAppendElement(in, list, Tcl_NewStringObj(arg+start, l - start));
+	      l++;
+	      start = l;
+	    } 
+	  }
+	  /* append last arg */
+	  Tcl_ListObjAppendElement(in, list, Tcl_NewStringObj(arg+start, l - start)); 
+	  /* append the whole thing to the list */
+	  Tcl_ListObjAppendElement(in, npaObj, list);
+     	} else {
+	  Tcl_ListObjAppendElement(in, npaObj, Tcl_NewStringObj(arg+1, length));
+	  Tcl_ListObjAppendElement(in, npaObj, Tcl_NewStringObj("", 0));
+	}
+	if (npac == 2) {
+	  Tcl_ListObjAppendElement(in, npaObj, npav[1]);
+	}      
+       	Tcl_ListObjAppendElement(in, nonPosArgsObj, npaObj);
+      }
+    } else {
+      return XOTclVarErrMsg(in, "cannot break down non-positional args: ", 
+		     ObjStr(objv[2]), (char *)NULL);
     }
-#endif
 
-    Tcl_PopCallFrame(in);
+    ov[2] = XOTclGlobalObjects[ARGS];
+    body = ObjStr(objv[4]);
+    ov[3] = Tcl_NewStringObj("", 0);
+    INCR_REF_COUNT(ov[3]);
+    Tcl_AppendStringsToObj(ov[3], "::xotcl::initProcNS\n", NULL);
 
-    if (objc == 6)
-      AssertionAddProc(in, ObjStr(objv[1]), aStore, objv[4], objv[5]);
+    hPtr = Tcl_CreateHashEntry(nonPosArgsTable, ObjStr(ov[1]), &nw);
+    if (nw) {
+      MEM_COUNT_ALLOC("nonPosArg",nonPosArg);
+      nonPosArg = (XOTclNonPosArgs*) ckalloc(sizeof(XOTclNonPosArgs));
+      nonPosArg->nonPosArgs = nonPosArgsObj;
+      nonPosArg->ordinaryArgs = objv[3];
+      INCR_REF_COUNT(objv[3]);
+      Tcl_SetHashValue(hPtr, (ClientData)nonPosArg);
+    }
 
-    DECR_REF_COUNT(objv[3]);
-    objv[3] = oldBody;
-
-    return result;
+    Tcl_AppendStringsToObj(ov[3], 
+			   "::xotcl::interpretNonPositionalArgs $args\n",
+			   NULL);
+  } else {
+    ov[2] = objv[2];
+    body = ObjStr(objv[3]);
+    ov[3] = Tcl_NewStringObj("", 0);
+    INCR_REF_COUNT(ov[3]);
+    Tcl_AppendStringsToObj(ov[3], "::xotcl::initProcNS\n", NULL);
+  }
+  
+#ifdef AUTOVARS
+  { char *p;
+    if ((p = strstr(body, "self")) && p != body && *(p-1) != '[')
+      Tcl_AppendStringsToObj(ov[3], "::set self [self]\n", NULL);
+    if (strstr(body, "proc"))
+      Tcl_AppendStringsToObj(ov[3], "::set proc [self proc]\n", NULL);
+    if (strstr(body, "class"))
+      Tcl_AppendStringsToObj(ov[3], "::set class [self class]\n", NULL);
+  }
+#endif
+  
+  Tcl_AppendStringsToObj(ov[3], body, NULL);
+  Tcl_PushCallFrame(in,&frame,ns,0);
+  
+  result = Tcl_ProcObjCmd(0, in, 4, ov) != TCL_OK;
+#if defined(NAMESPACEINSTPROCS)
+  {
+    Proc *procPtr = TclFindProc((Interp *)in, ObjStr(ov[1]));
+    Command *cmd = (Command *)obj->id;
+    /*fprintf(stderr,"proc=%p cmd=%p ns='%s' objns=%s\n",procPtr,procPtr->cmdPtr, 
+      procPtr->cmdPtr->nsPtr->fullName,cmd->nsPtr->fullName);*/
+    /*** patch the command ****/
+    procPtr->cmdPtr = cmd;
+  }
+#endif
+  
+  Tcl_PopCallFrame(in);
+  
+  if (objc == 6 || objc == 7) {
+    incr = (objc == 6) ? 0:1;
+    AssertionAddProc(in, ObjStr(objv[1]), aStore, objv[4+incr], objv[5+incr]);
+  }
+  
+  DECR_REF_COUNT(ov[3]);
+  
+  return result;
 }
 
 /*
@@ -4717,6 +4891,8 @@
     char *body = ObjStr(proc->bodyPtr);
     if (strncmp(body, "::xotcl::initProcNS\n",20) == 0)
       body+=20;
+    if (strncmp(body, "::xotcl::interpretNonPositionalArgs $args\n",42) == 0)
+      body+=42;
     Tcl_SetObjResult(in, Tcl_NewStringObj(body, -1));
     return TCL_OK;
   }
@@ -5281,6 +5457,14 @@
     freeObjectOpt(obj);
   }
 
+  if (obj->nonPosArgsTable) {
+    NonPosArgsFreeTable(obj->nonPosArgsTable);
+    Tcl_DeleteHashTable(obj->nonPosArgsTable);
+    MEM_COUNT_FREE("Tcl_InitHashTable", obj->nonPosArgsTable);
+    ckfree((char*) obj->nonPosArgsTable);
+    MEM_COUNT_FREE("Tcl_HashTable",obj->nonPosArgsTable);
+  }
+
   obj->flags &= ~XOTCL_MIXIN_ORDER_VALID;
   if (obj->mixinOrder)  MixinResetOrder(obj);
   obj->flags &= ~XOTCL_FILTER_ORDER_VALID;
@@ -5302,6 +5486,7 @@
   if (obj->flags & XOTCL_RECREATE) {
     obj->opt = 0;
     obj->varTable = 0;
+    obj->nonPosArgsTable = 0;
     obj->mixinOrder = 0;
     obj->filterOrder = 0;
     obj->flags = 0;
@@ -5531,6 +5716,14 @@
     }
   }
 
+  if (cl->nonPosArgsTable) {
+    NonPosArgsFreeTable(cl->nonPosArgsTable);
+    Tcl_DeleteHashTable(cl->nonPosArgsTable);
+    MEM_COUNT_FREE("Tcl_InitHashTable", cl->nonPosArgsTable);
+    ckfree((char*) cl->nonPosArgsTable);
+    MEM_COUNT_FREE("Tcl_HashTable",cl->nonPosArgsTable);
+  }
+
   Tcl_DeleteHashTable(&cl->instances);
   MEM_COUNT_FREE("Tcl_InitHashTable",&cl->instances);
 
@@ -5597,6 +5790,7 @@
   MEM_COUNT_ALLOC("Tcl_InitHashTable",&cl->instances);
 
   cl->opt = 0;
+  cl->nonPosArgsTable = 0;
 }
 
 /*
@@ -6175,9 +6369,6 @@
   if (objc < 2)
     return XOTclObjErrArgCnt(in, obj->cmdName, "info <opt> ?args?");
 
-
-
-
   opt = obj->opt;
   cmd = ObjStr(objv[1]);
   pattern = (objc > 2) ? ObjStr(objv[2]) : 0;
@@ -6197,6 +6388,13 @@
     if (isArgsString(cmd)) {
       if (objc != 3 || modifiers > 0)
 	return XOTclObjErrArgCnt(in, obj->cmdName, "info args <proc>");
+      if (obj->nonPosArgsTable) {
+	XOTclNonPosArgs* nonPosArgs = NonPosArgsGet(obj->nonPosArgsTable, pattern);
+	if (nonPosArgs) {
+	  Tcl_SetObjResult(in, nonPosArgs->ordinaryArgs);
+	  return TCL_OK;
+	}
+      }
       if (nsp)
 	return ListProcArgs(in, Tcl_Namespace_cmdTable(nsp), pattern);
       else
@@ -6367,6 +6565,22 @@
     }
 #endif
     break;
+
+  case 'n':
+    if (!strcmp(cmd, "nonposargs")) {
+      if (objc != 3 || modifiers > 0)
+	return XOTclObjErrArgCnt(in, obj->cmdName, "info nonposargs <proc>");
+      if (obj->nonPosArgsTable) {
+	XOTclNonPosArgs* nonPosArgs = 
+	  NonPosArgsGet(obj->nonPosArgsTable, pattern);
+	if (nonPosArgs) {
+	  Tcl_SetObjResult(in, NonPosArgsFormat(in, nonPosArgs->nonPosArgs));
+	}
+      }
+      return TCL_OK;
+    }
+    break;
+
   case 'p':
     if (!strcmp(cmd, "procs")) {
       if (objc > 3 || modifiers > 0)
@@ -6419,15 +6633,24 @@
   XOTclObject *obj = (XOTclObject*)cd;
   char *argStr, *bdyStr, *name;
   XOTclObjectOpt *opt;
+  int incr = 0, result = TCL_OK;
 
   if (!obj) return XOTclObjErrType(in, objv[0], "Object");
-  if (objc != 4 && objc != 6)
+  if (objc < 4 || objc > 7)
     return XOTclObjErrArgCnt(in, obj->cmdName,
-			     "proc name args body ?preAssertion postAssertion?");
-  argStr = ObjStr(objv[2]);
-  bdyStr = ObjStr(objv[3]);
-  name = ObjStr(objv[1]);
+			     "proc name ?non-positional-args? args body ?preAssertion postAssertion?");
 
+  if (objc == 5 || objc == 7) {
+    if (obj->nonPosArgsTable == 0) {
+      obj->nonPosArgsTable = NonPosArgsCreateTable();
+    }
+    incr = 1;
+  }
+
+  argStr = ObjStr(objv[2 + incr]);
+  bdyStr = ObjStr(objv[3 + incr]);
+  name = ObjStr(objv[1 + incr]);
+
   if (*argStr == 0 && *bdyStr == 0) {
     opt = obj->opt;
     if (opt)
@@ -6439,13 +6662,13 @@
     if (!opt->assertions)
       opt->assertions = AssertionCreateStore();
     requireObjNamespace(in, obj);
-    MakeProc(obj->nsPtr, opt->assertions, in, objc, (Tcl_Obj **) objv, obj);
+    result = MakeProc(obj->nsPtr, opt->assertions, obj->nonPosArgsTable,  in, objc, (Tcl_Obj **) objv, obj);
   }
 
   /* could be a filter => recompute filter order */
   FilterComputeDefined(in, obj);
 
-  return TCL_OK;
+  return result;
 }
 
 static int
@@ -7366,8 +7589,6 @@
 
   if (objc < 3)
     return XOTclObjErrArgCnt(in, objv[0], "::xotcl::setrelation obj ?reltype? classes");
-  if (Tcl_ListObjGetElements(in, objv[3], &oc, &ov)!= TCL_OK)
-    return TCL_ERROR;
 
   reltype = ObjStr(objv[2]);
   len = strlen(reltype);
@@ -7381,22 +7602,35 @@
   } else if (*reltype == 'i' && len == 10 && !strcmp(reltype, "instfilter")) {
     kind = instfilter;
   } else {
-    XOTclObjErrType(in, objv[2], "reltype (mixin, filter, instmixin, instfilter)");
+    result = XOTclObjErrType(in, objv[2], "reltype (mixin, filter, instmixin, instfilter)");
+    goto setrelationexit;
   }
   
   if (kind == mixin || kind == filter) {
     GetXOTclObjectFromObj(in, objv[1], &obj);
-    if (!obj) return XOTclObjErrType(in, objv[1], "Object");
+    if (!obj) {
+      result = XOTclObjErrType(in, objv[1], "Object");
+      goto setrelationexit;
+    }
   } else {
     GetXOTclClassFromObj(in, objv[1], &cl, 1);
-    if (!cl) return XOTclObjErrType(in, objv[1], "Class");
+    if (!cl) {
+      result = XOTclObjErrType(in, objv[1], "Class");
+      goto setrelationexit;
+    }
   }
 
+  /* objv[3] might be a shared object with objv[1]; we do the split later, since 
+     GetXOTclObjectFromObj() might do some shimmering to convert the list to an object
+  */
+  if ((result = Tcl_ListObjGetElements(in, objv[3], &oc, &ov)!= TCL_OK))
+    goto setrelationexit;
+
   switch (kind) {
   case mixin: 
     {
       XOTclObjectOpt *opt = XOTclRequireObjectOpt(obj);
-      if (opt->mixins) CmdListRemoveList(&obj->opt->mixins, GuardDel); 
+      if (opt->mixins) CmdListRemoveList(&opt->mixins, GuardDel); 
       
       obj->flags &= ~XOTCL_MIXIN_ORDER_VALID;
       /*
@@ -7406,7 +7640,7 @@
 
       for (i = 0; i < oc; i++) {
 	if ((result = MixinAdd(in, &opt->mixins, ov[i])) != TCL_OK)
-	  return result;
+	  goto setrelationexit;
       }
       
       MixinComputeDefined(in, obj);
@@ -7421,7 +7655,7 @@
       obj->flags &= ~XOTCL_FILTER_ORDER_VALID;
       for (i = 0; i < oc; i ++) {
 	if ((result = FilterAdd(in, &opt->filters, ov[i], obj, 0)) != TCL_OK)
-	  return result;
+	  goto setrelationexit;
       }
       /*FilterComputeDefined(in, obj);*/
       break;
@@ -7440,7 +7674,7 @@
 
       for (i = 0; i < oc; i++) {
 	if ((result = MixinAdd(in, &opt->instmixins, ov[i])) != TCL_OK)
-	  return result;
+	  goto setrelationexit;
       }
       break;
     }
@@ -7454,12 +7688,13 @@
 
       for (i = 0; i < oc; i ++) {
 	if ((result = FilterAdd(in, &opt->instfilters, ov[i], 0, cl)) != TCL_OK)
-	  return result;
+	  goto setrelationexit;
       }
       break;
     }
   }
-
+ setrelationexit:
+  /*DECR_REF_COUNT(list);*/
   return result;
 }
 
@@ -8234,6 +8469,13 @@
 	  if (objc != 3 || modifiers > 0)
 	    return XOTclObjErrArgCnt(in, cl->object.cmdName,
 				     "info instargs <instproc>");
+	  if (cl->nonPosArgsTable) {
+	    XOTclNonPosArgs* nonPosArgs = NonPosArgsGet(cl->nonPosArgsTable, pattern);
+	    if (nonPosArgs) {
+	      Tcl_SetObjResult(in, nonPosArgs->ordinaryArgs);
+	      return TCL_OK;
+	    }
+	  }
 	  return ListProcArgs(in, Tcl_Namespace_cmdTable(nsp), pattern);
 	}
 	break;
@@ -8334,6 +8576,23 @@
 	}
 	break;
 
+      case 'n':
+	if (!strcmp(cmdTail, "nonposargs")) {
+	  if (objc != 3 || modifiers > 0)
+	    return XOTclObjErrArgCnt(in, cl->object.cmdName, 
+				     "info instnonposargs <instproc>");
+	  if (cl->nonPosArgsTable) {
+	    XOTclNonPosArgs* nonPosArgs = 
+	      NonPosArgsGet(cl->nonPosArgsTable, pattern);
+	    if (nonPosArgs) {
+	      Tcl_SetObjResult(in, NonPosArgsFormat(in, 
+						    nonPosArgs->nonPosArgs));
+	    }
+	  }
+	  return TCL_OK;
+	}
+	break;
+
       case 'p':
 	if (!strcmp(cmdTail, "procs")) {
 	  if (objc > 3 || modifiers > 0)
@@ -8712,16 +8971,24 @@
   XOTclClass *cl = XOTclObjectToClass(cd);
   char *argStr, *bdyStr, *name;
   XOTclClassOpt* opt;
+  int incr = 0, result = TCL_OK;
 
   if (!cl) return XOTclObjErrType(in, objv[0], "Class");
-  if (objc != 4 && objc != 6)
+  if (objc < 4 || objc > 7)
     return XOTclObjErrArgCnt(in, cl->object.cmdName,
-			     "instproc name args body ?preAssertion postAssertion?");
+			     "instproc name ?non-positional-args? args body ?preAssertion postAssertion?");
 
-  argStr = ObjStr(objv[2]);
-  bdyStr = ObjStr(objv[3]);
-  name = ObjStr(objv[1]);
+  if (objc == 5 || objc == 7) {
+    if (cl->nonPosArgsTable == 0) {
+      cl->nonPosArgsTable = NonPosArgsCreateTable();
+    }
+    incr = 1;
+  }
 
+  argStr = ObjStr(objv[2 + incr]);
+  bdyStr = ObjStr(objv[3 + incr]);
+  name = ObjStr(objv[1 + incr]);
+
   if ((cl == RUNTIME_STATE(in)->theObject && isDestroyString(name)) ||
       (cl == RUNTIME_STATE(in)->theClass && isInstDestroyString(name)) ||
       (cl == RUNTIME_STATE(in)->theClass && isAllocString(name)) ||
@@ -8739,13 +9006,13 @@
     opt = XOTclRequireClassOpt(cl);
     if (!opt->assertions)
       opt->assertions = AssertionCreateStore();
-    MakeProc(cl->nsPtr, opt->assertions, in, objc, (Tcl_Obj **) objv, &cl->object);
+    result = MakeProc(cl->nsPtr, opt->assertions, cl->nonPosArgsTable, in, objc, (Tcl_Obj **) objv, &cl->object);
   }
 
   /* could be a filter or filter inheritance ... update filter orders */
   FilterInvalidateObjOrders(in, cl);
 
-  return TCL_OK;
+  return result;
 }
 
 
@@ -9166,17 +9433,228 @@
     fprintf(stderr, "currns = '%s'\n",currNs->fullName);
   }
 #endif
+ 
   RUNTIME_STATE(in)->cs.top->currentFramePtr = varFramePtr;
 #if !defined(NAMESPACEINSTPROCS)
   if (varFramePtr) {
-      varFramePtr->nsPtr = GetCallerVarFrame(in,varFramePtr,0);
+      varFramePtr->nsPtr = GetCallerVarFrame(in,varFramePtr);
   }
 #endif
   return TCL_OK;
 }
 
+/*
+ * Interpretation of Non-Positional Args
+ */
+int
+isNonPositionalArg(Tcl_Interp *in, char* argStr, 
+		   int nonPosArgsDefc, Tcl_Obj **nonPosArgsDefv, 
+		   char **varName) {
+  int i, npac;
+  Tcl_Obj **npav;
+  if (argStr[0] == '-') {
+    for (i=0; i < nonPosArgsDefc; i++) {
+      if (Tcl_ListObjGetElements(in, nonPosArgsDefv[i], 
+				 &npac, &npav) == TCL_OK && npac > 0) {
+	*varName = argStr+1;
+	if (!strcmp(*varName, ObjStr(npav[0]))) {
+	  return 1;
+	}
+      }
+    }
+  }
+  return 0;
+}
 
+int
+XOTclCheckBooleanArgs(ClientData cd, Tcl_Interp *in, int objc, 
+		      Tcl_Obj *CONST objv[]) {
+  int result, bool;
+  Tcl_Obj* boolean;
+  if (objc != 2 && objc != 3)
+    return XOTclObjErrArgCnt(in, NULL, 
+			     "::xotcl::nonPositionalArgs boolean <args> ?currentValue?");
 
+  boolean = Tcl_DuplicateObj(objv[2]);
+  INCR_REF_COUNT(boolean);
+  result = Tcl_GetBooleanFromObj(in, boolean, &bool);
+  DECR_REF_COUNT(boolean);
+  /*
+  result = TCL_OK;
+  */
+  if (result != TCL_OK)
+    return XOTclVarErrMsg(in, 
+			  "non-positional argument: '", ObjStr(objv[1]), "' with value '",
+			  ObjStr(objv[2]), "' is not of type boolean",
+			  NULL);
+  return TCL_OK;
+}
+
+int
+XOTclCheckRequiredArgs(ClientData cd, Tcl_Interp *in, int objc, 
+		       Tcl_Obj *CONST objv[]) {
+  if (objc != 2 && objc != 3)
+    return XOTclObjErrArgCnt(in, NULL, 
+			     "::xotcl::nonPositionalArgs required <args> ?currentValue?");
+
+  if (objc != 3)
+    return XOTclVarErrMsg(in, 
+			  "required arg: '", ObjStr(objv[1]), "' missing",
+			  NULL);
+  return TCL_OK;
+}
+
+int
+XOTclInterpretNonPositionalArgsCmd(ClientData cd, Tcl_Interp *in, int objc, 
+				   Tcl_Obj *CONST objv[]) {
+  Tcl_Obj **npav, **checkv, **checkArgv, **argsv, **nonPosArgsDefv, *invocation[4], 
+    **ordinaryArgsDefv, *list, *checkObj, *objPtr;
+  int npac, checkc, checkArgc, argsc, nonPosArgsDefc, 
+    ordinaryArgsDefc, argsDefined = 0, 
+    ordinaryArgsCounter = 0, i, j, result, ic;
+  char* lastDefArg = NULL, *varName, *arg, *argStr;
+  int endOfNonPosArgsReached = 0;
+  Var *varPtr;
+
+  XOTclClass* selfClass = GetSelfClass(in);
+  char*  methodName = (char*) GetSelfProc(in);
+  Tcl_HashTable* nonPosArgsTable;
+  XOTclNonPosArgs* nonPosArgs;
+  XOTclObject* selfObj;
+  int r1, r2, r3;
+
+  if (objc != 2)
+    return XOTclObjErrArgCnt(in, NULL, 
+			     "::xotcl::interpretNonPositionalArgs <args>");
+  
+  if (selfClass) {
+    nonPosArgsTable = selfClass->nonPosArgsTable;
+  } else if ((selfObj = GetSelfObj(in))) {
+    nonPosArgsTable = selfObj->nonPosArgsTable;
+  } else {
+    return XOTclVarErrMsg(in, 
+			  "Non positional args: can't find self/self class",
+			  NULL);
+  }
+
+  nonPosArgs = NonPosArgsGet(nonPosArgsTable, methodName);
+  if (nonPosArgs == 0) {
+    return XOTclVarErrMsg(in, 
+			  "Non positional args: can't find hash entry for: ",
+			  methodName,
+			  NULL);
+  }
+
+  r1 = Tcl_ListObjGetElements(in, nonPosArgs->nonPosArgs, 
+			      &nonPosArgsDefc, &nonPosArgsDefv);
+  r2 = Tcl_ListObjGetElements(in, nonPosArgs->ordinaryArgs, 
+			      &ordinaryArgsDefc, &ordinaryArgsDefv);
+  r3 = Tcl_ListObjGetElements(in, objv[1], &argsc, &argsv);
+  if (r1 != TCL_OK || r2 != TCL_OK || r3 != TCL_OK) {
+    return XOTclVarErrMsg(in, 
+			  "Cannot split non positional args list: ",
+			  methodName,
+			  NULL);
+  }
+
+  for (i=0; i < nonPosArgsDefc; i++) {
+     r1 = Tcl_ListObjGetElements(in, nonPosArgsDefv[i], 
+				 &npac, &npav);
+     if (r1 == TCL_OK &&  npac == 3) {
+       Tcl_ObjSetVar2(in, npav[0], 0, npav[2], 0);
+     }
+  }
+
+  if (ordinaryArgsDefc > 0) {
+    lastDefArg = ObjStr(ordinaryArgsDefv[ordinaryArgsDefc-1]);
+    if (isArgsString(lastDefArg)) {
+      argsDefined = 1;
+    }
+  }
+
+  for (i=0; i < argsc; i++) {
+    if (!endOfNonPosArgsReached) {
+      argStr = ObjStr(argsv[i]);
+      if (isDoubleDashString(argStr)) {
+	endOfNonPosArgsReached = 1;
+	i++;
+      }
+      if (isNonPositionalArg(in, argStr, nonPosArgsDefc, 
+			     nonPosArgsDefv, &varName)) {
+	i++;
+	if (i > argsc) 
+	  return XOTclVarErrMsg(in, "Non positional arg '",
+				ObjStr(argsv[1]), "': value missing", 
+				NULL);
+	Tcl_SetVar2(in, varName, 0, ObjStr(argsv[i]), 0);
+      } else {
+	endOfNonPosArgsReached = 1;
+      }
+    }
+
+    if (endOfNonPosArgsReached) {
+      if (ordinaryArgsCounter >= ordinaryArgsDefc) {
+	return XOTclObjErrArgCnt(in, NULL, ObjStr(nonPosArgs->ordinaryArgs));
+      }
+      arg = ObjStr(ordinaryArgsDefv[ordinaryArgsCounter]);
+      /* this is the last arg and 'args' is defined */ 
+      if (argsDefined && ordinaryArgsCounter+1 == ordinaryArgsDefc) {
+	list = Tcl_NewListObj(0, NULL);
+	INCR_REF_COUNT(list);
+	for(; i < argsc; i++)
+	  Tcl_ListObjAppendElement(in, list, argsv[i]);
+	Tcl_ObjSetVar2(in, ordinaryArgsDefv[ordinaryArgsCounter], 0, list, 0);
+	DECR_REF_COUNT(list);
+      } else {
+	Tcl_ObjSetVar2(in, ordinaryArgsDefv[ordinaryArgsCounter], 0, argsv[i], 0);
+      }
+      ordinaryArgsCounter++;
+    }
+  }
+  if (!argsDefined) {
+    if (ordinaryArgsCounter != ordinaryArgsDefc) {
+      return XOTclObjErrArgCnt(in, NULL, ObjStr(nonPosArgs->ordinaryArgs));
+    }
+    Tcl_UnsetVar2(in, "args", 0, 0);
+  }
+
+  for (i=0; i < nonPosArgsDefc; i++) {
+     r1 = Tcl_ListObjGetElements(in, nonPosArgsDefv[i], 
+				 &npac, &npav);
+     if (r1 == TCL_OK &&  npac > 1 && *(ObjStr(npav[1])) != '\0') {
+       r1 = Tcl_ListObjGetElements(in, npav[1], &checkc, &checkv);
+       if (r1 == TCL_OK) {
+	 checkObj = XOTclGlobalObjects[NON_POS_ARGS_OBJ];
+	 for (j=0; j < checkc; j++) {
+	   r1 = Tcl_ListObjGetElements(in, checkv[j], &checkArgc, &checkArgv);
+	   if (r1 == TCL_OK && checkArgc > 1) {
+	     if (isCheckObjectString((ObjStr(checkArgv[0]))) && checkArgc == 2) {
+	       checkObj = checkArgv[1];
+	       continue;
+	     }
+	   }
+	   invocation[0] = checkObj;
+	   invocation[1] = checkv[j];
+	   varPtr = TclVarTraceExists(in, ObjStr(npav[0]));
+	   invocation[2] = npav[0];
+	   ic = 3;
+	   if ((varPtr != NULL) && !TclIsVarUndefined(varPtr)) {
+	     invocation[3] = Tcl_ObjGetVar2(in, npav[0], 0, 0);
+	     ic = 4;
+	   }
+	   objPtr = Tcl_ConcatObj(ic, invocation);
+	   result = Tcl_EvalObjEx(in, objPtr, TCL_EVAL_DIRECT);
+	   if (result != TCL_OK) {
+	     return result;
+	   }
+	 }
+       }
+     }
+  }
+  return TCL_OK;
+}
+
+
 /* create a slave interp that calls XOTcl Init */
 static int
 XOTcl_InterpObjCmd(ClientData cd, Tcl_Interp *in, int objc, Tcl_Obj *objv[]) {
@@ -9217,7 +9695,6 @@
 		  int flgs) {
   Tcl_Obj *result;
   XOTcl_FrameDecls;
-
   XOTcl_PushFrame(in, obj);
   if (obj->nsPtr)
     flgs |= TCL_NAMESPACE_ONLY;
@@ -9624,6 +10101,7 @@
   XOTclClass *theobj = 0;
   XOTclClass *thecls = 0;
   XOTclClass *paramCl = 0;
+  XOTclClass *nonPositionalArgsCl = 0;
   ClientData runtimeState;
   int result, i;
 #ifdef XOTCL_BYTECODE
@@ -9852,6 +10330,9 @@
   instructions[INST_INITPROC].cmdPtr = (Command *)
 #endif
   Tcl_CreateObjCommand(in, "::xotcl::initProcNS", XOTclInitProcNSCmd, 0, 0);
+  Tcl_CreateObjCommand(in, "::xotcl::interpretNonPositionalArgs", 
+		       XOTclInterpretNonPositionalArgsCmd, 0, 0);
+
 #ifdef XOTCL_BYTECODE
   instructions[INST_SELF_DISPATCH].cmdPtr = (Command *)
 #endif
@@ -9861,6 +10342,22 @@
   XOTclBytecodeInit();
 #endif
 
+  /* 
+   * Non-Positional Args Object
+   */
+  
+  nonPositionalArgsCl = PrimitiveCCreate(in, 
+					 XOTclGlobalStrings[NON_POS_ARGS_CL], 
+					 thecls);
+  XOTclAddIMethod(in, (XOTcl_Class*) nonPositionalArgsCl,
+		  "required",
+		  (Tcl_ObjCmdProc*) XOTclCheckRequiredArgs, 0, 0);
+  XOTclAddIMethod(in, (XOTcl_Class*) nonPositionalArgsCl,
+		  "boolean",
+		  (Tcl_ObjCmdProc*) XOTclCheckBooleanArgs, 0, 0);
+  PrimitiveOCreate(in, XOTclGlobalStrings[NON_POS_ARGS_OBJ],
+		   nonPositionalArgsCl);
+
   /*
    *  Parameter Class
    */
Index: xotcl/generic/xotclInt.h
===================================================================
diff -u -rf7894d9be99a8da3a04218abcdb9bd46b6d625c8 -r225b8b992e16760eca2a7fa7bf51533499c7cc84
--- xotcl/generic/xotclInt.h	(.../xotclInt.h)	(revision f7894d9be99a8da3a04218abcdb9bd46b6d625c8)
+++ xotcl/generic/xotclInt.h	(.../xotclInt.h)	(revision 225b8b992e16760eca2a7fa7bf51533499c7cc84)
@@ -1,5 +1,5 @@
 /* -*- Mode: c++ -*-
- *  $Id: xotclInt.h,v 1.1 2004/05/23 22:50:39 neumann Exp $
+ *  $Id: xotclInt.h,v 1.2 2004/07/20 12:57:59 neumann Exp $
  *  Extended Object Tcl (XOTcl)
  *
  *  Copyright (C) 1999-2002 Gustaf Neumann, Uwe Zdun
@@ -104,6 +104,8 @@
 #define isArgsString(m) (\
 	*m   == 'a' && m[1] == 'r' && m[2] == 'g' && m[3] == 's' && \
 	m[4] == '\0')
+#define isDoubleDashString(m) (\
+	*m   == '-' && m[1] == '-' && m[2] == '\0')
 #define isBodyString(m) (\
 	*m   == 'b' && m[1] == 'o' && m[2] == 'd' && m[3] == 'y' && \
 	m[4] == '\0')
@@ -113,6 +115,10 @@
 #define isCheckString(m) (\
 	*m   == 'c' && m[1] == 'h' && m[2] == 'e' && m[3] == 'c' && \
 	m[4] == 'k' && m[5] == '\0')
+#define isCheckObjectString(m) (\
+        *m   == 'c' && m[1] == 'h' && m[2] == 'e' && m[3] == 'c' && \
+	m[4] == 'k' && m[5] == 'o' && m[6] == 'b' && m[7] == 'j' && \
+	m[8] == '\0')
 #define isCreateString(m) (\
 	*m   == 'c' && m[1] == 'r' && m[2] == 'e' && m[3] == 'a' && \
 	m[4] == 't' && m[5] == 'e' && m[6] == '\0')
@@ -425,10 +431,15 @@
 	(XOTclClass*)((((XOTclObject*)obj)->flags & XOTCL_IS_CLASS)?obj:0)
 
 
-
 /*
  * object and class internals
  */
+
+typedef struct XOTclNonPosArgs {
+  Tcl_Obj* nonPosArgs;
+  Tcl_Obj* ordinaryArgs;
+} XOTclNonPosArgs;
+
 typedef struct XOTclObjectOpt {
   XOTclAssertionStore *assertions;
   XOTclCmdList* filters;
@@ -454,6 +465,7 @@
   XOTclMixinStack *mixinStack;
   int refCount;
   short flags;
+  Tcl_HashTable *nonPosArgsTable;
 } XOTclObject;
 
 typedef struct XOTclClassOpt {
@@ -478,6 +490,7 @@
   Tcl_Namespace *nsPtr;
   Tcl_Obj* parameters;
   XOTclClassOpt* opt;
+  Tcl_HashTable *nonPosArgsTable;
 } XOTclClass;
 
 typedef struct XOTclClasses {
@@ -496,10 +509,11 @@
     ZERO, MOVE, SELF, CLASS, RECREATE,
     SELF_CLASS, SELF_PROC, PARAM_CL,
     SEARCH_DEFAULTS, EXIT_HANDLER,
+    NON_POS_ARGS_CL, NON_POS_ARGS_OBJ, 
     CLEANUP, CONFIGURE, FILTER, INSTFILTER,
     INSTPROC, PROC, MKGETTERSETTER, FORMAT, 
     NEWOBJ, GUARD_OPTION, DEFAULTMETHOD,
-    __UNKNOWN,
+    __UNKNOWN, ARGS, SPLIT, COMMA,
     /** these are the redefined tcl commands; leave them
 	together at the end */
     EXPR, INCR, INFO, RENAME, SUBST, 
@@ -513,10 +527,11 @@
   "0", "move", "self", "class", "recreate",
   "self class", "self proc", "::xotcl::Class::Parameter",
   "searchDefaults", "__exitHandler",
+  "::xotcl::NonPosArgs", "::xotcl::nonPosArgs", 
   "cleanup", "configure", "filter", "instfilter",
   "instproc", "proc", "mkGetterSetter", "format", 
   "__#", "-guard", "defaultmethod",
-  "__unknown",
+  "__unknown", "args", "split", ",",
   "expr", "incr", "info", "rename", "subst", 
 };
 #endif
Index: xotcl/tests/testx.xotcl
===================================================================
diff -u -r5ce5a10c82bc948f50fc4542f844dcd50de1eae3 -r225b8b992e16760eca2a7fa7bf51533499c7cc84
--- xotcl/tests/testx.xotcl	(.../testx.xotcl)	(revision 5ce5a10c82bc948f50fc4542f844dcd50de1eae3)
+++ xotcl/tests/testx.xotcl	(.../testx.xotcl)	(revision 225b8b992e16760eca2a7fa7bf51533499c7cc84)
@@ -1,4 +1,4 @@
-#$Id: testx.xotcl,v 1.10 2004/07/03 21:19:39 neumann Exp $
+#$Id: testx.xotcl,v 1.11 2004/07/20 12:57:59 neumann Exp $
 package require XOTcl
 namespace import -force xotcl::*
 
@@ -3371,9 +3371,99 @@
   return "PASSED [self]"
 }
 
+TestX create nonposargs
+nonposargs proc run {{n 20}} {
+    Object o	
+    o proc x {a b} {
+	return "$a $b"
+    }
+    o proc y {-x {-a {1 2 3}}} {a b} {
+	return "$args"
+    }
+    o proc z1 {-x:required {-a {1 2 3}}} {a args} {
+	return "$x -- $args"
+    }
+    o proc z2 {-x:required {-a {1 }} {-b {1 2}}} {args} {return "$x -- $args -- $a -- $b"}
+    o proc z3 {-b:boolean} {arg} {
+	return "$b $arg"
+    }
+    Object colorchecker
+    colorchecker proc color {a b c argName args} {
+	lappend ::r "$a $b $c"
+    }
+    colorchecker proc reddish {argName args} {
+	lappend ::r "reddish"
+    }
+    
+    o proc z4 {{{-b:checkobj colorchecker ,  color must be red, reddish,  checkobj xotcl::nonPosArgs , required} red} {{-c: required}}} {arg} {
+	lappend ::r "$b $arg"
+	return "$b $arg"
+    }
+    Class P
+    P instproc x {a b} {
+	return "$a $b"
+    }
+    P instproc z2 {-x:required {-a 1} {-b {1 2}}} {args} {return "$x -- $args -- $a -- $b"}
+    
+    P instproc z3 {-x:required {-a 1} {-b {1 2}}} {a b c} {
+	return "$x -- $args -- $a -- $b"
+    }
+    P p
 
+    errorCheck [o x 1 2] "1 2" "Ordinary Method"
+    errorCheck [p x 3 4] "3 4" "Ordinary Method (2)"
+    catch {
+	o y 4 56 5
+    } m
+    errorCheck $m "wrong # args: should be {a b}" "wrong \# check 1"
+    catch {
+	o y
+    } m
+    errorCheck $m "wrong # args: should be {a b}" "wrong \# check 2"
+    catch {
+	o y -x 1
+    } m
+    errorCheck $m "wrong # args: should be {a b}" "wrong \# check 3"
+    catch {
+	o z1 a 1 2 3
+    } m
+    errorCheck $m "required arg: 'x' missing" "required missing"
+    errorCheck [o z1 -x 1  a 1 2 3] "1 -- 1 2 3" "invocation 1"
+    errorCheck [o z2 -x 2  a 1 2 3] "2 -- a 1 2 3 -- 1  -- 1 2" "invocation 2"
+    catch {
+	o y -x 1 -a 2 2 3
+    } m
+    errorCheck $m "can't read \"args\": no such variable" "args unset?"
+    errorCheck [o z2 -a 2 -x 1 -b 3 a b c] \
+	"1 -- a b c -- 2 -- 3" "invocation 3"
+    errorCheck [p z2 -x 1 -a 2 -b 3 a b c] \
+	"1 -- a b c -- 2 -- 3" "invocation 4"
 
+    errorCheck [o z3 -b true -- -b] \
+	"true -b" "dash dash"
 
+    catch {
+	o z3 -b abc -- -b
+    } m
+    errorCheck $m "non-positional argument: 'b' with value 'abc' is not of type boolean" "not boolean"
+
+    set ::r ""    
+    o z4 -c 1 1
+    errorCheck $::r [list {must be red} reddish {red 1}] \
+	"multiple check options + checkobject"
+
+    errorCheck [o info body z2] {return "$x -- $args -- $a -- $b"} "info body 1"
+    errorCheck [P info instbody z2] {return "$x -- $args -- $a -- $b"} "info instbody z2"
+    errorCheck [o info args z4] {arg} "info args"
+    errorCheck [o info nonposargs z4] {{{-b:checkobj colorchecker ,  color must be red, reddish,  checkobj xotcl::nonPosArgs , required} red} {{-c: required}}} "info nonposargs 1"
+    errorCheck [o info nonposargs x] {} "info nonposargs 2"
+    errorCheck [P info instargs z3] {a b c} "info instargs"
+    errorCheck [P info instnonposargs z3] {-x:required {-a 1} {-b {1 2}}} "info instnonposargs 1"
+    errorCheck [P info instnonposargs x] {} "info instnonposargs 2"
+
+  return "PASSED [self]"
+}
+
 TestX proc run {} {
   puts [nestingClasses run]
   puts [nestingObjects run]
@@ -3396,6 +3486,7 @@
   puts [condMixins run]
   puts [volatileObjects run]
   puts [uplevelCmds run]
+  puts [nonposargs run]
 }
 
 puts "XOTcl - Test"