Index: TODO
===================================================================
diff -u -r021a681aedece8a8a1f1ae03b51dcadd166333c9 -r5bcfa978f7b42933cd499264abc4679093e8182d
--- TODO	(.../TODO)	(revision 021a681aedece8a8a1f1ae03b51dcadd166333c9)
+++ TODO	(.../TODO)	(revision 5bcfa978f7b42933cd499264abc4679093e8182d)
@@ -3885,10 +3885,18 @@
 - fixed NRE memory management (for Tcl 8.6) by refactoring
   alias handling
 
+- removed documentation about incompatibility to XOTcl1 in 
+  respect of the method interface for object invocations
+
 ========================================================================
 TODO:
 
+- why is now "numbers" in asciidoc pretty-print-interface ignored? 
+  [source,tcl,numbers]
+  (asciidoc has changed from 8.5.5 to 8.5.6)
+- document new setable object properties perobjectdispatch and keepcallerself
 - pertaining perobjectdispatch and keepcallerself in serializer
+
 - should we allow objects to overwrite procs/methods and vice versa?
 - behavior on keepcallerself on ordinary dispatches with implicit/explicit 
   receiver (currently the flag is ignored, the code just commented out)
Index: doc/next-migration.html
===================================================================
diff -u -r45ab205c7d750d8f285e5004194cd664e6064732 -r5bcfa978f7b42933cd499264abc4679093e8182d
--- doc/next-migration.html	(.../next-migration.html)	(revision 45ab205c7d750d8f285e5004194cd664e6064732)
+++ doc/next-migration.html	(.../next-migration.html)	(revision 5bcfa978f7b42933cd499264abc4679093e8182d)
@@ -3,7 +3,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
 <head>
 <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=UTF-8" />
-<meta name="generator" content="AsciiDoc 8.6.5" />
+<meta name="generator" content="AsciiDoc 8.6.6" />
 <title>Migration Guide for the the Next Scripting Language</title>
 <style type="text/css">
 /* Shared CSS for AsciiDoc xhtml11 and html5 backends */
@@ -179,7 +179,7 @@
   margin-left: 1.0em;
   margin-right: 10%;
   border-left: 5px solid #f0f0f0;
-  color: #777777;
+  color: #888;
 }
 
 div.quoteblock > div.attribution {
@@ -514,6 +514,29 @@
 th.tableblock.valign-bottom, td.tableblock.valign-bottom {
   vertical-align: bottom;
 }
+
+
+/*
+ * manpage specific
+ *
+ * */
+
+body.manpage h1 {
+  padding-top: 0.5em;
+  padding-bottom: 0.5em;
+  border-top: 2px solid silver;
+  border-bottom: 2px solid silver;
+}
+body.manpage h2 {
+  border-style: none;
+}
+body.manpage div.sectionbody {
+  margin-left: 3em;
+}
+
+@media print {
+  body.manpage div#toc { display: none; }
+}
 </style>
 <script type="text/javascript">
 /*<![CDATA[*/
@@ -587,7 +610,7 @@
   var i;
   for (i = 0; i < toc.childNodes.length; i++) {
     var entry = toc.childNodes[i];
-    if (entry.nodeName == 'DIV'
+    if (entry.nodeName == 'div'
      && entry.getAttribute("class")
      && entry.getAttribute("class").match(/^toclevel/))
       tocEntriesToRemove.push(entry);
@@ -633,7 +656,7 @@
   var entriesToRemove = [];
   for (i = 0; i < noteholder.childNodes.length; i++) {
     var entry = noteholder.childNodes[i];
-    if (entry.nodeName == 'DIV' && entry.getAttribute("class") == "footnote")
+    if (entry.nodeName == 'div' && entry.getAttribute("class") == "footnote")
       entriesToRemove.push(entry);
   }
   for (i = 0; i < entriesToRemove.length; i++) {
@@ -6841,54 +6864,26 @@
 </div>
 </div>
 <div class="sect2">
-<h3 id="_calling_objects_via_method_interface">3.3. Calling Objects via Method Interface</h3>
-<div class="paragraph"><p>Since the Next Scripting Framework supports the so-called <em>ensemble
-objects</em>, which ease the definition of sub-methods substantially,
-objects registered as methods have different semantics. In XOTcl 1, it
-was possible to call e.g. a method foo of the slot object
-<tt>Foo::slot::ints</tt> via the following two interfaces the same way:</p></div>
-<div class="listingblock">
-<div class="content"><style type='text/css'>
-.nx             {color: #000000; font-weight: normal; font-style: normal; padding-left: 10px}
-table.nx        {border-collapse: collapse; border-spacing: 3px;}
-.nx-linenr      {border-right: 1px solid #DDDDDD;padding-right: 5px; color: #2B547D;font-style: italic;}
-.nx-string      {color: #779977; font-weight: normal; font-style: italic;}
-.nx-comment     {color: #717ab3; font-weight: normal; font-style: italic;}
-.nx-keyword     {color: #7f0055; font-weight: normal; font-style: normal;}
-.nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
-.nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
-</style>
-<pre class='nx'><span class='nx-comment'># XOTcl example
-</span>
-Foo::slot::ints foo ...
-Foo slot ints foo ...</pre></div></div>
-<div class="paragraph"><p>In the Next Scripting Framework, only the first form has the same
-semantic as before. In the second form (invocation of objects via
-method interface) has now the ensemble object semantics. This means
-that in the second case the current object of method foo is now Foo
-instead of ints.</p></div>
-</div>
-<div class="sect2">
-<h3 id="_slots">3.4. Slots</h3>
+<h3 id="_slots">3.3. Slots</h3>
 <div class="paragraph"><p>All slot objects (also XOTcl slot objects) are now next-scripting
 objects of baseclass <tt>::nx::Slot</tt>. The name of the experimental
 default-setter <tt>initcmd</tt> was changed to <tt>defaultcmd</tt>. Code directly
 working on the slots objects has to be adapted.</p></div>
 </div>
 <div class="sect2">
-<h3 id="_obsolete_commands">3.5. Obsolete Commands</h3>
+<h3 id="_obsolete_commands">3.4. Obsolete Commands</h3>
 <div class="paragraph"><p>Parameter-classes were rarely used and have been replaced by the more
 general object parameterization. Therefore, <tt>cl info parameterclass</tt> has
 been removed.</p></div>
 </div>
 <div class="sect2">
-<h3 id="_stronger_checking">3.6. Stronger Checking</h3>
+<h3 id="_stronger_checking">3.5. Stronger Checking</h3>
 <div class="paragraph"><p>The Next Scripting Framework performs stronger checking than XOTcl 1
 For example, the requiredness of slots in XOTcl 1 was just a
 comment, while XOTcl 2 enforces it.</p></div>
 </div>
 <div class="sect2">
-<h3 id="_exit_handlers">3.7. Exit Handlers</h3>
+<h3 id="_exit_handlers">3.6. Exit Handlers</h3>
 <div class="paragraph"><p>The exit hander interface changed from a method of <tt>::xotcl::Object</tt>
 into the Tcl command <tt>::nsf::exithandler</tt>:</p></div>
 <div class="listingblock">
@@ -6912,7 +6907,7 @@
 <div id="footer">
 <div id="footer-text">
 Version 2.1<br />
-Last updated 2011-10-29 00:57:06 CEST
+Last updated 2012-01-25 11:20:34 CET
 </div>
 </div>
 </body>
Index: doc/next-migration.txt
===================================================================
diff -u -r45ab205c7d750d8f285e5004194cd664e6064732 -r5bcfa978f7b42933cd499264abc4679093e8182d
--- doc/next-migration.txt	(.../next-migration.txt)	(revision 45ab205c7d750d8f285e5004194cd664e6064732)
+++ doc/next-migration.txt	(.../next-migration.txt)	(revision 5bcfa978f7b42933cd499264abc4679093e8182d)
@@ -2945,28 +2945,6 @@
 therefore not necessary. In XOTcl 2 (and NX), +info heritage+ includes
 as well the transitive per-class mixins.
 
-=== Calling Objects via Method Interface
-
-Since the Next Scripting Framework supports the so-called _ensemble
-objects_, which ease the definition of sub-methods substantially,
-objects registered as methods have different semantics. In XOTcl 1, it
-was possible to call e.g. a method foo of the slot object
-`Foo::slot::ints` via the following two interfaces the same way:
-
-[source,tcl]
-----------------
-# XOTcl example
-
-Foo::slot::ints foo ...
-Foo slot ints foo ... 
-----------------
-
-In the Next Scripting Framework, only the first form has the same
-semantic as before. In the second form (invocation of objects via
-method interface) has now the ensemble object semantics. This means
-that in the second case the current object of method foo is now Foo
-instead of ints.
-
 === Slots
 
 All slot objects (also XOTcl slot objects) are now next-scripting
Index: doc/next-tutorial.html
===================================================================
diff -u -r9d8cfca98a5da22ca842502f73d2e6195582dfee -r5bcfa978f7b42933cd499264abc4679093e8182d
--- doc/next-tutorial.html	(.../next-tutorial.html)	(revision 9d8cfca98a5da22ca842502f73d2e6195582dfee)
+++ doc/next-tutorial.html	(.../next-tutorial.html)	(revision 5bcfa978f7b42933cd499264abc4679093e8182d)
@@ -860,26 +860,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Stack {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Stack {
 
    <span class='nx-comment'>#
 </span>   <span class='nx-comment'># Stack of Things
@@ -897,7 +878,7 @@
       <span class='nx-keyword'>set</span> :things [<span class='nx-keyword'>lrange</span> <span class='nx-variable'>${</span><span class='nx-variable'>:things}</span> 1 end]
       <span class='nx-keyword'>return</span> <span class='nx-variable'>$top</span>
    }
-}</pre></td></tr></table></div></div>
+}</pre></div></div>
 <div class="paragraph"><p>Typically, classes are defined in NX via <tt>nx::Class create</tt>, followed
 by the name of the new class (here: <tt>Stack</tt>). The definition of the
 stack placed between curly braces and contains here just the method
@@ -954,25 +935,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-comment'>#!/bin/env tclsh
+<pre class='nx'><span class='nx-comment'>#!/bin/env tclsh
 </span><span class='nx-keyword'>package</span> <span class='nx-keyword'>require</span> nx
 
 <span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Stack {
@@ -989,7 +952,7 @@
 s1 push c
 <span class='nx-keyword'>puts</span> [s1 pop]
 <span class='nx-keyword'>puts</span> [s1 pop]
-s1 <span class='nx-keyword'>destroy</span></pre></td></tr></table></div></div>
+s1 <span class='nx-keyword'>destroy</span></pre></div></div>
 <div class="paragraph"><p>Now we want to use the stack. The code snippet in <a href="#xmp-using-stack">Listing 3</a> shows how to use the class Stack in a script.
 Since NX is based on Tcl, the script will be called with the Tcl shell
 <tt>tclsh</tt>. In the Tcl shell we have to <tt>require package nx</tt> to use the
@@ -1054,22 +1017,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> stack {
+<pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> stack {
 
    <span class='nx-keyword'>:variable</span> things {}
 
@@ -1083,7 +1031,7 @@
       <span class='nx-keyword'>set</span> :things [<span class='nx-keyword'>lrange</span> <span class='nx-variable'>${</span><span class='nx-variable'>:things}</span> 1 end]
       <span class='nx-keyword'>return</span> <span class='nx-variable'>$top</span>
    }
-}</pre></td></tr></table></div></div>
+}</pre></div></div>
 <div class="paragraph"><p>The example in <a href="#xmp-object-stack">Listing 5</a> defines the
 object <tt>stack</tt> in a very similar way as the class <tt>Stack</tt>. But the
 following points are different.</p></div>
@@ -1156,31 +1104,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Safety {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Safety {
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Implement stack safety by defining an additional
@@ -1203,7 +1127,7 @@
     <span class='nx-keyword'>incr</span> :count -1
     <span class='nx-keyword'>next</span>
   }
-}</pre></td></tr></table></div></div>
+}</pre></div></div>
 <div class="paragraph"><p>Note that all the methods of the class <tt>Safety</tt> end with <tt>next</tt>.
 This command is a primitive command of NX, which calls the
 same-named method with the same argument list as the current
@@ -1228,29 +1152,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
-</pre></td><td class='nx-body'><pre class='nx'>% <span class='nx-keyword'>package</span> <span class='nx-keyword'>require</span> nx
+<pre class='nx'>% <span class='nx-keyword'>package</span> <span class='nx-keyword'>require</span> nx
 2.0
 % <span class='nx-keyword'>source</span> Stack.tcl
 ::Stack
@@ -1271,7 +1173,7 @@
 ::Stack ::nx::Object
 
 % s2 <span class='nx-keyword'>info</span> precedence
-::Safety ::Stack ::nx::Object</pre></td></tr></table></div></div>
+::Safety ::Stack ::nx::Object</pre></div></div>
 <div class="paragraph"><p>When the method <tt>push</tt> of <tt>s2</tt> is called, first the method of the
 mixin class <tt>Safety</tt> will be invoked that increments the counter and
 continues with <tt>next</tt> to call the shadowed method, here the method
@@ -1313,20 +1215,13 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-comment'>#
+<pre class='nx'><span class='nx-comment'>#
 </span><span class='nx-comment'># Create a safe stack class by using Stack and mixin
 </span><span class='nx-comment'># Safety
 </span><span class='nx-comment'>#
 </span><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> SafeStack -superclass Stack -mixin Safety
 
-SafeStack <span class='nx-keyword'>create</span> s3</pre></td></tr></table></div></div>
+SafeStack <span class='nx-keyword'>create</span> s3</pre></div></div>
 <div class="paragraph"><p>The difference to the case with the per-object mixin is that now,
 <tt>Safety</tt> is mixed into the definition of <tt>SafeStack</tt>. Therefore, all
 instances of the class <tt>SafeStack</tt> (here the instance <tt>s3</tt>) will be
@@ -1364,18 +1259,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
-</pre></td><td class='nx-body'><pre class='nx'>Stack <span class='nx-keyword'>create</span> s4 {
+<pre class='nx'>Stack <span class='nx-keyword'>create</span> s4 {
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Create a stack with a object-specific method
@@ -1385,7 +1269,7 @@
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> push {thing:integer} {
     <span class='nx-keyword'>next</span>
   }
-}</pre></td></tr></table></div></div>
+}</pre></div></div>
 <div class="paragraph"><p>The program snippet in <a href="#xmp-object-integer-stack">Listing 12</a> defines an instance <tt>s4</tt> of the class
 <tt>Stack</tt> and provides an object specific method for <tt>push</tt> to implement
 an integer stack. The method <tt>pull</tt> is the same for the integer stack
@@ -1411,17 +1295,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> IntegerStack -superclass Stack {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> IntegerStack -superclass Stack {
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Create a Stack accepting only integers
@@ -1430,7 +1304,7 @@
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> push {thing:integer} {
     <span class='nx-keyword'>next</span>
   }
-}</pre></td></tr></table></div></div>
+}</pre></div></div>
 <div class="paragraph"><p>An alternative approach is shown in
 <a href="#xmp-class-integer-stack">Listing 13</a>, where the class
 <tt>IntegerStack</tt> is defined, using the same method definition
@@ -1467,31 +1341,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Stack2 {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Stack2 {
 
    <span class='nx-keyword'>:public</span> <span class='nx-keyword'>class</span> <span class='nx-keyword'>method</span> available_stacks {} {
       <span class='nx-keyword'>return</span> [<span class='nx-keyword'>llength</span> [<span class='nx-keyword'>:info</span> instances]]
@@ -1514,7 +1364,7 @@
 Stack2 <span class='nx-keyword'>create</span> s1
 Stack2 <span class='nx-keyword'>create</span> s2
 
-<span class='nx-keyword'>puts</span> [Stack2 available_stacks]</pre></td></tr></table></div></div>
+<span class='nx-keyword'>puts</span> [Stack2 available_stacks]</pre></div></div>
 <div class="paragraph"><p>The class <tt>Stack2</tt> in <a href="#xmp-stack2">Listing 14</a> consists of the
 earlier definition of the class <tt>Stack</tt> and is extended by the
 class-specific method <tt>available_stacks</tt>, which returns the
@@ -1585,18 +1435,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Foo {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Foo {
 
   <span class='nx-keyword'>:method</span> foo args {...}
     <span class='nx-comment'># "a" is a method scoped variable
@@ -1606,7 +1445,7 @@
     <span class='nx-comment'># "c" is a global variable/namespaced variable
 </span>    <span class='nx-keyword'>set</span> ::c 3
   }
-}</pre></td></tr></table></div></div>
+}</pre></div></div>
 <div class="paragraph"><p><a href="#xmp-var-resolver">Listing 16</a> shows a method <tt>foo</tt>
 of some class <tt>Foo</tt> referring to differently scoped variables.</p></div>
 <div class="sect3">
@@ -1650,34 +1489,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-comment'>#
+<pre class='nx'><span class='nx-comment'>#
 </span><span class='nx-comment'># Define a class Person with properties "name"
 </span><span class='nx-comment'># and "birthday"
 </span><span class='nx-comment'>#
@@ -1703,7 +1515,7 @@
 Student <span class='nx-keyword'>create</span> s1 -name Susan -matnr 4711
 
 <span class='nx-comment'># Access property value via accessor method
-</span><span class='nx-keyword'>puts</span> <span class='nx-string'>"The name of s1 is [s1 name]"</span></pre></td></tr></table></div></div>
+</span><span class='nx-keyword'>puts</span> <span class='nx-string'>"The name of s1 is [s1 name]"</span></pre></div></div>
 <div class="paragraph"><p>By defining <tt>name</tt> and <tt>birthday</tt> as properties of <tt>Person</tt>, NX
 provides automatically accessor methods with the same name.  The
 accessors methods (or shortly called "accessors") provide read and
@@ -1749,22 +1561,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Base {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Base {
   <span class='nx-keyword'>:variable</span> x 1
   <span class='nx-comment'># ...
 </span>}
@@ -1778,7 +1575,7 @@
 </span>Derived <span class='nx-keyword'>create</span> d1
 
 <span class='nx-comment'># Object d1 has instance variables
-</span><span class='nx-comment'># x == 1 and y == 2</span></pre></td></tr></table></div></div>
+</span><span class='nx-comment'># x == 1 and y == 2</span></pre></div></div>
 <div class="paragraph"><p>Note that the variable definitions are inherited in the same way as
 properties. The example in <a href="#xmp-variable">Listing 19</a> shows a
 class <tt>Derived</tt> that inherits from <tt>Base</tt>. When an instance <tt>d1</tt> is
@@ -1795,26 +1592,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Base2 {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Base2 {
  <span class='nx-comment'># ...
 </span> <span class='nx-keyword'>:method</span> <span class='nx-keyword'>init</span> {} {
    <span class='nx-keyword'>set</span> :x 1
@@ -1832,7 +1610,7 @@
 }
 
 <span class='nx-comment'># Create instance of the class Derived2
-</span>Derived2 <span class='nx-keyword'>create</span> d2</pre></td></tr></table></div></div>
+</span>Derived2 <span class='nx-keyword'>create</span> d2</pre></div></div>
 <div class="paragraph"><p>In many other object oriented languages, the instance variables are
 initialized solely by the constructor (similar to class <tt>Derived2</tt> in
 <a href="#xmp-constructor">Listing 20</a>). This approach is certainly
@@ -1874,21 +1652,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-comment'># Define a class
+<pre class='nx'><span class='nx-comment'># Define a class
 </span><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Dog {
 
   <span class='nx-comment'># Define a scripted method for the class
@@ -1901,7 +1665,7 @@
 </span>Dog <span class='nx-keyword'>create</span> fido
 
 <span class='nx-comment'># The following line prints "::fido Bark, bark, bark."
-</span>fido bark</pre></td></tr></table></div></div>
+</span>fido bark</pre></div></div>
 <div class="paragraph"><p>In the example above we create a class <tt>Dog</tt> with a scripted method
 named <tt>bark</tt>. The method body defines the code, which is executed when
 the method is invoked. In this example, the method <tt>bar</tt> prints out a
@@ -1947,32 +1711,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Dog {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Dog {
  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> bark {} { <span class='nx-keyword'>puts</span> <span class='nx-string'>"[self] Bark, bark, bark."</span> }
  <span class='nx-keyword'>:method</span> <span class='nx-keyword'>init</span> {} { Tail <span class='nx-keyword'>create</span> [<span class='nx-keyword'>self</span>]::tail}
 }
@@ -1996,7 +1735,7 @@
 </span>fido::tail length 10
 
 <span class='nx-comment'># Proving an invalid values will raise an error
-</span>fido::tail length <span class='nx-string'>"Hello"</span></pre></td></tr></table></div></div>
+</span>fido::tail length <span class='nx-string'>"Hello"</span></pre></div></div>
 <div class="paragraph"><p><a href="#xmp-fido2">Listing 22</a> shows an extended example, where every dog
 has a tail. The object <tt>tail</tt> is created as a subobject of the dog in
 the constructor <tt>init</tt>. The subobject can be accessed by providing the
@@ -2016,26 +1755,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Dog {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Dog {
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> bark {} { <span class='nx-keyword'>puts</span> <span class='nx-string'>"[self] Bark, bark, bark."</span> }
   <span class='nx-keyword'>:method</span> <span class='nx-keyword'>init</span> {} {
     Tail <span class='nx-keyword'>create</span> [<span class='nx-keyword'>self</span>]::tail
@@ -2053,7 +1773,7 @@
 
 <span class='nx-comment'># The invocation of "fido wag" is delegated to "fido::tail wag".
 </span><span class='nx-comment'># Therefore, the following method returns "Joy".
-</span>fido wag</pre></td></tr></table></div></div>
+</span>fido wag</pre></div></div>
 <div class="paragraph"><p><a href="#xmp-fido3">Listing 23</a> again extends the example by adding a
 forwarder named <tt>wag</tt> to the object (e.g. <tt>fido</tt>). The forwarder
 redirects all calls of the form <tt>fido wag</tt> with arbitrary arguments to
@@ -2099,20 +1819,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Dog {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Dog {
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> bark {} { <span class='nx-keyword'>puts</span> <span class='nx-string'>"[self] Bark, bark, bark."</span> }
 
   <span class='nx-comment'># Define a public alias for the method "bark"
@@ -2124,7 +1831,7 @@
 </span>Dog <span class='nx-keyword'>create</span> fido
 
 <span class='nx-comment'># The following line prints "::fido Bark, bark, bark."
-</span>fido warn</pre></td></tr></table></div></div>
+</span>fido warn</pre></div></div>
 <div class="paragraph"><p><a href="#xmp-fido4">Listing 24</a> extends the last example by defining an
 alias for the method "bark". The example only shows the bare
 mechanism. In general, method aliases are very powerful means for
@@ -2172,29 +1879,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Foo {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Foo {
 
   <span class='nx-comment'># Define a public method
 </span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {} {
@@ -2215,7 +1900,7 @@
 </span>f1 foo
 
 <span class='nx-comment'># The invocation of the protected method "helper" raises an error:
-</span>f1 helper</pre></td></tr></table></div></div>
+</span>f1 helper</pre></div></div>
 <div class="paragraph"><p>The example above uses <tt>:protected method helper &#8230;</tt>. We could have
 used here as well <tt>:method helper &#8230;</tt>, since the default method
 call-protection is already protected.</p></div>
@@ -2235,21 +1920,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Base {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Base {
   <span class='nx-keyword'>:private</span> <span class='nx-keyword'>method</span> helper {a b} {<span class='nx-keyword'>expr</span> {<span class='nx-variable'>$a</span> + <span class='nx-variable'>$b</span>}}
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo     {a b} {: -local helper <span class='nx-variable'>$a</span> <span class='nx-variable'>$b</span>}
 }
@@ -2262,7 +1933,7 @@
 
 s1 foo 3 4     ;<span class='nx-comment'># returns 7
 </span>s1 bar 3 4     ;<span class='nx-comment'># returns 12
-</span>s1 helper 3 4  ;<span class='nx-comment'># raises error: unable to dispatch method helper</span></pre></td></tr></table></div></div>
+</span>s1 helper 3 4  ;<span class='nx-comment'># raises error: unable to dispatch method helper</span></pre></div></div>
 <div class="paragraph"><p>The base class implements a public method <tt>foo</tt> using the helper
 method named <tt>helper</tt>. The derived class implements a as well a public
 method <tt>bar</tt>, which is also using a helper method named <tt>helper</tt>. When
@@ -2306,22 +1977,14 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {} {<span class='nx-keyword'>return</span> 1}
   <span class='nx-keyword'>:create</span> c1
 }
 
 <span class='nx-comment'># Method "foo" is defined on class "C"
 </span><span class='nx-comment'># and applicable to the instances of "C"
-</span>c1 foo</pre></td></tr></table></div></div>
+</span>c1 foo</pre></div></div>
 <div class="paragraph"><p>There are many programming languages that only allow these types of methods.
 However, NX also allows methods to be defined on objects.</p></div>
 </div>
@@ -2351,26 +2014,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {} {<span class='nx-keyword'>return</span> 1}
   <span class='nx-keyword'>:create</span> c1 {
      <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {} {<span class='nx-keyword'>return</span> 2}
@@ -2388,7 +2032,7 @@
 </span><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o1 {
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> baz {} {<span class='nx-keyword'>return</span> 4}
 }
-o1 baz</pre></td></tr></table></div></div>
+o1 baz</pre></div></div>
 </div>
 <div class="sect3">
 <h4 id="_class_methods">3.4.3. Class Methods</h4>
@@ -2418,32 +2062,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Define a class method "bar" and an instance
 </span>  <span class='nx-comment'># method "foo"
@@ -2467,7 +2086,7 @@
 
 <span class='nx-comment'># When trying to invoke the class method on the
 </span><span class='nx-comment'># instance, an error will be raised.
-</span>c1 bar</pre></td></tr></table></div></div>
+</span>c1 bar</pre></div></div>
 <div class="paragraph"><p>In some other object oriented programming languages, class methods
 are called "static methods".</p></div>
 </div>
@@ -2503,21 +2122,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
 
     <span class='nx-comment'># Define an ensemble method "string" with sub-methods
 </span>    <span class='nx-comment'># "length", "tolower" and "info"
@@ -2530,7 +2135,7 @@
 }
 
 <span class='nx-comment'># Invoke the ensemble method
-</span>c1 <span class='nx-keyword'>string</span> length <span class='nx-string'>"hello world"</span></pre></td></tr></table></div></div>
+</span>c1 <span class='nx-keyword'>string</span> length <span class='nx-string'>"hello world"</span></pre></div></div>
 </div>
 <div class="sect2">
 <h3 id="_method_resolution">3.6. Method Resolution</h3>
@@ -2554,27 +2159,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {} { <span class='nx-keyword'>return</span> <span class='nx-string'>"C foo: [next]"</span>}
 }
 
@@ -2593,7 +2178,7 @@
 </span>
 <span class='nx-comment'># Query the precedence order from NX via introspection
 </span>d1 <span class='nx-keyword'>info</span> precedence
-<span class='nx-comment'># result: "::D ::C ::nx::Object"</span></pre></td></tr></table></div></div>
+<span class='nx-comment'># result: "::D ::C ::nx::Object"</span></pre></div></div>
 <div class="paragraph"><p>Consider the example in
 <tt>foo</tt> is invoked on object <tt>d1</tt>, the per-object method has the highest
 precedence and is therefore invoked. The per-object methods shadows
@@ -2620,31 +2205,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> M1 {
+<pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> M1 {
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {} { <span class='nx-keyword'>return</span> <span class='nx-string'>"M1 foo: [next]"</span>}
 }
 <span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> M2 {
@@ -2667,7 +2228,7 @@
 </span>
 <span class='nx-comment'># Query the precedence order from NX via introspection
 </span>d1 <span class='nx-keyword'>info</span> precedence
-<span class='nx-comment'># result: "::M1 ::M2 ::D ::C ::nx::Object"</span></pre></td></tr></table></div></div>
+<span class='nx-comment'># result: "::M1 ::M2 ::D ::C ::nx::Object"</span></pre></div></div>
 <div class="paragraph"><p>an extension of the previous example. We define here two additional
 classes <tt>M1</tt> and <tt>M2</tt> which are used as per-object and per-class
 mixins.  Both classes define the method <tt>foo</tt>, these methods shadow
@@ -2686,23 +2247,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-comment'>#
+<pre class='nx'><span class='nx-comment'>#
 </span><span class='nx-comment'># "d1" is created based on the definitions of the last two examples,
 </span><span class='nx-comment'># the mixins "M1" and "M2" are registered.
 </span><span class='nx-comment'>#
@@ -2717,7 +2262,7 @@
 }
 
 <span class='nx-comment'># Invoke the method "bar"
-</span>d1 bar</pre></td></tr></table></div></div>
+</span>d1 bar</pre></div></div>
 <div class="paragraph"><p>In the first line of the body of method <tt>bar</tt>, the method <tt>foo</tt> is
 called as usual with an implicit receiver, which defaults to the
 current object (therefore, the call is equivalent to <tt>d1 foo</tt>). The
@@ -2810,43 +2355,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o1 {
+<pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o1 {
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Method foo has positional parameters:
@@ -2881,7 +2390,7 @@
 <span class='nx-comment'># invoke baz (positional and non-positional parameters)
 </span>o1 baz -x 1 100
 o1 baz 200
-o1 baz -- -y</pre></td></tr></table></div></div>
+o1 baz -- -y</pre></div></div>
 <div class="paragraph"><p>Consider the example in <a href="#xmp-posnonpos">Listing 34</a>. The method
 <tt>foo</tt> has the argument list <tt>x y</tt>. This means that the first argument
 is passed in an invocation like <tt>o1 foo 1 2</tt> to <tt>x</tt> (here, the value
@@ -2927,28 +2436,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o2 {
+<pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o2 {
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Method foo has one required and one optional
@@ -2968,7 +2456,7 @@
 }
 
 <span class='nx-comment'># invoke foo (one optional positional parameter is missing)
-</span>o2 foo 1</pre></td></tr></table></div></div>
+</span>o2 foo 1</pre></div></div>
 <div class="paragraph"><p>The example in <a href="#xmp-optional-req">Listing 35</a> defined method <tt>foo</tt>
 with one required and one optional positional parameter. For this
 purpose we use the parameter options <tt>required</tt> and <tt>optional</tt>. The
@@ -3006,27 +2494,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o3 {
+<pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o3 {
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Positional parameter with default value:
@@ -3045,7 +2513,7 @@
 
 <span class='nx-comment'># use default values
 </span>o3 foo
-o3 bar</pre></td></tr></table></div></div>
+o3 bar</pre></div></div>
 <div class="paragraph"><p>In order to define a default value, the parameter specification must
 be of the form of a 2 element list, where the second argument is the
 default value. See for an example in
@@ -3096,26 +2564,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o4 {
+<pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o4 {
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Positional parameter with value constraints:
@@ -3133,7 +2582,7 @@
 }
 
 <span class='nx-comment'># The following invocation raises an exception
-</span>o4 foo a</pre></td></tr></table></div></div>
+</span>o4 foo a</pre></div></div>
 <div class="paragraph"><p>Value contraints are specified as parameter options in the parameter
 specifications. The parameter specification <tt>x:integer</tt> defines <tt>x</tt> as
 a required positional parmeter which value is constraint to an
@@ -3155,35 +2604,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-comment'>#
+<pre class='nx'><span class='nx-comment'>#
 </span><span class='nx-comment'># Create classes for Person and Project
 </span><span class='nx-comment'>#
 </span><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Person
@@ -3210,7 +2631,7 @@
 <span class='nx-comment'>#
 </span><span class='nx-comment'># Use method with value constraints
 </span><span class='nx-comment'>#
-</span>o5 work -person gustaf -project nx</pre></td></tr></table></div></div>
+</span>o5 work -person gustaf -project nx</pre></div></div>
 <div class="paragraph"><p>The native checkers <tt>object</tt>, <tt>class</tt>, <tt>metaclass</tt> and <tt>baseclass</tt> can
 be further specialized with the parameter option <tt>type</tt> to restrict
 the permissible values to instances of certain classes. We can use for
@@ -3244,47 +2665,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-comment'>#
+<pre class='nx'><span class='nx-comment'>#
 </span><span class='nx-comment'># Value checker named "groupsize"
 </span><span class='nx-comment'>#
 </span>::nx::Slot <span class='nx-keyword'>method</span> type=groupsize {name value} {
@@ -3323,7 +2704,7 @@
 
 <span class='nx-comment'># testing "choice"
 </span>d1 bar green good
-d1 bar pink bad</pre></td></tr></table></div></div>
+d1 bar pink bad</pre></div></div>
 <div class="paragraph"><p>In order to define a checker <tt>groupsize</tt> a method of the name
 <tt>type=groupsize</tt> is defined. This method receives two arguments,
 <tt>name</tt> and <tt>value</tt>. The first argument is the name of the parameter
@@ -3381,33 +2762,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o6 {
+<pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o6 {
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Positional parameter with an possibly empty
@@ -3432,7 +2787,7 @@
 </span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> baz {x:integer,1..n} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x"</span>
   }
-}</pre></td></tr></table></div></div>
+}</pre></div></div>
 <div class="paragraph"><p><a href="#xmp-multiplicity">Listing 41</a> contains three examples for
 positional parameters with different multiplicities. Multiplicity is
 often combined with value constraints. A parameter specification of
@@ -3522,34 +2877,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-comment'>#
+<pre class='nx'><span class='nx-comment'>#
 </span><span class='nx-comment'># Define a class Person with properties "name"
 </span><span class='nx-comment'># and "birthday"
 </span><span class='nx-comment'>#
@@ -3575,7 +2903,7 @@
 Student <span class='nx-keyword'>create</span> s1 -name Susan -matnr 4711
 
 <span class='nx-comment'># Access property value via accessor method
-</span><span class='nx-keyword'>puts</span> <span class='nx-string'>"The name of s1 is [s1 name]"</span></pre></td></tr></table></div></div>
+</span><span class='nx-keyword'>puts</span> <span class='nx-string'>"The name of s1 is [s1 name]"</span></pre></div></div>
 <div class="paragraph"><p>The class <tt>Person</tt> has two properties <tt>name</tt> and <tt>birthday</tt>, where the
 property <tt>name</tt> is required, the property <tt>birthday</tt> is not. The
 class <tt>Student</tt> is a subclass of <tt>Person</tt> with the additional required
@@ -3632,22 +2960,14 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>Object</span> parameter <span class='nx-keyword'>for</span> Person p1:
+<pre class='nx'><span class='nx-keyword'>Object</span> parameter <span class='nx-keyword'>for</span> Person p1:
    -name:required -birthday ...
    -mixin:mixinreg,<span class='nx-keyword'>alias</span>,1..n -filter:filterreg,<span class='nx-keyword'>alias</span>,1..n _:initcmd,optional
 
 <span class='nx-keyword'>Object</span> parameter <span class='nx-keyword'>for</span> Student s1:
    -matnr:required {-oncampus:boolean true}
    -name:required -birthday ...
-   -mixin:mixinreg,<span class='nx-keyword'>alias</span>,1..n -filter:filterreg,<span class='nx-keyword'>alias</span>,1..n _:initcmd,optional</pre></td></tr></table></div></div>
+   -mixin:mixinreg,<span class='nx-keyword'>alias</span>,1..n -filter:filterreg,<span class='nx-keyword'>alias</span>,1..n _:initcmd,optional</pre></div></div>
 <div class="paragraph"><p>The actual values can be obtained via introspection via <tt>Person info
 parameter definition</tt>. The object parameter types <tt>mixinreg</tt> and
 <tt>filterreg</tt> are for converting definitions of filters and mixins.  The
@@ -3694,12 +3014,9 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>Object</span> parameter <span class='nx-keyword'>for</span> <span class='nx-keyword'>Class</span> Student:
+<pre class='nx'><span class='nx-keyword'>Object</span> parameter <span class='nx-keyword'>for</span> <span class='nx-keyword'>Class</span> Student:
    -mixin:mixinreg,<span class='nx-keyword'>alias</span>,1..n -filter:filterreg,<span class='nx-keyword'>alias</span>,1..n ...
-   {-superclass<span class='nx-keyword'>:class</span>,<span class='nx-keyword'>alias</span>,1..n ::nx::Object} ...</pre></td></tr></table></div></div>
+   {-superclass<span class='nx-keyword'>:class</span>,<span class='nx-keyword'>alias</span>,1..n ::nx::Object} ...</pre></div></div>
 <div class="paragraph"><p>The actual values can be obtained via introspection via <tt>nx::Class info
 parameter definition</tt>.</p></div>
 </div>
@@ -3800,17 +3117,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
-</pre></td><td class='nx-body'><pre class='nx'>::nx::Object <span class='nx-keyword'>create</span> o {
+<pre class='nx'>::nx::Object <span class='nx-keyword'>create</span> o {
   <span class='nx-keyword'>:method</span> <span class='nx-keyword'>unknown</span> {called_method args} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"Unknown method '$called_method' called"</span>
   }
@@ -3819,7 +3126,7 @@
 <span class='nx-comment'># Invoke an unknown method for object o:
 </span>o foo 1 2 3
 
-<span class='nx-comment'># Output will be: "Unknown method 'foo' called"</span></pre></td></tr></table></div></div>
+<span class='nx-comment'># Output will be: "Unknown method 'foo' called"</span></pre></div></div>
 <div class="paragraph"><p>Without any provision of an unknown method handler, an error will be
 raised, when an unknown method is called.</p></div>
 </div>
@@ -3844,29 +3151,7 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
-</pre></td><td class='nx-body'><pre class='nx'>::nx::Class <span class='nx-keyword'>public</span> <span class='nx-keyword'>class</span> <span class='nx-keyword'>method</span> __unknown {name} {
+<pre class='nx'>::nx::Class <span class='nx-keyword'>public</span> <span class='nx-keyword'>class</span> <span class='nx-keyword'>method</span> __unknown {name} {
   <span class='nx-comment'># A very simple unknown handler, showing just how
 </span>  <span class='nx-comment'># the mechanism works.
 </span>  <span class='nx-keyword'>puts</span> <span class='nx-string'>"***** __unknown called with &lt;$name&gt;"</span>
@@ -3887,7 +3172,7 @@
   <span class='nx-comment'># The output will be:
 </span>  <span class='nx-comment'>#     ***** __unknown called with &lt;::M&gt;
 </span>  <span class='nx-comment'>#     ::M
-</span>}</pre></td></tr></table></div></div>
+</span>}</pre></div></div>
 <div class="paragraph"><p>The Next Scripting Framework allows to add, query, delete and list unknown handlers.</p></div>
 <div class="paragraph" id="xmp-unknown-registration"><div class="title">Listing 49: Unknown Handler registration</div><p></p></div>
 <div class="listingblock">
@@ -3901,16 +3186,11 @@
 .nx-placeholder {color: #AF663F; font-weight: normal; font-style: italic;}
 .nx-variable    {color: #AF663F; font-weight: normal; font-style: normal;}
 </style>
-<table class='nx'><tr><td class='nx-linenr'><pre>  1
-  2
-  3
-  4
-  5
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-comment'># Interface for unknown handlers:
+<pre class='nx'><span class='nx-comment'># Interface for unknown handlers:
 </span><span class='nx-comment'># nsf::object::unknown::add /key/ /handler/
 </span><span class='nx-comment'># nsf::object::unknown::get /key/
 </span><span class='nx-comment'># nsf::object::unknown::delete /key/
-</span><span class='nx-comment'># nsf::object::unknown::keys</span></pre></td></tr></table></div></div>
+</span><span class='nx-comment'># nsf::object::unknown::keys</span></pre></div></div>
 <div class="ulist bibliography"><div class="title">References</div><ul>
 <li>
 <p>
@@ -3994,7 +3274,7 @@
 <div id="footer">
 <div id="footer-text">
 Version 2.1<br />
-Last updated 2011-12-22 11:52:31 CET
+Last updated 2012-01-16 14:39:46 CET
 </div>
 </div>
 </body>
