API doc extraction

+syntax: glob
+
+doc/api/*
+dist/*
+dput.sh
+*.pyc
+*~
+.gone
+,*
+*.class

+abcd crash on [foo>>(s), foo<<(s+s)]
+[foo(x,y,z)] creates a multi-arc instead of a tuple
+
+abcd substitues for loops variables:
+net Foo (x) :
+    buffer b : int = [x for x in range(4)]
+                      ^     ^
+                      substituted (should not)
+
+errors during expressions evaluation are directly sent to user, should be wrapper to indicate this is a model error. And should be catched in abcd --simul/check

+recursive-include doc *
+include *

+all:
+	@echo "Commands:"
+	@echo "  release    prepare source for release"
+	@echo "  tgz        build a source tarball"
+	@echo "  doc        build API documentation"
+	@echo "  dput       build and upload Ubuntu packages"
+	@echo "  clean      delete some garbage files"
+	@echo "  test       run tests through supported Python implementations"
+	@echo "  next-deb   increments debian/VERSION"
+	@echo "  next-ppa   increments debian/PPA"
+	@echo "  lang       build generated files in snakes/lang"
+	@echo "  emacs      compile Emacs files"
+
+committed:
+	hg summary|grep -q '^commit: (clean)$$'
+
+next-deb:
+	echo 1 > debian/PPA
+	echo $$((1+$$(cat debian/VERSION))) > debian/VERSION
+
+emacs:
+	emacs -batch -f batch-byte-compile utils/abcd-mode.el
+
+next-ppa:
+	echo $$((1+$$(cat debian/PPA))) > debian/PPA
+
+release: committed test doc tgz
+	hg tag version-$$(cat VERSION)
+	echo 1 > debian/PPA
+	echo 1 > debian/VERSION
+	hg commit -m "version $$(cat VERSION)"
+	hg push
+
+lang:
+	python mklang.py
+
+tgz: committed
+	hg archive snakes-$$(cat VERSION)-$$(cat debian/VERSION)
+	cd snakes-$$(cat VERSION)-$$(cat debian/VERSION) && make doc
+	tar cf snakes-$$(cat VERSION)-$$(cat debian/VERSION).tar snakes-$$(cat VERSION)-$$(cat debian/VERSION)
+	rm -rf snakes-$$(cat VERSION)-$$(cat debian/VERSION)
+	gzip -9 snakes-$$(cat VERSION)-$$(cat debian/VERSION).tar
+	gpg --armor --sign --detach-sig snakes-$$(cat VERSION)-$$(cat debian/VERSION).tar.gz
+
+doc: snakes/*.py snakes/plugins/*.py snakes/utils/*.py snakes/lang/*.py
+	make -C doc
+
+dput.sh: VERSION debian/*
+	python mkdeb.py
+
+dput: committed dput.sh
+	sh dput.sh
+
+clean:
+	rm -f $$(find . -name ",*")
+	rm -f $$(find . -name "*.pyc")
+	rm -f $$(find . -name "*~")
+	rm -f $$(find . -name "*.class")
+	rm -rf $$(find . -type d -name __pycache__)
+
+test:
+	python2.5 test.py
+	python2.6 test.py
+	python2.7 test.py
+	python3 test.py
+	unladen test.py
+	pypy test.py
+	spypy test.py
+	stackless test.py
+	jython test.py

+ + emacs mode for ABCD
+ ! fixex nodes merge in plugin labels
+ ! fixed nets.MultiArc.flow (thanks to Jan Ciger's report)
+
+version 0.9.13 (Fri Jul 16 17:01:22 CEST 2010):
+ + added inhibitor arcs
+ + added Ubuntu Lucid (10.04) package
+ ! fixed data.WordSet.fresh when base is used
+ ! fixed reduce(xor, []) is some __hash__ methods
+ + added PetriNet.layout method in snakes.plugins.gv
+
+version 0.9.12 (Thu Apr 1 19:42:33 CEST 2010):
+ + removed PyGraphviz dependency (layout method supressed temporarily)
+ + now compatible with PyPy (1.2), Unladen-Swallow and Jython (2.5.1)
+ ! fixed snakes.plugins.clusters.rename_node
+ ! fixed snakes.nets.Flush.flow
+ ! fixed an uncaught exception in snakes.data.MultiSet.__eq__
+   and snakes.data.Symbol.__eq__
+ ! hopefully fixed LALR built in ABCD compiler
+ ! fixed hash-related issues
+ * moved PLY stuff to snakes.utils.abcd
+ * snakes.compyler has been completely replaced (PLY dependency removed)
+
+version 0.9.11 (Thu Mar 25 19:32:31 CET 2010):
+ ! fixed various doctests
+ ! fixed issues with attributes locking
+ ! fixed issues related to missing __hash__ methods
+ ! fixed renaming a node to itself in ABCD
+ + added snakes.nets.Evaluator.__contains__
+ + added base argument to snakes.data.WordSet
+ + added option --symbols to ABCD compiler
+ + added snakes.data.Symbol
+ + added net instances naming in ABCD
+ + added logo
+ + added let function to update bindings from expressions
+ + added snakes.data.Subtitution.__setitem__
+
+version 0.9.10 (Fri Jun 19 13:32:45 CEST 2009):
+ ! fixed inconstent hashing on clusters
+ ! fixed mutability of hashed multisets
+ ! fixed snakes.nets.Tuple.mode
+
+version 0.9.9 (Tue, 19 May 2009 15:00:00 +0100):
+ + added mkdeb.py to build deb packages for multiple distributions
+ + ported to Python 2.6
+
+version 0.9.8 (lun, 23 mar 2009 17:30:34 (CET)):
+ + added graph_attr option to snakes.plugins.gv.StateGraph
+ * plugin gv now draws partially constructed marking graphs
+ ! fixed expression compilation in present of net parameters in ABCD
+   compiler
+ ! fixed flush arcs binding
+ * plugin lashdata has been removed because its too experimental
+ * merged plugin decorators into a single one
+
+version 0.9.7 (Tue, 20 Jan 2009 13:04:15 +0100):
+ ! fixed sharing of globals between net components
+ ! fixed loading of PNML when some plugins fail to load
+ + added cpp option to abcd
+ + added some docstrings and doctests
+ ! fixed sharing of globals between net components
+
+version 0.9.6 (Fri, 28 Nov 2008 15:22:27 +0100):
+ + added doc for ABCD
+ ! fixed False and True handling in ABCD compiler
+ + added cross product types to ABCD
+
+version 0.9.5 (Wed, 19 Nov 2008 21:42:05 +0100):
+ + added distutils setup.py
+ * strip PNML data before decoding (work around invalid XML)
+ ! fixed Multiset.__pnmlload__ on iterable values
+
+version 0.9.4 (mar, 28 oct 2008 12:28:02 (UTC+0100)):
+ ! fixed nets.Value.__eq__, __ne__ and __hash__
+ ! fixed nets.Token.__repr__
+ + added Flush arcs
+ ! fixed nets.Tuple.bind
+ ! fixed PNML dump/load of subclasses
+ ! fixed nets.PetriNet.merge_* in the presence of Tuple arcs
+ ! fixed plugins.clusters.Cluster.path
+ ! fixed plugins.status.PetriNet.__pnmlload__
+ ! fixed ABCD lexer
+ + improved ABCD compiler with parametric nets, Python declarations
+ ! fixed black token values in ABCD     arcs     and flush
+ + ABCD compiler launches pdb.post_mortem when an error occurs in
+ + added TCP mode to query plugin     debug mode
+ * removed dependency to epydoc in snakes.typing
+ + updated PNML doc
+ + added a producer/consumer ABCD example
+
+version 0.9.3 (lun, 29 sep 2008 08:04:55 (CEST)):
+ ! fixed a bug in place pnml loading
+ ! fixed wrong association of pnml tags to classes
+ + improved query and associated programs, added documentation
+ * improved loading of PNML files with plugins
+ * PNML tag <snakes> can only occur once as a child of <pnml>
+ + abcd compiler adds many structural information to PNML (including
+ + test.py checks is snakes.version is correct     AST if asked)
+ + query plugins now has two verbosity levels
+ + added snakes.compyler.Tree.__pnmldump__()
+
+version 0.9.2
+ + added query plugin and demon client/server programs
+ ! various small bugs fixed
+ + improved PNML serialisation of standard objects
+ + snakes.plugins.load puts new module in caller's environment
+ ! fixed snakes.pnml.Tree.update
+ * Substitution.image() returns a set
+ + added apix.py
+ ! PNML export empty arcs fixed
+ ! fixed broken abcd.py
+ * updated abcd.py so it uses gv
+ * improved clustering efficiency
+
+version 0.9.1
+ + added plugin gv to replace graphviz
+ + added plugin clusters to manage clusters of nodes
+ + updated plugins ops so it builds clusters
+ * the plugin posops is deprecated since gv does the work much better
+
+version 0.9
+ * dropped compatibilty with Python 2.4
+ + finished pnml
+ * the compyler module has been completely replaced
+
+Changes in 0.8.4 (06.09.2007 11:30:21):
+ + updated the tutorial
+
+Changes in 0.8.3 (29.06.2007 11:57:39):
+ + snakes.plugins.graphivz: added options to control the layout
+ + snakes.plugins.graphviz: improved the rendering
+ + updated the tutorial
+
+Changes in 0.8.2 (22.06.2007 13:09:02):
+ + snakes.plugins.ops: added a name hiding operator (PetriNet.__div__)
+ ! fixed several copy/clone problems
+
+Changes in 0.8.1 (20.06.2007 10:18:17):
+ * updated tutorial
+ + snakes.plugins.pos: the position of a node can be redefined when
+ ! snakes.plugins.pos: accept float positions when loading from pnml
+
+Changes in 0.8 (19.06.2007 17:19:19): First public release.

+SNAKES is the Net Algebra Kit for Editors and Simulators
+========================================================
+
+////////////////////////////////////////////////////////////////
+This file is formatted in order to be processed by AsciiDoc
+(http://www.methods.co.nz/asciidoc). It will be more comfortable
+to render it or to read the HTML version available at:
+http://www.univ-paris12.fr/pommereau/soft/snakes/index.html
+////////////////////////////////////////////////////////////////
+
+SNAKES is a Python library that provides all then necessary to define
+and execute many sorts of Petri nets, in particular those of the PBC
+and M-nets family. Its main aim is to be a general Petri net library,
+being able to cope with most Petri nets models, and providing the
+researcher with a tool to quickly prototype its new ideas. SNAKES
+should be suitable to provide the data model for editors or
+simulators; actually, any editor that use SNAKES may also be a
+simulator as SNAKES can execute any net.
+
+A key feature of SNAKES is the ability to use arbitrary Python objects
+as tokens and arbitrary Python expressions in many points, for
+instance in transitions guards or arcs outgoing of transitions. This
+is what makes SNAKES that general. This relies on the capability of
+Python to run dynamically provided Python code (the $eval$ function).
+This feature may not be efficient enough for model-checking: speed is
+the price to pay for the wide generality. However, in the case of a
+new model, SNAKES may happen to be the only available tool.
+
+Another important feature of SNAKES is the plugin system that allows
+to extend the features and work with specialised classes of Petri
+nets. Currently, the following plugins are provided:
+
+pos:: adds to nodes the capability of holding their position. Nodes
+can be moved or shifted, Petri nets can be shifted globally and their
+bounding box can be computed.
+
+gv:: adds a method to draw a Petri net or a state graph using the tool
+http://www.graphviz.org[GraphViz] (through the Python binding
+http://networkx.lanl.gov/wiki/pygraphviz[PyGraphViz]). This module
+replaces the previous plugin called _graphviz_ and provides more
+flexibility and security, _graphviz_ is still provided but deprecated.
+
+status:: extends the Petri net model by adding status to the nodes.
+This is similar to what is used in the models of the PBC or Mnets
+family. Nodes can then merged automatically according to their status.
+
+ops:: this plugins defines control flow operations on Petri nets
+usually found in the PBC and Mnets family. Nets can be composed in
+parallel, sequence, choice and iteration. These operations rely on the
+places status.
+
+labels:: allows to add arbitrary labels to most objects (places,
+transitions, nets, ...)
+
+posops:: combines the features of pos and ops plugins: the control
+flow operations are modified in order to rearrange the nodes position
+in order to provide well shaped nets. This plugin is deprecated
+because the new _gv_ does the work much better.
+
+synchro:: it defines the label-based transition synchronisation
+defined in the Mnets model.
+
+// export:: allows to save Petri nets objects in the format of the tools
+// http://pep.sourceforge.net[PEP], http://helena.cnam.fr[Helena] and
+// http://maria[Maria]. http://pnml[PNML] is also supported as it is
+// built-in SNAKES.
+
+lashdata:: allows to define data that is not handled in the places of
+the Petri net but stored instead in the special structures handled by
+the http://www.montefiore.ulg.ac.be/~boigelot/research/lash/[library
+Lash]. This allows in particular to aggregate possibly infinite states
+into one meta-state.
+
+clusters:: this is an auxiliary plugin that allows to group nodes in a
+Petri net. This feature is used by _ops_ in order to record how a net
+is constructed, which is exploited by _gv_ in order to build a nice
+layout of composed nets.
+
+
+Getting SNAKES and installing it
+--------------------------------
+
+Download http://www.univ-paris12.fr/lacl/pommereau/soft/snakes/snakes-{VERSION}.tar.gz[$snakes-{VERSION}.tar.gz$]
+({sys:../stat snakes-{VERSION}.tar.gz})
+
+To install SNAKES, uncompress the archive and copy the directory
+snakes in a location where Python can find it (_i.e._, in a directory
+listed in your $PYTHONPATH$ environment variable).
+
+SNAKES should work with a Python version at least 2.5 but will _not_
+work for an older version. Optionally, you may want to install
+additional software required by some plugins:
+
+gv:: depends on http://www.graphviz.org[GraphViz] and its Python
+   binding http://networkx.lanl.gov/wiki/pygraphviz[PyGraphViz]. The
+   plugin _graphviz_ depends on GraphViz only but is now deprecated.
+
+lashdata:: requires
+   http://www.montefiore.ulg.ac.be/~boigelot/research/lash[Lash] and
+   the
+   http://www.univ-paris12.fr/lacl/pommereau/soft/index.html#PyLash[Python
+   Lash binding].
+
+[NOTE]
+=====================
+(C) 2007 Franck Pommereau <pommereau@univ-paris12.fr>
+
+This library is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as
+published by the Free Software Foundation; either version 2.1 of the
+License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+USA
+=====================
+
+
+Contact
+-------
+
+Please feel free to send me comments, questions, bug reports or
+contributions by mailto:pommereau@univ-paris12.fr[email].
+
+If you wish to be notified of the new releases of SNAKES, please
+register at the http://freshmeat.net/projects/snakes[FreshMeat page].
+
+You may contribute to SNAKES by either send patches by email, or by
+using the https://launchpad.net/snakes[SNAKES Launchpad page].
+
+
+Documentation
+-------------
+
+A good starting point may be the link:tutorial.html[tutorial]. Then,
+you may find the link:api/index.html[API reference manual] useful, it
+documents all the API and gives number of examples of how to use the
+various classes and functions.
+
+If you do not program Python, you can learn it in a few hours thanks
+to the very good http://docs.python.org/tut/tut.html[Python tutorial].
+
+In order to know more about the PBC and M-nets family or the Petri net
+compositions defined in the plugins, you may read papers from
+http://www.univ-paris12.fr/lacl/pommereau/publis[my publications page]
+(in particular those with _calculus_ in the title).

+* add name to transitions, eg, [buff-(x) as name]
+  make it consistent with instance names?
+* zero test/inhibitor arc
+! parameter and global buffer with same names => parameter ignored
+! accept net instances with too much parameters

+0.9.16

+#!/usr/bin/env python
+import snakes.utils.abcd.main as abcdmain
+abcdmain.main()

+#!/usr/bin/env python
+import socket, sys, readline
+from snakes.pnml import dumps, loads
+from snakes.plugins.query import Query
+
+env = {}
+
+def public (fun) :
+    env[fun.__name__] = fun
+    return fun
+
+@public
+def set (*larg, **karg) :
+    """set(name, value) -> None
+    assign value (object) to name (str) on the server"""
+    return Query("set", *larg, **karg)
+
+@public
+def get (*larg, **karg) :
+    """get(name) -> object
+    return the last value assigned to name (str)"""
+    return Query("get", *larg, **karg)
+
+@public
+def delete (*larg, **karg) :
+    """delete(name) -> None
+    discard name (str)"""
+    return Query("del", *larg, **karg)
+
+@public
+def call (*larg, **karg) :
+    """call(obj, ...) -> object
+    call obj (str or result from another call) with the additional arguments
+    return whatever the called object returns"""
+    return Query("call", *larg, **karg)
+
+@public
+def help (command=None) :
+    """help(command) -> None
+    print help about command, if no command is given, list available commands"""
+    if command is None:
+        print "commands:", ", ".join(repr(cmd) for cmd in env
+                                     if not cmd.startswith("_"))
+        print "  type 'help(cmd)' to ge help about a command"
+    elif command in env :
+        print env[command].__doc__
+    elif command.__name__ in env :
+        print command.__doc__
+    else :
+        print "unknown command %r" % command
+
+@public
+def quit () :
+    """quit() -> None
+    terminate the client"""
+    print "bye"
+    sys.exit(0)
+
+@public
+def load (path) :
+    """net(path) -> object
+    load a PNML file from path (str) and return the object is represents"""
+    return loads(open(path).read())
+
+@public
+def show (query) :
+    """show(obj) -> None
+    show the PNML representation of obj (object), for instance of a query"""
+    print dumps(query)
+
+_verbose = False
+
+@public
+def verbose (state=None) :
+    """verbose(state) -> None
+    turn on (state=True), off (state=False) or toggle (state not
+    given) the printing of queries before they are sent to the
+    server"""
+    global _verbose
+    if state is None :
+        _verbose = not _verbose
+    else :
+        _verbose = state
+    if _verbose :
+        print "dump of queries enabled"
+    else :
+        print "dump of queries disabled"
+
+try :
+    if sys.argv[1] in ("-t", "--tcp") :
+        proto = "TCP"
+        del sys.argv[1]
+    else :
+        proto = "UDP"
+    host, port = sys.argv[1:]
+    port = int(port)
+except :
+    print >>sys.stderr, "Usage: snkc [--tcp] HOST PORT"
+    sys.exit(1)
+
+sock = None
+
+def sendto (data, address) :
+    global sock
+    if proto == "UDP" :
+        if sock is None :
+            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            sock.settimeout(2)
+        sock.sendto(data, address)
+    else :
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(2)
+        sock.connect(address)
+        sock.send(data)
+
+def recvfrom (size) :
+    global sock
+    if proto == "UDP" :
+        data, address = sock.recvfrom(size)
+    else :
+        parts = []
+        while True :
+            parts.append(sock.recv(size))
+            if len(parts[-1]) < size :
+                break
+        address = sock.getpeername()
+        sock.close()
+        data = "".join(parts)
+    return data, address
+
+while True :
+    try :
+        data = raw_input("? ")
+        q = eval(data.strip(), env)
+    except (EOFError, KeyboardInterrupt) :
+        quit()
+    except SystemExit :
+        raise
+    except Exception, e :
+        print "query error:", e
+        continue
+    if q is not None :
+        q = dumps(q)
+        if _verbose :
+            print "# query to %s:%u" % (host, port)
+            print q
+        sendto(q, (host, port))
+        try :
+            data, address = recvfrom(2**20)
+            if _verbose :
+                print "# answer from %s:%u" % address
+            print data.strip()
+        except socket.timeout :
+            print "# no answer received (timeout)"
+    print

+#!/usr/bin/env python
+import sys
+import snakes.plugins
+snakes.plugins.load("query", "snakes.nets", "nets")
+
+port = 1234
+size = 2**20
+verbose = 0
+proto = "UDP"
+
+def help () :
+    print "Usage: snkd [OPTION]"
+    print "Options:"
+    print "  -p PORT, --port PORT    listen on port number PORT"
+    print "  -t, --tcp               use TCP instead of UDP"
+    print "  -s SIZE, --size SIZE    set buffer size for inputs"
+    print "  -v, --verbose           display information about queries"
+    print "                          (use '-v' twice to dump queries/answers)"
+    print "  -h, --help              print this help and exit"
+
+args = sys.argv[1:]
+try :
+    while len(args) > 0 :
+        arg = args.pop(0)
+        if arg in ("-p", "--port") :
+            port = int(args.pop(0))
+        elif arg in ("-v", "--verbose") :
+            verbose += 1
+        elif arg in ("-t", "--tcp") :
+            proto = "TCP"
+        elif arg in ("-s", "--size") :
+            size = int(args.pop(0))
+        elif arg in ("-h", "--help") :
+            help()
+            sys.exit(0)
+        else :
+            print >>sys.stderr("snkd: invalid command %r" % arg)
+            sys.exit(1)
+except SystemExit :
+    raise
+except :
+    cls, val, tb = sys.exc_info()
+    print >>sys.stderr, "snkd: %s, %s" % (cls.__name__, val)
+    sys.exit(1)
+
+if verbose :
+    print "# starting"
+    print "# listen on: %s:%u" % (proto, port)
+    print "# buffer size: %uMb" % (size/1024)
+    print "# verbosity:", verbose
+
+try :
+    if proto == "UDP" :
+        nets.UDPServer(port, size=size, verbose=verbose).run()
+    else :
+        nets.TCPServer(port, size=size, verbose=verbose).run()
+except KeyboardInterrupt :
+    print "# bye"
+except :
+    cls, val, tb = sys.exc_info()
+    if verbose > 1 :
+        raise
+    elif verbose :
+        print "# fatal error"
+    print >>sys.stderr, "snkd: %s, %s" % (cls.__name__, val)
+    sys.exit(2)

+lucid     10.04 LTS
+hardy     8.04  LTS
+oneiric   11.10
+precise   12.04 LTS

+5

+1

+python-snakes (0.9.16-1) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Tue, 07 Jun 2011 12:23:33 +0200
+
+python-snakes (0.9.15-1) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Tue, 10 May 2011 18:22:34 +0200
+
+python-snakes (0.9.14-1) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Mon, 11 Apr 2011 16:45:50 +0200
+
+python-snakes (0.9.13-2) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Fri, 23 Jul 2010 20:06:53 +0200
+
+python-snakes (0.9.13-1) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Fri, 16 Jul 2010 17:09:14 +0200
+
+python-snakes (0.9.12-2) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Sat, 03 Apr 2010 21:06:50 +0200
+
+python-snakes (0.9.12-1) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Thu, 01 Apr 2010 19:46:02 +0200
+
+python-snakes (0.9.11-1) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Thu, 25 Mar 2010 19:39:47 +0100
+
+python-snakes (0.9.10-1) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Fri, 19 Jun 2009 13:40:36 +0200
+
+python-snakes (0.9.9-2) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Tue, 19 May 2009 09:29:46 +0200
+
+python-snakes (0.9.8-2) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Tue, 14 Apr 2009 20:02:32 +0200
+
+python-snakes (0.9.8-1) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Mon, 23 Mar 2009 17:34:06 +0100
+
+python-snakes (0.9.7-1) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Tue, 20 Jan 2009 13:07:09 +0100
+
+python-snakes (0.9.6-2) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Tue, 02 Dec 2008 17:47:43 +0100
+
+python-snakes (0.9.6-1) UNRELEASED; urgency=low
+
+  * see NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Fri, 28 Nov 2008 15:24:05 +0100
+
+python-snakes (0.9.5-2) UNRELEASED; urgency=low
+
+  * Fixed doc installation path
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Fri, 21 Nov 2008 13:20:55 +0100
+
+python-snakes (0.9.5-1) UNRELEASED; urgency=low
+
+  * Trying to fix build on Launchpad
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Fri, 21 Nov 2008 08:19:04 +0100
+
+python-snakes (0.9.5) UNRELEASED; urgency=low
+
+  * See NEWS
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Wed, 19 Nov 2008 21:47:52 +0100
+
+python-snakes (0.9.4) UNRELEASED; urgency=low
+
+  * Initial release. (Closes: #XXXXXX)
+
+ -- Franck Pommereau <pommereau@univ-paris12.fr>  Tue, 18 Nov 2008 12:09:16 +0100

+6

+Source: python-snakes
+Section: python
+Priority: extra
+Maintainer: Franck Pommereau <pommereau@univ-paris12.fr> 
+Homepage: http://lacl.univ-paris12.fr/pommereau/soft/snakes
+Build-Depends: python (>=2.5), cdbs (>=0.4.49), debhelper (>= 5), python-central (>=0.5.6)
+XS-Python-Version: >=2.5
+Standards-Version: 3.7.2
+
+Package: python-snakes
+Architecture: all
+XB-Python-Version: ${python:Versions}
+Depends: python (>=2.5), python-central, graphviz, python-tk
+Description: SNAKES is the Net Algebra Kit for Editors and Simulators
+ SNAKES is a general purpose Petri net Python library allowing to
+ define and execute most classes of Petri nets. It features a plugin
+ system to allow its extension. In particular, plugins are provided to
+ implement the operations usually found in the PBC and M-nets family.

+This package was debianized by Franck Pommereau <pommereau@univ-paris12.fr> on
+DATE
+
+License:
+
+   This package is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public License
+   as published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   This package is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this package; if not, see
+   `http://www.gnu.org/licenses/lgpl-3.0.txt'.
+
+On Debian systems, the complete text of the GNU General
+Public License can be found in `/usr/share/common-licenses/LGPL'.
+
+The Debian packaging is (C) 2008, Franck Pommereau
+<pommereau@univ-paris12.fr> and is licensed under the LGPL, see above.

+#!/usr/bin/make -f
+
+DEB_PYTHON_SYSTEM=pycentral
+
+include /usr/share/cdbs/1/rules/debhelper.mk
+include /usr/share/cdbs/1/class/python-distutils.mk

+		   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

+all:
+	rm -rf api
+	epydoc --output api --no-frames --graph=all \
+	  --name="SNAKES is the Net Algebra Kit for Editors and Simulators" \
+	  --navlink='<img alt="SNAKES logo" src="snakes-logo.jpg" width="120" height="120"/>' \
+          --no-private ../snakes
+	convert ../logo/snakes-logo.png -background white -scale 120x120 ./api/snakes-logo.jpg

+ABCD specification language
+===========================
+
+This document presents the ABCD language and compiler that is provided
+with SNAKES.
+
+WARNING: this documentation needs update since ABCD syntax has changed
+a bit. A precise (but not user-friendly) syntax can be found in the
+source:
+
+ - snakes/lang/abcd/abcd.pgen is the concrete grammar and
+
+ - snakes/lang/abcd/abcd.asdl is the abstract syntax
+
+
+Introduction
+------------
+
+ABCD (Asynchronous Box Calculus with Data) is a specification language
+whose semantics is given in terms of coloured Petri net. The formal
+semantics will not be defined here, but only an intuition of it. ABCD
+can be seen as both an Python based implementation and a variant of
+several algebras of Petri nets:
+
+ - with respect to the versatile box calculus
+   (http://lacl.univ-paris12.fr/pommereau/publis/2007-dasd.html), ABCD
+   does not provide tasks and abort mechanism, but it allows nested
+   parallelism;
+
+ - with respect to the box calculus with coloured buffers or the box
+   calculus with high-level buffers
+   (http://lacl.univ-paris12.fr/pommereau/publis/2002-bcd.html and
+   http://lacl.univ-paris12.fr/pommereau/publis/2004-dads.html), ABCD
+   does not provide synchronous communication operations.
+
+
+Syntax
+------
+
+The syntax of ABCD is a mix between Python and a process algebra. An
+ABCD specification is structured as follows:
+
+   1. a possibly empty list of definitions, each being either
+      1. a Python ``def`` statement (function definition)
+      2. a Python ``import`` of ``from`` statement
+      3. an ABCD communication buffer definition
+      4. an ABCD sub-net definition (similar to a sub-program)
+   2. an ABCD process (similar to the ``main`` function of a C program)
+
+Like in Python, block and sub-blocks are defined through indentation,
+and comments begin with ``#`` and end with the line. Unlike Python,
+scoping is lexical, with name masking as usual.
+
+
+Python definitions
+^^^^^^^^^^^^^^^^^^
+
+Functions definitions and module imports are exactly as in Python.
+Classes definition is not allowed, to do so, one must create a
+separate Python module and import its content.
+
+The following is an example of valid ABCD definitions:
+
+    from foo import *
+    from bar import spam
+    import math
+
+    def sqrt (x) :
+        return int(math.sqrt(x))
+
+
+Buffers definitions
+^^^^^^^^^^^^^^^^^^^
+
+An ABCD buffer is implemented in the Petri nets semantics as a
+coloured place, so a buffer is:
+
+typed
+   values that can be inserted in the buffer must belong to a given
+   type; using ``object`` allows to put anything in the buffer.
+
+unbounded
+   there is no a priori limit to the number of values that can be
+   inserted in a buffer, not even to the number of copies of a given
+   value within a buffer.
+
+unordered
+   the order in which values are retrieved from a buffer is non
+   deterministic and is absolutely not related to the order of
+   insertion.
+
+In order to contain the combinatorial explosion during the analysis of
+the Petri net resulting from an ABCD specification, it is recommended
+to take these aspects into account. In particular, it could be good
+to:
+
+ - define buffer types as small as possible, allowing just the
+   expected values and no more;
+
+ - implement some policy in order to limit the number of values
+   simultaneously stored in a buffer. Anyway, if the buffer is
+   unbounded, it is likely that the resulting Petri net cannot be
+   analysed;
+
+ - implement a FIFO policy whenever possible, for instance by storing
+   numbered pairs ``(num, obj)`` instead of just ``obj`` and by
+   maintaining a counter for the next value to insert and the next to
+   get.
+
+In order to declare a buffer, one has to write:
+
+    buffer NAME : TYPE = INIT
+
+where ``NAME`` is the name of the buffer (a Python identifier),
+``TYPE`` is its type (a Python type name or a more complex type
+specification, see below), and ``INIT`` is the initial content of the
+buffer: ``()`` if empty, or a comma separated list of values.
+
+For instance, an empty buffer of integers and a buffer of strings with
+two values can be declared as:
+
+    buffer count : int = ()
+    buffer messages : str = 'hello', 'world'
+
+Buffer types can be:
+
+Python classes
+    for instance ``int``, ``str``, ``float``, ``bool``, ``object``,
+    etc., including user defined classes.
+
+Enumerated types
+    for instance ``enum(1, 3, 'foo', True)`` allows all the value listed
+    between the parenthesis but no other value.
+
+Union types
+    for instance, ``int|float`` allows for integer as well as floating
+    point numbers. Intersection types, using operator ``&``, are also
+    allowed even if it hard to find a real usage for them.
+
+Sets of typed values
+    for instance, ``{int|float}`` defines sets of numbers (integers or
+    floating point).
+
+Lists of typed values
+    for instance, ``[str]`` defines lists of strings.
+
+Dictionary types
+    for instance, ``str:int`` specifies ``dict`` objects whose keys
+    are strings and values are integers.
+
+Cross product of types
+    for instance, ``(int, str)`` specifies tuples of length two whose
+    first item is an integer and second item is a string. Tuples of
+    length one *must* use a trailing comma; for instance, ``(int,)``
+    stands for integer singletons, but ``(int)`` is equivalent to just
+    ``int`` as usual in Python.
+
+Parentheses are allowed in order to combine complex types together, as
+in ``(int|float):(str|NoneType)``.
+
+
+Sub-nets definitions
+^^^^^^^^^^^^^^^^^^^^
+
+A sub-net is declared as follows:
+
+    net NAME (PARAMS) :
+        BLOCK
+
+where ``NAME`` is the name of the sub-net (a Python identifier),
+``PARAMS`` is a list of parameters (as in Python with default values
+allowed but not ``*`` or ``**`` arguments) and BLOCK is an indented
+block that follows the syntax of an ABCD specification (with optional
+definitions and a mandatory process term).
+
+Objects (Python functions or imports, and buffers) defined inside a
+sub-net are local to it and cannot be accessed from the outside. But,
+objects defined before the sub-net (unless nested in another sub-net)
+are visible from within the sub-net and can be used.
+
+
+Process terms
+^^^^^^^^^^^^^
+
+An ABCD process is defined as a term on a process algebra whose
+operators are control flow operators:
+
+sequential composition
+    the execution of ``A ; B`` starts with the execution of ``A``,
+    followed by the execution of ``B``
+
+choice composition
+    the execution of ``A + B`` is either the execution of ``A`` or
+    that of ``B``, which is chosen non-deterministically.
+
+loop composition
+
+    the execution of ``A * B`` starts by an arbitrary number of
+    executions of ``A``, followed by exactly one execution of ``B``,
+    the choice to loop or terminate is non-deterministic. So, ``A *
+    B`` is equivalent to ``B + (A ; B) + (A ; A ; B) + ...``.
+
+parallel composition
+    the execution of ``A | B`` is that of both ``A`` and ``B``
+    concurrently.
+
+Base terms of the algebra are either atomic processes or sub-net
+instantiations. An atomic process, also called an action, is described
+by a term enclosed in square brackets ``[...]``. The semantics of an
+action is a Petri net transition. We distinguish:
+
+``[True]``
+    the silent action that can always be executed and performs no
+    buffer access.
+
+``[False]``
+    the deadlock action that can never be executed.
+
+complex actions
+    such an action involve buffer accesses and an optional condition.
+    If ``expr`` denotes a Python expression, ``obj`` a Python constant
+    and ``var`` a Python identifier, buffer accesses may be:
+
+ - ``buffer+(expr)`` evaluated ``expr`` and adds the resulting value
+   to the buffer; this results in the semantics as an arc from the
+   transition to the buffer place, labeled by ``expr``.
+
+ - ``buffer-(obj)`` consumes the value ``obj`` from the buffer; this
+   results in the semantics as an arc from the buffer place to the
+   transition, labeled by ``obj``.
+
+ - ``buffer-(var)`` binds the variable ``var`` to a value present in
+   the buffer and consumes it; this results in the semantics as an arc
+   from the buffer place to the transition, labeled by ``var``.
+
+ - ``buffer?(obj)`` or ``buffer?(var)`` are similar except that they
+   just test the presence of a value but do not consume it; this is
+   semantically a read arc.
+
+ - ``buffer>>(var)`` consumes all the values in the buffer and bind
+   the resulting multiset to the variable ``var``; this is
+   semantically a flush arc.
+
+ - ``buffer<<(expr)`` evaluates the expression ``expr`` (the result
+   must be iterable) and adds all its values to the buffer; this is
+   semantically a fill arc.
+
+For instance:
+
+    [count-(x), count+(x+1), shift?(j), buf+(j+x) if x<10]
+
+This action can be execution if the following hold:
+
+ - buffer ``count`` must hold a value that it is bound to ``x``
+
+ - buffer ``shift`` mush hold a value that is bound to ``j``
+
+ - the type of buffer ``count`` must allow the value resulting from
+   the evaluation of ``x+1``
+
+ - the type of buffer ``buf`` must allow the value resulting from the
+   evaluation of ``j+x``
+
+ - expression ``x<10`` must evaluate to ``True``
+
+If all these condition hold, the action can be executed, which results in:
+
+ - the chosen value for ``x`` is removed from buffer ``count``
+
+ - a new value corresponding to the evaluation of ``x+1` is added to
+   ``count``
+
+ - a new value corresponding to the evaluation of ``j+x`` is added to
+   ``buf``
+
+This execution is atomic: it can be considered that all buffers accesses
+and conditions evaluation are performed simultaneously and
+instantaneously.
+
+If ``count`` or ``shift`` contain more than one value, only those that
+allow to fulfill the conditions listed above are considered. Among
+those valuations, one is chosen non deterministically in order to
+execute the action.
+
+Note that the variables (like ``var``) used in an action do not need
+to be declared and are local to this action. These are variables
+exactly like in mathematics. Moreover, if a variable is used more than
+once in an action, the execution gives it a single consistent value.
+For instance, ``[count-(x), shit?(x) if x != 0]`` is executable only
+if a same non-zero value can be found both in ``count`` and ``shift``.
+
+
+Example
+-------
+
+Let's consider a simple railroad crossing involving:
+
+ - one track where trains can arrive repeatedly;
+
+ - one road crossing the track;
+
+ - a pair of gates that prevent cars to go on the track when a train
+   is approaching;
+
+ - a red light that prevent the train to cross the road before the
+   gates completely close.
+
+When a train is approaching, the light is turned red and the gates are
+asked to go down. When they arrive down, the light is reset to green.
+When the train leaves the gates, they are asked to go up.
+
+This system can be specified in ABCD as follows. We first specify
+global buffers to model the red light and a communication channel
+between trains and the gates:
+
+    # light is initially 'green'
+    buffer light : in('red', 'green') = 'green'
+    # no command is available initially
+    buffer command : in('up', 'down') = ()
+
+Then we specify the behavior of the gates. We provide for it an
+internal buffer allowing to easily observe its current state.
+
+    net gate () :
+        # gates are initially 'open'
+        buffer state : in('open', 'moving', 'closed') = 'open'
+        # a sequence of actions
+        # receive the command 'down' and start moving
+        ([command-('down'), state-('open'), state+('moving')] ;
+        # finish to close and reset the light to 'green'
+         [state-('moving'), state+('closed'), light-('red'), light+('green')] ;
+	# receive the command 'up' and start moving
+         [command-('up'), state-('closed'), state+('moving')] ;
+        # finish to open
+         [state-('moving'), state+('open')])
+        # this sequence is infinitely repeated because the loop exit
+    	# cannot be executed
+        * [False]
+
+Then we specify the track on which trains can repeatedly arrive
+
+    net track () :
+        # we also need to observe trains position
+        buffer crossing : bool = False
+        # here also an sequence is infinitely repeated
+        # a train is approaching so the light is turned red and the
+	# gates are asked to close
+        ([command+('down'), light-('green'), light+('red')] ;
+        # the train must wait for green light before to go further and
+	# cross the road
+         [light?('green'), crossing-(False), crossing+(True)] ;
+        # when the train leaves, gates are asked to open
+         [crossing-(True), crossing+(False), command+('up')])
+        * [False]
+
+The full system is specified by running in parallel one instance of
+the gates and one of the track.
+
+    gate() | track()
+
+The Petri net from this specification can be drawn and saved to PNML
+by invoking:
+
+    abcd --pnml railroad.pnml --dot railroad.png railroad.abcd
+
+This creates both ``railroad.png`` and ``railroad.pnml``, the former
+can be viewed in order to check how is the Petri net semantics, and
+the latter can be used to verify the system. On such a small system,
+SNAKES performs quickly enough for the verification. So we can use it
+to iterate the marking graph and search for an insecure state, ie, in
+which gates are open and train. The following program does the job:
+
+    from snakes.nets import *
+
+    n = loads(",railroad.pnml")
+    g = StateGraph(n)
+    for s in g :
+        m = g.net.get_marking()
+        if ("train().crossing" in m
+            and True in m["train().crossing"]
+            and "closed" not in m["gate().state"]) :
+            print s, m
+    print "checked", len(g), "states"
+
+Here, no insecure marking is found. This would not be the case if we
+would remove the red light since a train could always arrive on the
+road faster than the gate could close.

+prod-cons.abcd
+    a simple producer/consumer
+
+railroad.abcd
+    a (not so) simple railroad crossing system
+railroad.py
+    checks basic property of railroad.abcd
+
+ns/ns.abcd
+    Needham-Schroeder public key authentication protocol
+ns/ns.py
+    checks mutual authentication

+class Nonce (object) :
+    def __init__ (self, agent) :
+        self._agent = agent
+    def __eq__ (self, other) :
+        try :
+            return self._agent == other._agent
+        except :
+            return False
+    def __ne__ (self, other) :
+        return not self.__eq__(other)
+    def __str__ (self) :
+        return self.__repr__()
+    def __repr__ (self) :
+        return "Nonce(%x)" % self._agent
+
+def _cross (sets) :
+    if len(sets) == 0 :
+        pass
+    elif len(sets) == 1 :
+        for item in sets[0] :
+            yield (item,)
+    else :
+        for item in sets[0] :
+            for others in _cross(sets[1:]) :
+                yield (item,) + others
+
+
+class Spy (object) :
+    keywords = set(["crypt", "pub", "priv", "secret", "hash"])
+    def __init__ (self, *types) :
+        """
+        >>> s = Spy(str, int, (str, int, (float, object)))
+        >>> s
+        <Spy>
+        >>> s._subtypes == set([str, int, float, object,
+        ...                     (float, object),
+        ...                     (str, int, (float, object))])
+        True
+        """
+        self._types = set(types)
+        self._subtypes = set()
+        todo = set(self._types)
+        while len(todo) > 0 :
+            t = todo.pop()
+            self._subtypes.add(t)
+            if isinstance(t, tuple) :
+                todo.update(t)
+    def __str__ (self) :
+        """
+        >>> str(Spy(str, int))
+        '<Spy>'
+        """
+        return "<%s>" % self.__class__.__name__
+    def __repr__ (self) :
+        """
+        >>> str(Spy(str, int))
+        '<Spy>'
+        """
+        return self.__str__()
+    def __eq__ (self, other) :
+        """
+        >>> Spy(str, int) == Spy(int, str)
+        True
+        >>> Spy(str, int) == Spy(int, str, float)
+        False
+        """
+        return self._types == other._types
+    def __ne__ (self, other) :
+        """
+        >>> Spy(str, int) != Spy(int, str, float)
+        True
+        >>> Spy(str, int) != Spy(int, str)
+        False
+        """
+        return not self.__eq__(other)
+    def __hash__ (self) :
+        """
+        >>> hash(Spy(str, int)) == hash(Spy(int, str))
+        True
+        >>> hash(Spy(str, int)) == hash(Spy(int, str, float))
+        False
+        """
+        return hash(tuple(sorted(self._types)))
+    @classmethod
+    def get_type (cls, obj) :
+        """
+        >>> Spy().get_type(('hello', ('foo', 4), 5))
+        (<type 'str'>, (<type 'str'>, <type 'int'>), <type 'int'>)
+        """
+        t = type(obj)
+        if t is tuple :
+            if len(obj) > 0 and obj[0] in cls.keywords :
+                return (obj[0],) + tuple(cls.get_type(o) for o in obj[1:])
+            else :
+                return tuple(cls.get_type(o) for o in obj)
+        else :
+            return t
+    @classmethod
+    def match (cls, obj, pattern) :
+        """
+        >>> Spy.match(('hello', 42, (1, 2, 3.4)), (str, int, (1, 2, float)))
+        True
+        >>> Spy.match(('hello', 42, (1, 2, 3.4)), ('hello', int, (1, 2, float)))
+        True
+        >>> Spy.match(('hello', 42, (1, 2, 3)), (str, int, (1, 2, float)))
+        False
+        >>> Spy.match(('hello', 42, (1, 2, 3, 4)), (str, int, (1, 2, float)))
+        False
+        >>> Spy.match(('hello', 42, (1, 2, 3.4)), ('foo', int, (1, 2, float)))
+        False
+        """
+        if type(obj) == tuple == type(pattern) :
+            if len(obj) != len(pattern) :
+                return False
+            for o, p in zip(obj, pattern) :
+                if not cls.match(o, p) :
+                    return False
+            return True
+        elif type(pattern) is type :
+            return isinstance(obj, pattern)
+        else :
+            return obj == pattern
+    def message (self, obj) :
+        """
+        >>> Spy(str, int).message('hello')
+        True
+        >>> Spy(str, int).message(42)
+        True
+        >>> Spy(str, int).message((1, 2))
+        False
+        >>> Spy(str, int).message(3.14)
+        False
+        """
+        return self.get_type(obj) in self._types
+    def fragment (self, obj) :
+        """
+        >>> s = Spy(str, int, (str, int, (float, list)))
+        >>> s.fragment('hello')
+        True
+        >>> s.fragment(3.14)
+        True
+        >>> s.fragment((3.14, []))
+        True
+        >>> s.fragment(('hello', 1, (3.14, [])))
+        True
+        >>> s.fragment((1, 2))
+        False
+        >>> s.fragment({})
+        False
+        """
+        return self.get_type(obj) in self._subtypes
+    def can_decrypt (self, message, knowledge) :
+        try :
+            if message[0] != "crypt" :
+                return False
+            key = message[1]
+            if key[0] == "pub" :
+                return ("priv", key[1]) in knowledge
+            elif key[0] == "priv" :
+                return ("pub", key[1]) in knowledge
+            elif key[0] == "secret" :
+                return key in knowledge
+        except :
+            pass
+        return False
+    def can_decompose (self, message) :
+        try :
+            if not isinstance(message, tuple) :
+                return False
+            elif message[0] not in self.keywords :
+                return True
+        except :
+            pass
+        return False
+    def learn (self, msg, knowledge) :
+        """
+        >>> s = Spy((int, int, str), (int, int, (str, str)))
+        >>> k = set()
+        >>> k = s.learn((1, 2, 'hello'), k)
+        >>> for m in sorted(k) :
+        ...     print m
+        1
+        2
+        hello
+        (1, 1, 'hello')
+        (1, 1, ('hash', 'hello'))
+        (1, 1, ('hello', 'hello'))
+        (1, 2, 'hello')
+        (1, 2, ('hash', 'hello'))
+        (1, 2, ('hello', 'hello'))
+        (2, 1, 'hello')
+        (2, 1, ('hash', 'hello'))
+        (2, 1, ('hello', 'hello'))
+        (2, 2, 'hello')
+        (2, 2, ('hash', 'hello'))
+        (2, 2, ('hello', 'hello'))
+        ('hash', 'hello')
+        ('hello', 'hello')
+        >>> k = s.learn((2, 3, ('hello', 'world')), k)
+        >>> for m in sorted(k) :
+        ...     print m
+        1
+        2
+        3
+        hello
+        world
+        (1, 1, 'hello')
+        (1, 1, 'world')
+        (1, 1, ('hash', 'hello'))
+        (1, 1, ('hash', 'world'))
+        (1, 1, ('hello', 'hello'))
+        (1, 1, ('hello', 'world'))
+        (1, 1, ('world', 'hello'))
+        (1, 1, ('world', 'world'))
+        (1, 2, 'hello')
+        (1, 2, 'world')
+        (1, 2, ('hash', 'hello'))
+        (1, 2, ('hash', 'world'))
+        (1, 2, ('hello', 'hello'))
+        (1, 2, ('hello', 'world'))
+        (1, 2, ('world', 'hello'))
+        (1, 2, ('world', 'world'))
+        (1, 3, 'hello')
+        (1, 3, 'world')
+        (1, 3, ('hash', 'hello'))
+        (1, 3, ('hash', 'world'))
+        (1, 3, ('hello', 'hello'))
+        (1, 3, ('hello', 'world'))
+        (1, 3, ('world', 'hello'))
+        (1, 3, ('world', 'world'))
+        (2, 1, 'hello')
+        (2, 1, 'world')
+        (2, 1, ('hash', 'hello'))
+        (2, 1, ('hash', 'world'))
+        (2, 1, ('hello', 'hello'))
+        (2, 1, ('hello', 'world'))
+        (2, 1, ('world', 'hello'))
+        (2, 1, ('world', 'world'))
+        (2, 2, 'hello')
+        (2, 2, 'world')
+        (2, 2, ('hash', 'hello'))
+        (2, 2, ('hash', 'world'))
+        (2, 2, ('hello', 'hello'))
+        (2, 2, ('hello', 'world'))
+        (2, 2, ('world', 'hello'))
+        (2, 2, ('world', 'world'))
+        (2, 3, 'hello')
+        (2, 3, 'world')
+        (2, 3, ('hash', 'hello'))
+        (2, 3, ('hash', 'world'))
+        (2, 3, ('hello', 'hello'))
+        (2, 3, ('hello', 'world'))
+        (2, 3, ('world', 'hello'))
+        (2, 3, ('world', 'world'))
+        (3, 1, 'hello')
+        (3, 1, 'world')
+        (3, 1, ('hash', 'hello'))
+        (3, 1, ('hash', 'world'))
+        (3, 1, ('hello', 'hello'))
+        (3, 1, ('hello', 'world'))
+        (3, 1, ('world', 'hello'))
+        (3, 1, ('world', 'world'))
+        (3, 2, 'hello')
+        (3, 2, 'world')
+        (3, 2, ('hash', 'hello'))
+        (3, 2, ('hash', 'world'))
+        (3, 2, ('hello', 'hello'))
+        (3, 2, ('hello', 'world'))
+        (3, 2, ('world', 'hello'))
+        (3, 2, ('world', 'world'))
+        (3, 3, 'hello')
+        (3, 3, 'world')
+        (3, 3, ('hash', 'hello'))
+        (3, 3, ('hash', 'world'))
+        (3, 3, ('hello', 'hello'))
+        (3, 3, ('hello', 'world'))
+        (3, 3, ('world', 'hello'))
+        (3, 3, ('world', 'world'))
+        ('hash', 'hello')
+        ('hash', 'world')
+        ('hello', 'hello')
+        ('hello', 'world')
+        ('world', 'hello')
+        ('world', 'world')
+
+        >>> s = Spy(('crypt', ('pub', int), str))
+        >>> pub, priv = ('pub', 1), ('priv', 1)
+        >>> k = set([pub])
+        >>> k = s.learn(('crypt', priv, 'hello'), k)
+        >>> 'hello' in k
+        True
+        >>> k = s.learn(('crypt', pub, 'secret message'), k)
+        >>> 'secret message' in k
+        False
+        >>> k.add(priv)
+        >>> k = s.learn(('crypt', pub, 'secret message'), k)
+        >>> 'secret message' in k
+        True
+        """
+        k = set(knowledge)
+        # learn from new message
+        # add new message to knowledge
+        k.add(msg)
+        # hash new message if useful
+        h = ("hash", msg)
+        if self.fragment(h) :
+            k.add(h)
+        # try to decrypt new message
+        if self.can_decrypt(msg, k) :
+            for m in msg[2:] :
+                if m not in k :
+                    k.update(self.learn(m, k))
+        # try to decompose new message
+        elif self.can_decompose(msg) :
+            for m in msg :
+                if m not in k :
+                    k.update(self.learn(m, k))
+        self._learn_(msg, k)
+        # compose new messages from fragments
+        for sub in (s for s in sorted(self._subtypes, key=self._size)
+                    if type(s) is tuple) :
+            sets = []
+            for t in sub :
+                sets.append([x for x in k|self.keywords if self.match(x, t)])
+            k.update(_cross(sets))
+        return k
+    @classmethod
+    def _size (cls, obj) :
+        if isinstance(obj, tuple) :
+            return (len(obj),) + tuple(cls._size(o) for o in obj)
+        else :
+            return 1
+    def _learn_ (self, m, k) :
+        for attr in (a for a in dir(self) if a.startswith("learn_")) :
+            getattr(self, attr)(m, k)
+
+class SpyKS (Spy) :
+    def can_decrypt (self, message, knowledge) :
+        try :
+            if message[1][0] == "priv" :
+                knowledge.add(("pub", message[1][1]))
+        except :
+            pass
+        return Spy.can_decrypt(self, message, knowledge)
+
+if __name__ == "__main__" :
+    import doctest
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

+# communication network
+buffer nw : object = ()
+# implementation of nonces and Dolev-Yao attacker
+from dolev_yao import *
+
+net Alice (this, who: buffer) :
+    # protocol initiater
+    buffer peer : int = ()
+    buffer peer_nonce : Nonce = ()
+    [who?(B), peer+(B), nw+("crypt", ("pub", B), this, Nonce(this))]
+    ; [nw-("crypt", ("pub", this), Na, Nb), peer_nonce+(Nb) if Na == Nonce(this)]
+    ; [peer?(B), peer_nonce?(Nb), nw+("crypt", ("pub", B), Nb)]
+
+net Bob (this) :
+    # protocol responder
+    buffer peer : int = ()
+    buffer peer_nonce : Nonce = ()
+    [nw-("crypt", ("pub", this), A,  Na), peer+(A), peer_nonce+(Na)]
+    ; [peer?(A), peer_nonce?(Na), nw+("crypt", ("pub", A),  Na, Nonce(this))]
+    ; [nw-("crypt", ("pub", this), Nb) if Nb == Nonce(this)]
+
+net Mallory (this, init) :
+    # attacker
+    buffer knowledge : object = (this, Nonce(this), ("priv", this)) + init
+    # Dolev-Yao attacker, bound by protocol signature
+    buffer spy : object = Spy(("crypt", ("pub", int), int, Nonce),
+                               ("crypt", ("pub", int), Nonce, Nonce),
+                               ("crypt", ("pub", int), Nonce))
+    # capture on message and learn from it
+    ([spy?(s), nw-(m), knowledge>>(k), knowledge<<(s.learn(m, k))]
+     # loose message or inject another one (may be the same)
+     ; ([True] + [spy?(s), knowledge?(x), nw+(x) if s.message(x)]))
+    * [False]
+
+# Alice will contact one of these agents
+buffer agents : int = 2, 3
+# main processes, with friendly names
+alice::Alice(1, agents)
+| bob::Bob(2)
+| spy::Mallory(3, (1, ("pub", 1), 2, ("pub", 2)))

+import snakes.plugins
+snakes.plugins.load("status", "snakes.nets", "nets")
+from nets import *
+from dolev_yao import Nonce
+
+ns = loads(",ns.pnml")
+states = StateGraph(ns)
+
+for s in states :
+    m = states.net.get_marking()
+    # skip non final markings
+    if "bob.x" not in m or "alice.x" not in m :
+        continue
+    # get Alice's and Bob's peers ids
+    bp = list(m["bob.peer"])[0]
+    ap = list(m["alice.peer"])[0]
+    # violation of mutual authentication
+    if bp == 1 and ap != 2 :
+        print(s, "A(1) <=> %s ; B(2) <=> %s" % (ap, bp))
+        print(m)
+
+print(len(states), "states")

+# get BlackToken
+#from snakes.nets import *
+
+buffer fork1 : BlackToken = dot
+buffer fork2 : BlackToken = dot
+buffer fork3 : BlackToken = dot
+
+# buffer parameters have to be declared as such
+net philo (left: buffer, right: buffer):
+    buffer eating : BlackToken = ()
+    ([left-(dot), right-(dot), eating+(dot)]
+     ; [left+(dot), right+(dot), eating-(dot)])
+    * [False]
+
+philo(fork1, fork2)
+| philo(fork2, fork3)
+| philo(fork3, fork1)

+# shared buffer between producers and consumers
+buffer bag : int = ()
+
+net prod () :
+    # produces 10 tokens: 1..9 in bag
+    buffer count : int = 0
+    [count-(x), count+(x+1), bag+(x) if x < 10] * [count-(x) if x == 10]
+
+net odd () :
+    # consumes odd tokens in bag
+    [bag-(x) if (x % 2) == 1] * [False]
+
+net even () :
+    # consumes even tokens un bag
+    [bag-(x) if (x % 2) == 0] * [False]
+
+# main process with one instance of each net
+odd() | even() | prod()

+# symbols
+symbol RED, GREEN, UP, DOWN, OPEN, MOVING, CLOSED
+# states of the gate
+typedef gatestate : enum(OPEN, MOVING, CLOSED)
+
+# stores green light state
+buffer light : enum(RED, GREEN) = GREEN
+# commands send by the track to the gate
+buffer command : enum(UP, DOWN) = ()
+
+net gate () :
+    # a pair of gates
+    buffer state : gatestate = OPEN
+    ([command-(DOWN), state-(OPEN), state+(MOVING)] ;
+     [state-(MOVING), state+(CLOSED), light-(RED), light+(GREEN)] ;
+     [command-(UP), state-(CLOSED), state+(MOVING)] ;
+     [state-(MOVING), state+(OPEN)])
+    * [False]
+
+net track () :
+    # a track with trains passing on it
+    buffer crossing : bool = False
+    ([command+(DOWN), light-(GREEN), light+(RED)] ;
+     [light?(GREEN), crossing-(False), crossing+(True)] ;
+     [crossing-(True), crossing+(False), command+(UP)])
+    * [False]
+
+# main process
+gate() | track()

+import sys
+
+import snakes.plugins
+snakes.plugins.load("gv", "snakes.nets", "snk")
+from snk import *
+
+n = loads(sys.argv[1])
+g = StateGraph(n)
+for s in g :
+    m = g.net.get_marking()
+    # safety property: train present => gates closed
+    if ("train().crossing" in m
+        and True in m["train().crossing"]
+        and "closed" not in m["gate().state"]) :
+        print("%s %s" % (s, m))
+print("checked %s states" % len(g))
+
+g.draw(sys.argv[1].rsplit(".", 1)[0] + "-states.png")

+The plugin 'queries' introduces two new classes:
+
+ - Query allows to describe and execute various kind of queries, that
+   can be serialized to PNML in order to be exchanged with another
+   program. SNAKES uses an extension of PNML, for a complete list of
+   SNAKES' PNML tags, see 'snakes-pnml.txt'.
+
+ - UDPServer is a sample server over UDP that handles a limited number
+   of simple queries. However, these queries can be nested, in the
+   client program as well as in the communication with the server, so
+   the range of possibilities is unlimited and very complex queries
+   may be constructed from those simple ones.
+
+A server program is provides in 'utils/query/snkd.py' and is general
+an robust enough to be used in real cases (but considering it only
+implements the limited set of queries exposed above). As it works in a
+disconnected mode (UDP), this server does not try to make any
+difference between possibly several clients. This may result in data
+sharing or conflicts, which makes this server more suitable to a local
+use only. Start the server with option '-h' to have details about its
+command line.
+
+A sample client is provided also, in order to allow to experiment with
+the server. (Notice that since the client is programmed in Python, it
+could use SNAKES directly, which explains why it will never be made
+more sophisticated.) It takes the form a shell-like program that
+accepts commands of the form "? command(param, ...)" where "? " is the
+prompt.
+
+First come local commands, these are commands that do not send any
+data to the server but are handled locally:
+
+ ? help()
+
+   list available commands
+
+ ? help(command)
+
+   print help about the given command
+
+ ? quit()
+
+   exits the client, end-of-file or ^C may be used equivalently
+
+ ? load(path)
+
+   loads a PNML file and return the object it represents. This is
+   useful for instance to load a Petri net on the server as in:
+   "? set('net', load('mynet.pnml'))"
+
+ ? show(obj)
+
+   prints the PNML representation of 'obj', this may be useful for
+   instance to see how a query is translated, as in:
+   "? show(set('x', [1, 2, 'hello']))"
+
+ ? verbose(mode)
+
+   turns on (mode=True), off (mode=False) or toggle (no mode given)
+   the printing of queries before they are sent to the server
+
+Then come commands that actually generate queries, there is only 4 of
+them:
+
+ ? set('name', value)
+
+   assign value to 'name', which is equivalent to the Python statement
+   "name=value". 'value' may be any Python expression. It is important
+   to notice that 'name' is assigned on the server side, in an
+   environment that initially contains Python's builtins, the content
+   of 'operator' and of 'snakes.net' modules (the later being extended
+   by all the plugins loaded before 'query').
+
+ ? get('name')
+
+   returns the value previously assigned to 'name'.
+
+ ? delete('name')
+
+   Equivalent to the Python statement "del name".
+
+ ? call(obj, ...)
+
+   equivalent to the Python statement "obj(...)". 'obj' may be a name
+   or an access to an object like 'x' or 'x.method', or even the
+   result from a nested query (see examples below).
+
+##
+## Answers
+##
+
+In case of a success with no return value, the answer is:
+
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok"/>
+</pnml>
+
+If there is a return value, it is given as a PNML sub-tree of tag
+<answer>. For instance:
+
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok">
+  <object type="str">hello world!</object>
+ </answer>
+</pnml>
+
+If an errors occurs during the handling of the query, an answer with
+status "error" is returned. The data in tag <answer> is the error
+message and the tag has an attribute 'error' that is the name of the
+caught exception. For instance:
+
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer error="ExceptionName" status="error">Exception message</answer>
+</pnml>
+
+##
+## Queries
+##
+
+Query arguments are passed as tags <argument> nested in <query>, the
+value of each argument is encoded in PNML using the tags presented in
+'snakes-pnml.txt'. The following is a copy/paste from a snkc session,
+interleaved with comments.
+
+First, we turn on the verbose mode.
+
+? verbose()
+dump of queries enabled
+
+The first query assigns to 'x' a list composed of an integer, a float
+and a string. This allows to illustrate how these types are encoded.
+
+? set('x', [1, 3.14, 'hello'])
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="set">
+  <argument>
+   <object type="str">x</object>
+  </argument>
+  <argument>
+   <object type="list">
+    <object type="int">1</object>
+    <object type="float">3.14</object>
+    <object type="str">hello</object>
+   </object>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok"/>
+</pnml>
+
+If we get 'x' back, the same encoding is used again but in the other
+direction.
+
+? get('x')
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="get">
+  <argument>
+   <object type="str">
+    x
+   </object>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok">
+  <object type="list">
+   <object type="int">1</object>
+   <object type="float">3.14</object>
+   <object type="str">hello</object>
+  </object>
+ </answer>
+</pnml>
+
+'x' can be removed, after which trying to get it again results in an
+error.
+
+? delete('x')
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="del">
+  <argument>
+   <object type="str">x</object>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok"/>
+</pnml>
+
+? get('x')
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="get">
+  <argument>
+   <object type="str">x</object>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer error="AttributeError" status="error">
+  'module' object has no attribute 'x'
+ </answer>
+</pnml>
+
+We set a new name 's' that is a string in order to illustrate method
+calls.
+
+? set('s', 'hello world!')
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="set">
+  <argument>
+   <object type="str">s</object>
+  </argument>
+  <argument>
+   <object type="str">hello world!</object>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok"/>
+</pnml>
+
+The following calls the method 'replace' of 's' passing it two string
+arguments.
+
+? call('s.replace', 'o', '_')
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="call">
+  <argument>
+   <object type="str">s.replace</object>
+  </argument>
+  <argument>
+   <object type="str">o</object>
+  </argument>
+  <argument>
+   <object type="str">_</object>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok">
+  <object type="str">hell_ w_rld!</object>
+ </answer>
+</pnml>
+
+In order to cascade calls, that is call a method of the object
+returned by the first call, we can use the function 'getattr' that
+returns a named attribute of an object. Here, we get and call the
+'split' method from the string returned by 's.replace'. This is
+exactly the same as "s.replace('o', '_').split()" in Python.
+
+? call(call('getattr', call('s.replace', 'o', '_'), 'split'))
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="call">
+  <argument>
+   <query name="call">
+    <argument>
+     <object type="str">getattr</object>
+    </argument>
+    <argument>
+     <query name="call">
+      <argument>
+       <object type="str">s.replace</object>
+      </argument>
+      <argument>
+       <object type="str">o</object>
+      </argument>
+      <argument>
+       <object type="str">_</object>
+      </argument>
+     </query>
+    </argument>
+    <argument>
+     <object type="str">split</object>
+    </argument>
+   </query>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok">
+  <object type="list">
+   <object type="str">hell_</object>
+   <object type="str">w_rld!</object>
+  </object>
+ </answer>
+</pnml>
+
+Let's now apply these techniques to work with Petri nets. First we
+load a net from PNML file. In practical cases, the command 'load' from
+snkc is not available. But it is enough to read the PNML file, extract
+its '<net>...</net>' part and paste it in the middle of the 'set'
+request.
+
+? set('n', load('simple-coloured.pnml'))
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="set">
+  <argument>
+   <object type="str">n</object>
+  </argument>
+  <argument>
+   <net id="mynet">
+    <place id="p2">
+     <type domain="universal"/>
+     <initialMarking>
+      <multiset/>
+     </initialMarking>
+    </place>
+    <place id="p1">
+     <type domain="universal"/>
+     <initialMarking>
+      <multiset>
+       <item>
+        <value>
+         <object type="int">1</object>
+        </value>
+        <multiplicity>1</multiplicity>
+       </item>
+       <item>
+        <value>
+         <object type="int">2</object>
+        </value>
+        <multiplicity>1</multiplicity>
+       </item>
+      </multiset>
+     </initialMarking>
+    </place>
+    <transition id="t"/>
+    <arc id="p1:t" source="p1" target="t">
+     <inscription>
+      <variable>x</variable>
+     </inscription>
+    </arc>
+    <arc id="t:p2" source="t" target="p2">
+     <inscription>
+      <expression>x+1</expression>
+     </inscription>
+    </arc>
+   </net>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok"/>
+</pnml>
+
+The marking of the net can then be retrieved. Only place 'p1' is
+marked by the two integer-valued tokens 1 and 2.
+
+? call('n.get_marking')
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="call">
+  <argument>
+   <object type="str">n.get_marking</object>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok">
+  <marking>
+   <place id="p1">
+    <tokens>
+     <multiset>
+      <item>
+       <value>
+        <object type="int">1</object>
+       </value>
+       <multiplicity>1</multiplicity>
+      </item>
+      <item>
+       <value>
+        <object type="int">2</object>
+       </value>
+       <multiplicity>1</multiplicity>
+      </item>
+     </multiset>
+    </tokens>
+   </place>
+  </marking>
+ </answer>
+</pnml>
+
+Using the same techniques as for emulating "s.replace().split()"
+above, we can query the modes of transition 't' in net 'n'. We get in
+return a list of two substitutions that allow to fire 't'.
+
+? call(call('getattr', call('n.transition', 't'), 'modes'))
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="call">
+  <argument>
+   <query name="call">
+    <argument>
+     <object type="str">getattr</object>
+    </argument>
+    <argument>
+     <query name="call">
+      <argument>
+       <object type="str">n.transition</object>
+      </argument>
+      <argument>
+       <object type="str">t</object>
+      </argument>
+     </query>
+    </argument>
+    <argument>
+     <object type="str">modes</object>
+    </argument>
+   </query>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok">
+  <object type="list">
+   <substitution>
+    <item>
+     <name>x</name>
+     <value>
+      <object type="int">1</object>
+     </value>
+    </item>
+   </substitution>
+   <substitution>
+    <item>
+     <name>x</name>
+     <value>
+      <object type="int">2</object>
+     </value>
+    </item>
+   </substitution>
+  </object>
+ </answer>
+</pnml>
+
+Instead of getting this list of modes, we could have saved it to a
+name 's'. We just need to nest the above query in a 'set' query.
+
+? set('s', call(call('getattr', call('n.transition', 't'), 'modes')))
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="set">
+  <argument>
+   <object type="str">s</object>
+  </argument>
+  <argument>
+   <query name="call">
+    <argument>
+     <query name="call">
+      <argument>
+       <object type="str">getattr</object>
+      </argument>
+      <argument>
+       <query name="call">
+        <argument>
+         <object type="str">n.transition</object>
+        </argument>
+        <argument>
+         <object type="str">t</object>
+        </argument>
+       </query>
+      </argument>
+      <argument>
+       <object type="str">modes</object>
+      </argument>
+     </query>
+    </argument>
+   </query>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok"/>
+</pnml>
+
+In order to fire 't', we will call its method 'fire' and pass it one
+of the modes stored in 's'. Here, we use function 'getitem' to
+retrieve the first item in 's' (numbered 0). In a realistic example,
+it could be simpler to parse and store on the client the list of
+substitutions, instead of storing it on the server.
+
+? call(call('getattr', call('n.transition', 't'), 'fire'), call('getitem', get('s'), 0))
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="call">
+  <argument>
+   <query name="call">
+    <argument>
+     <object type="str">getattr</object>
+    </argument>
+    <argument>
+     <query name="call">
+      <argument>
+       <object type="str">n.transition</object>
+      </argument>
+      <argument>
+       <object type="str">t</object>
+      </argument>
+     </query>
+    </argument>
+    <argument>
+     <object type="str">fire</object>
+    </argument>
+   </query>
+  </argument>
+  <argument>
+   <query name="call">
+    <argument>
+     <object type="str">getitem</object>
+    </argument>
+    <argument>
+     <query name="get">
+      <argument>
+       <object type="str">s</object>
+      </argument>
+     </query>
+    </argument>
+    <argument>
+     <object type="int">0</object>
+    </argument>
+   </query>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok"/>
+</pnml>
+
+As we can see now, both places are marked.
+
+? call('n.get_marking')
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="call">
+  <argument>
+   <object type="str">n.get_marking</object>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok">
+  <marking>
+   <place id="p2">
+    <tokens>
+     <multiset>
+      <item>
+       <value>
+        <object type="int">2</object>
+       </value>
+       <multiplicity>1</multiplicity>
+      </item>
+     </multiset>
+    </tokens>
+   </place>
+   <place id="p1">
+    <tokens>
+     <multiset>
+      <item>
+       <value>
+        <object type="int">2</object>
+       </value>
+       <multiplicity>1</multiplicity>
+      </item>
+     </multiset>
+    </tokens>
+   </place>
+  </marking>
+ </answer>
+</pnml>
+
+Then we can call again 'fire', with the second available mode.
+
+? call(call('getattr', call('n.transition', 't'), 'fire'), call('getitem', get('s'), 1))
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="call">
+  <argument>
+   <query name="call">
+    <argument>
+     <object type="str">getattr</object>
+    </argument>
+    <argument>
+     <query name="call">
+      <argument>
+       <object type="str">n.transition</object>
+      </argument>
+      <argument>
+       <object type="str">t</object>
+      </argument>
+     </query>
+    </argument>
+    <argument>
+     <object type="str">fire</object>
+    </argument>
+   </query>
+  </argument>
+  <argument>
+   <query name="call">
+    <argument>
+     <object type="str">getitem</object>
+    </argument>
+    <argument>
+     <query name="get">
+      <argument>
+       <object type="str">s</object>
+      </argument>
+     </query>
+    </argument>
+    <argument>
+     <object type="int">1</object>
+    </argument>
+   </query>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok"/>
+</pnml>
+
+And now only 'p2' is marked.
+
+? call('n.get_marking')
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="call">
+  <argument>
+   <object type="str">n.get_marking</object>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok">
+  <marking>
+   <place id="p2">
+    <tokens>
+     <multiset>
+      <item>
+       <value>
+        <object type="int">2</object>
+       </value>
+       <multiplicity>1</multiplicity>
+      </item>
+      <item>
+       <value>
+        <object type="int">3</object>
+       </value>
+       <multiplicity>1</multiplicity>
+      </item>
+     </multiset>
+    </tokens>
+   </place>
+  </marking>
+ </answer>
+</pnml>
+
+Querying the modes of 't' now results in an empty list because there
+is no more tokens in the input place of 't'.
+
+? call(call('getattr', call('n.transition', 't'), 'modes'))
+# query to localhost:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="call">
+  <argument>
+   <query name="call">
+    <argument>
+     <object type="str">getattr</object>
+    </argument>
+    <argument>
+     <query name="call">
+      <argument>
+       <object type="str">n.transition</object>
+      </argument>
+      <argument>
+       <object type="str">t</object>
+      </argument>
+     </query>
+    </argument>
+    <argument>
+     <object type="str">modes</object>
+    </argument>
+   </query>
+  </argument>
+ </query>
+</pnml>
+# answer from 127.0.0.1:1234
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <answer status="ok">
+  <object type="list"/>
+ </answer>
+</pnml>
+
+These examples are intended to illustrate what _can_ be made, but not
+necessarily what _should_ be made. Here, we use snkc at the client
+side, so we have no way to store locally information, nor to parse the
+PNML we get from the server. So, when we need to record some data, we
+put it at the server side using a 'set' query. Doing so, we will need
+to use quite complicated queries in order to extract the bits of data
+that we will want to use. See for instance how complicated was the
+firing of a transition.
+
+In a realistic client, it is possible to store an manage locally some
+information and so avoid complex queries. It is even possible to
+completely parse and interpret PNML data received from the server.
+Both extremities have pros and cons:
+
+ - Storing everything on the server simplifies processing for the
+   client; but it increases (a lot) the complexity of queries.
+
+ - Storing everything on the client requires to parse and interpret
+   PNML data, and to manage stored information; but it simplifies
+   queries and may give more control on the amount of exchanged.
+
+Any intermediary position may be adopted: it is possible for a client
+to partially interpret PNML and to store fragments of uninterpreted
+PNML text as symbolic values. These fragments can then be inserted
+into queries where they are required.
+
+For instance, a client could parse the list of modes of a transition
+up to the tag <substitution>, which is quite a simple task. Each mode
+could then be saved locally as a fragment of PNML text
+"<substitution>...</substitution>". Then, firing a transition would
+simply require to insert such a fragment at the right position in a
+template query. For instance, let's run:
+
+? show(call(call('getattr', call('n.transition', 't'), 'fire'), 'SUBST'))
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="call">
+  <argument>
+   <query name="call">
+    <argument>
+     <object type="str">getattr</object>
+    </argument>
+    <argument>
+     <query name="call">
+      <argument>
+       <object type="str">n.transition</object>
+      </argument>
+      <argument>
+       <object type="str">t</object>
+      </argument>
+     </query>
+    </argument>
+    <argument>
+     <object type="str">fire</object>
+    </argument>
+   </query>
+  </argument>
+  <argument>
+   <object type="str">SUBST</object>
+  </argument>
+ </query>
+</pnml>
+
+Then, we just need to replace '<object type="str">SUBST</object>' with
+the saved fragment '<substitution>...</substitution>' in order to fire
+the transition with the chosen mode. A similar techniques can be
+applied to many situations. A lazy (but clever) approach would be to
+prepare a series of template queries where placeholders could be
+substituted with fragments of PNML text retrieved from the server.
+
+##
+## Keyword arguments
+##
+
+A <query> may also accepts keyword arguments like functions in Python.
+But currently no query expects that. The syntax to add keyword
+arguments is to use a tag <keyword> for each such argument, with an
+attribute 'name' that store the keyword name and with a child tag that
+stores the keyword value. For instance, a Python call "example('x', 1,
+foo=5, bar='hello')" would translate to a query:
+
+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <query name="example">
+  <argument>
+   <object type="str">
+    x
+   </object>
+  </argument>
+  <argument>
+   <object type="int">
+    1
+   </object>
+  </argument>
+  <keyword name="foo">
+   <object type="int">
+    5
+   </object>
+  </keyword>
+  <keyword name="bar">
+   <object type="str">
+    hello
+   </object>
+  </keyword>
+ </query>
+</pnml>

+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <net id="mynet">
+  <place id="p2">
+   <type domain="universal"/>
+   <initialMarking>
+    <multiset/>
+   </initialMarking>
+  </place>
+  <place id="p1">
+   <type domain="universal"/>
+   <initialMarking>
+    <multiset>
+     <item>
+      <value>
+       <object type="int">
+        1
+       </object>
+      </value>
+      <multiplicity>
+       1
+      </multiplicity>
+     </item>
+     <item>
+      <value>
+       <object type="int">
+        2
+       </object>
+      </value>
+      <multiplicity>
+       1
+      </multiplicity>
+     </item>
+    </multiset>
+   </initialMarking>
+  </place>
+  <transition id="t"/>
+  <arc id="p1:t" source="p1" target="t">
+   <inscription>
+    <variable>
+     x
+    </variable>
+   </inscription>
+  </arc>
+  <arc id="t:p2" source="t" target="p2">
+   <inscription>
+    <expression>
+     x+1
+    </expression>
+   </inscription>
+  </arc>
+ </net>
+</pnml>

+<?xml version="1.0" encoding="utf-8"?>
+<pnml>
+ <net id="Simple P/T net">
+  <place id="p2">
+   <initialMarking>
+    <text>
+     0
+    </text>
+   </initialMarking>
+  </place>
+  <place id="p1">
+   <initialMarking>
+    <text>
+     1
+    </text>
+   </initialMarking>
+  </place>
+  <transition id="t2"/>
+  <transition id="t1"/>
+  <arc id="p2:t2" source="p2" target="t2">
+   <inscription>
+    <text>
+     1
+    </text>
+   </inscription>
+  </arc>
+  <arc id="t2:p1" source="t2" target="p1">
+   <inscription>
+    <text>
+     1
+    </text>
+   </inscription>
+  </arc>
+  <arc id="p1:t1" source="p1" target="t1">
+   <inscription>
+    <text>
+     1
+    </text>
+   </inscription>
+  </arc>
+  <arc id="t1:p2" source="t1" target="p2">
+   <inscription>
+    <text>
+     1
+    </text>
+   </inscription>
+  </arc>
+ </net>
+</pnml>

+This document describes the PNML extensions used bu SNAKES. See
+http://www.pnml.org for the definition of the standard PNML. In the
+following, we use a simplified RELAX NG Compact Syntax (see
+http://relaxng.org). For each element, we provide the Python class
+that implements it (see API reference for details), a list of its
+attributes and children elements.
+
+##
+## Petri net elements
+##
+
+element pnml {
+  element net { ... }*
+}
+# Several nets may be provided in one PNML file.
+
+element net {                  # class snakes.nets.PetriNet
+  attribute id { text }        # identity of the net
+  element place { ... }*       # places in the net
+  element transition { ... }*  # transitions in the net
+  element arc { ... }*         # arcs in the net
+}
+
+element place {                     # class snakes.nets.Place
+  attribute id { text }             # identity of the place
+  element type { ... }?             # for a coloured place
+  element initialMarking {          # marking
+    ( element text { num:integer }  # for a P/T place
+     | element multiset { ... } )   # for a coloured place
+  }?
+}
+# A P/T place is identified in SNAKES by the fact it has a typing
+# constraint "tBlackToken". In such a case, its initial marking is
+# given as the number of black tokens held by the place, which
+# respects the PNML standard. In the other cases, the place is
+# considered to be coloured and its type constraint is given by an
+# element <type> and its marking is given by an element <multiset>.
+
+element transition {            # class snakes.nets.Transition
+  attribute id { text }         # identity of the transition
+  element guard {
+    element expression { ... }  # guard if not True
+  }?
+}
+# When the guard is True, like in P/T nets, it is not saved in the
+# PNML so that the result respects PNML standard. Otherwise, the guard
+# is saved inside a tag <guard>.
+
+element declare {
+  statement
+}
+# One <declare> tag is added to <net> for each Python statement run
+# using PetriNet.declare() for this net.
+
+element global {
+  attribute name { name:string }  # object's name
+  element * { ... }               # value
+}
+# One <global> is added to <net> for each entry in net.globals that
+# is not obtained through the use of PetriNet.declare().
+
+##
+## Arcs
+##
+
+element arc {
+  attribute id { text }      # identity of the arc
+  attribute source { text }  # identity of source node
+  attribute target { text }  # identity of target node
+  element inscription {
+    element text {           # for a P/T net
+      weight:int
+    }?
+    element * { ... }?       # for a coloured net
+  }
+}
+# When the net is a P/T net, a weight is given for the arcs, which
+# respects the PNML standard. Otherwise, the inscription is one of the
+# possible inscriptions given below.
+
+element value {           # class snakes.nets.Value
+  element object { ... }  # value transported on an arc
+}
+
+element variable {  # class snakes.nets.Variable
+  name:string       # name of the variable
+}
+
+element expression {  # class snakes.nets.Expression
+  expr:string         # text of the expression (Python code)
+}
+
+element test {                   #  class snakes.nets.Test
+  ( element value { ... }
+   | element variable { ... }
+   | element expression { ... }
+   | element multiarc { ... }
+   | element tuple { ... } )     # tested annotation
+}
+
+element multiarc {               # class snakes.nets.MultiArc
+  ( element value { ... }
+   | element variable { ... }
+   | element expression { ... }
+   | element multiarc { ... }
+   | element tuple { ... } )*    # list of encapsulated annotations
+}
+
+element tuple {                  # class snakes.nets.Tuple
+  ( element value { ... }
+   | element variable { ... }
+   | element expression { ... }
+   | element multiarc { ... }
+   | element tuple { ... } )*    # list of encapsulated annotations
+}
+
+
+##
+## Auxiliary tags
+##
+
+element token {  # class snakes.nets.BlackToken
+}                # a standard black token
+
+element marking {               # class snakes.nets.Marking
+  element place {               # one for each marked place
+    attribute id { text }       # identity of the place
+    element tokens {
+      element multiset { ... }  # marking of the place
+    }
+  }*
+}
+
+element multiset {            # class snakes.data.MultiSet
+  element item {              # items in the multiset
+    element value {
+      element object { ... }  # value of one item
+    }
+    element multiplicity {    # number of time it is repeated
+      num:integer
+    }
+  }*
+}
+
+element substitution {        # class snakes.data.Substitution
+  element item {              # mapped variables
+    element name {
+      name:string             # variable name
+    }
+    element value {
+      element object { ... }  # associated value
+    }
+  }*
+}
+
+##
+## Python objects
+##
+
+element object {
+  attribute type { ... }  # type of the object
+  ...                     # depends of attribute type
+}
+
+element object {
+  attribute type { "int" }  # object is an integer
+  value:integer
+}
+
+element object {
+  attribute type { "float" }  # object is a float
+  value:float
+}
+
+element object {
+  attribute type { "str" }  # object is a string
+  value:string
+}
+
+element object {
+  attribute type { "bool" }  # object is a Boolean
+  ( "True" | "False" )
+}
+
+element object {
+  attribute type { "list" }  # object is a list
+  element object { ... }*    # list items
+}
+
+element object {
+  attribute type { "tuple" }  # object is a tuple
+  element object { ... }*     # tuple items
+}
+
+element object {
+  attribute type { "set" }  # object is a set
+  element object { ... }*   # set items
+}
+
+element object {
+  attribute type { "method" }    # object is a class method
+  attribute name { path:string}  # path to method, including module name
+}
+
+element object {
+  attribute type { "function" }  # object is a function
+  attribute name { path:string}  # path to function, including module name
+}
+
+element object {
+  attribute type { "class" }     # object is a class
+  attribute name { path:string}  # path to class, including module name
+}
+
+element object {
+  attribute type { "module" }    # object is a module
+  attribute name { path:string}  # path to module
+}
+
+element object {
+  attribute type { "pickle" }  # object that cannot be handled symbolically
+  data:string                  # pickled object
+}
+
+element object {
+  attribute type { "NoneType" }  # object is the value None
+}
+
+##
+## Typing constraints
+##
+
+element type {
+  attribute domain { text }  # kind of typing constraint
+  ...                        # depending on domain
+}
+# Module snakes.typing defines a full algebra of types, all are saved
+# to an element <type>. The  attribute "domain" is then the key to
+# decompose correctly a type. Below is a list of the different
+# domains, with the structure of the corresponding type
+
+element type {                         # class snakes.typing._And
+  attribute domain { "intersection" }  # intersection of two types
+  element left {                       # left operand type
+    element type { ... }
+  }
+  element right {                      # right operand type
+    element type { ... }
+  }
+}
+
+element type {                  # class snakes.typing._Or
+  attribute domain { "union" }  # union of two types
+  element left {                # left operand type
+    element type { ... }
+  }
+  element right {               # right operand type
+    element type { ... }
+  }
+}
+
+element type {                       # class snakes.typing._Sub
+  attribute domain { "difference" }  # difference of two types
+  element left {                     # left operand type
+    element type { ... }
+  }
+  element right {                    # right operand type
+    element type { ... }
+  }
+}
+
+element type {                # class snakes.typing._Xor
+  attribute domain { "xor" }  # exclusive union of two types
+  element left {              # left operand type
+    element type { ... }
+  }
+  element right {             # right operand type
+    element type { ... }
+  }
+}
+
+element type {                       # class snakes.typing._Invert
+  attribute domain { "complement" }  # complement of a type
+  element type { ... }               # complemented type
+}
+
+element type {                      # class snakes.typing._All
+  attribute domain { "universal" }  # type with all possible values
+}
+
+element type {                  # class snakes.typing._Nothing
+  attribute domain { "empty" }  # type with no value
+}
+
+element type {                     # class snakes.typing.Instance
+  attribute domain { "instance" }  # type whose values are instances
+  element object { ... }           # class of the instances
+}
+
+element type {                    # class snakes.typing.TypeCheck
+  attribute domain { "checker" }  # type defined by a Boolean function
+  element checker {
+    element object { ... }        # the Boolean function
+  }
+  element iterator {
+    element object { ... }        # a function to enumerate the values
+  }
+}
+
+element type {                 # class snakes.typing.OneOf
+  attribute domain { "enum" }  # enumerated type
+  element object { ... }*      # values in the type
+}
+
+element type {                       # class snakes.typing.Collection
+  attribute domain { "collection" }  # flat container type (list, set, ...)
+  element container {
+    element type { ... }             # type of the container
+  }
+  element items {
+    element type { ... }             # type of the contained items
+  }
+  element min {
+    element object { ... }           # smallest allowed number of elements
+  }
+  element max {
+    element object { ... }           # biggest allowed number of elements
+  }
+}
+
+element type {                    # class snakes.typing.Mapping
+  attribute domain { "mapping" }  # dictionary-like container type
+  element container {
+    element type { ... }          # type of the container
+  }
+  element keys {
+    element type { ... }          # type of the contained keys
+  }
+  element items {
+    element type { ... }          # type of the contained items
+  }
+}
+
+element type {                  # class snakes.typing.Range
+  attribute domain { "range" }  # values in a range
+  element min {
+    element object { ... }      # smallest allowed value
+  }
+  element min {
+    element object { ... }      # smallest excluded value
+  }
+  element min {
+    element object { ... }      # step between consecutive values
+  }
+}
+
+element type {                    # class snakes.typing.Greater
+  attribute domain { "greater" }  # values bigger than a given one
+  element object { ... }          # biggest excluded value
+}
+
+element type {                      # class snakes.typing.GreaterOrEqual
+  attribute domain { "greatereq" }  # values not smaller than a given one
+  element object { ... }            # smallest allowed value
+}
+
+element type {                 # class snakes.typing.Less
+  attribute domain { "less" }  # values smaller than a given one
+  element object { ... }       # smallest excluded value
+}
+
+element type {                   # class snakes.typing.LessOrEqual
+  attribute domain { "lesseq" }  # values not bigger than a given one
+  element object { ... }         # biggest allowed value
+}
+
+element type {                         # class snakes.typing.CrossProduct
+  attribute domain { "crossproduct" }  # cross product of types
+  element type { ... }*                # crossed types
+}
+
+##
+## Additional elements from plugins
+##
+
+element snakes {
+  attribute version { ... }       # SNAKES' version that produced this PNML
+  element plugins {
+    element object {
+      attribute type { "tuple" }
+      element object {            # the base module 'snakes.nets' is listed also
+        attribute type { "str" } 
+        "snakes.nets"
+      }
+      element object {            # list of plugins
+        attribute type { "str" } 
+        plugin:string
+      }*
+    }
+  }
+}
+# Added to another element in order to specify the plugins necessary
+# to load properly the element. <snakes><plugins> tags can be added at
+# any position in the PNML, but they are then used globally for a
+# whole <pnml> tree.
+
+element status {            # class snakes.plugins.status.Status
+  element name {
+    name:string             # status name
+  }
+  element value {
+    element object { ... }  # attached value
+  }
+}
+# Added to <place> and <transition> when plugin 'status' is loaded.
+
+element multiaction {      # class snakes.plugins.synchro.MultiAction
+  element action { ... }*  # actions in the multi-action
+}
+# Added to <transition> when plugin 'synchro' is loaded.
+
+element action {                   # class snakes.plugins.synchro.Action
+  attribute name { name:string }   # action name
+  attribute send { send:boolean }  # send/receive action
+  element * { ... }*               # action parameters
+}
+
+element clusters {             # class snakes.plugins.clusters.Cluster
+  element node { id:string }*  # nodes at this level
+  element clusters { ... }*    # children clusters
+}
+# Added to <net> when plugin 'clusters' is loaded.
+
+element label {                  # class snakes.plugins.labels
+  attribute name { name:string}  # label name
+  element object { ... }         # label content
+}
+# Added to <net>, <place> and <transition> when plugin 'labels' is
+# loaded.
+
+element graphics {
+  element position {                      # node position
+    attribute x { xpos:(integer|float) }  # x coordinate
+    attribute y { ypos:(integer|float) }  # y coordinate
+  }
+}
+# Added to <place> and <transition> when plugin 'pos' is loaded.
+
+element query {                # snakes.plugins.query.Query
+  attribute name { name:text}  # name of the query
+  element argument { ... }*    # arguments of the query
+  element keyword {            # keyword arguments
+    attribute name { text }    # keyword name
+    element * { ... }          # associated value
+  }*
+}
+# See file 'queries.txt'
+
+element answer {
+  attribute status { "ok" | "error" }  # status of the answer
+  message:string?                      # error message if status=error
+  element * { ... }?                   # returned value if status=ok 
+}
+# See file 'queries.txt'
+
+##
+## Abstract syntax tree
+##
+
+# The following specifies the PNML translation of abstract syntax
+# trees for ABCD programs, as inserted into <net> but the ABCD
+# compiler.
+
+element ast {                        # class snakes.compyler.Tree
+  attribute name { text }            # node nature
+  attribute lineno { num:integer }?  # line number in source code
+  attribute * { ... }*               # depending on name
+  element * { ... }*                 # depending on name
+}
+# <ast> trees are obtained by direct translation of
+# snakes.compyler.Tree instances: tree name is mapped to an attribute
+# 'name', sub-trees are mapped to child tags, and attributes are
+# mapped either to attributes or to child tags <attribute> when they
+# cannot be represented as a simple string. The following lists the
+# more current patterns. The element 'lineno' will be omitted in the
+# following.
+
+element ast {
+  attribute name { "abcd" }          # start symbol
+  element ast {                      # buffer declarations
+    attribute name { "buffer" }
+    ...
+  }*
+  element ast {                      # net declarations
+    attribute name { "net" }
+    ...
+  }*
+  element attribute {                # ABCD expression
+    attribute name { "expr" }
+    ...
+  }
+}
+# An ABCD program is composed of optional buffer and net declarations,
+# followed by an ABCD expression.
+
+element ast {
+  attribute name { "buffer" }       # buffer declaration
+  attribute ident { text:string }   # buffer's name
+  element attribute {
+    attribute name { "type" }       # buffer's type
+    ...
+  }
+  element attribute {               # buffer's initial value
+    attribute name { "init" }
+    ...
+  }
+}
+
+element net {
+  attribute name { "net" }          # net declaration
+  attribute ident { text:string }   # net's name
+  element ast {                     # net's body
+    attribute name { "abcd" }
+    ...
+  }
+}
+
+element ast {
+  attribute name { "expr" }
+  element ast {
+    attribute name { ( "parallel"     # binary composition
+                      | "loop"
+                      | "sequence"
+                      | "choice" ) }
+    element ast { ... }               # first operand
+    element ast { ... }               # second operand
+  }
+}
+
+element ast {
+  attribute name { "expr" }
+  element ast {
+    attribute name { "scope" }     # name hiding
+    element ast { ... }            # first operand
+    element object {
+      attribute type { "str" }     # hidden name
+      name:string
+    }
+  }
+}
+
+element ast {
+  attribute name { "action" }                 # basic action
+  attribute net { ( name:string | "None" ) }  # reference to a net
+  attribute test { ( "False" | "True" ) }?    # trivial condition
+  element ast {
+    attribute name { "access" }               # buffer access
+    attribute buffer { name:string }          # buffer's name
+    attribute mode { ("?" | "+" | "-") }      # test, put or get
+    element attribute {
+      attribute name { "param" }              # access' parameter
+      element python { ... }                  # Python's AST of the parameter
+    }
+  }*
+  element attribute {                         # non-trivial condition
+    attribute name { "test" }
+    element python { ... }                    # Python's AST of the condition
+  }?
+}
+# A basic action can be the name of a net or a trivial action
+# '[False]'. Otherwise, it is composed of a possibly empty list of
+# buffer accesses and a condition. If the condition is 'True', it is
+# stored as attribute 'test=True", but more complex conditions are
+# stored as a Python AST in a child tag <attribute name="test">. Each
+# access is composed of a buffer name, an access mode and a parameter.
+
+# Next elements are children of a tag <attribute name="type"> and
+# defined the type of a buffer.
+
+element ast {
+  attribute name { "name }         # Python built-in type
+  attribute value { type:string }  # name of the type
+}
+
+element ast {
+  attribute name { "enum" }         # enumerated type
+  element ast {
+    attribute name { "values" }
+    element python {                # Python's AST node in this case
+      attribute class { "Tuple" }   # is a Tuple of Const
+      element attribute {
+        attribute name { "nodes" }
+        values                      # eg, "[Const('a'), Const('b')]"
+      }
+    }
+  }
+}
+
+element ast {
+  attribute name { "union" }  # union of two types
+  element ast { ... }         # first type
+  element ast { ... }         # second type
+}
+
+element ast {
+  attribute name { "intersection" }  # intersection of two types
+  element ast { ... }                # first type
+  element ast { ... }                # second type
+}
+
+element ast {
+  attribute name { "list" }  # list type
+  element ast { ... }        # items' type
+}
+
+element ast {
+  attribute name { "dict" }  # dict type
+  element ast { ... }        # keys' type
+  element ast { ... }        # values' type
+}
+
+element ast {
+  attribute name { "set" }  # set type
+  element ast { ... }       # items' type
+}
+
+# A Python AST is serialized as a <python> tag, see the section 31.3.1
+# (AST Nodes) of the Python Library Reference for a list of AST nodes.
+
+element python {
+  attribute * { text }*      # direct mapping of simple attributes
+  element attribute {        # complex attributes are serialized 
+    attribute name { text }  # in a tag <object>
+    element object { ... }
+  }*
+  data?                      # when none of the above method works,
+                             # 'repr' is used to convert the AST to text
+}

+SNAKES: a tutorial
+==================
+
+////////////////////////////////////////////////////////////////
+This file is formatted in order to be processed by AsciiDoc
+(http://www.methods.co.nz/asciidoc). It will be more comfortable
+to render it or to read the HTML version available at:
+http://www.univ-paris12.fr/pommereau/soft/snakes/tutorial.html
+////////////////////////////////////////////////////////////////
+
+The first example is a simple coloured Petri net with a single
+transition that increments an integer valued (so 0 is the _value_ of
+the token, not a number of tokens) token held by a single place, the
+incrementation stops when the value is $5$ thanks to a guard on the
+transition.
+
+image:tutorial.png[]
+
+To define this net, we must load SNAKES, define a Petri net (lets call
+it 'First net'), add the place (called 'p'), add the transition
+(called 't') and then connect them with arcs.
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> from snakes.nets import *
+>>> n1 = PetriNet('First net')
+>>> n1.add_place(Place('p', [0]))
+>>> n1.add_transition(Transition('t', Expression('x<5')))
+>>> n1.add_input('p', 't', Variable('x'))
+>>> n1.add_output('p', 't', Expression('x+1'))
+^^^^^^^^^^^^^^^^^^^^^^
+
+On the third line, the net is added a place, which could equivalently
+be written as:
+
+//skip
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> p = Place('p', [0])
+>>> n1.add_place(p)
+^^^^^^^^^^^^^^^^^^^^^^
+
+However, having a variable for the place is not necessary as it can be
+retrieved from $n1$ using its name with $n1.place('p')$.
+
+The instruction $Place('p', [0])$ is the construction of a new
+instance of the class $Place$ that expects the name of the place as
+its first argument. The second argument is optional and is the initial
+marking of the place, that can be given as a list, set, tuple or
+multiset of tokens (the class for multisets is defined in the module
+$snakes.data$). A third optional argument is a constraint for the
+tokens that the place can hold (also known as its type); the default
+value allows any token to mark the place. The typing of the places
+will be detailed later on.
+
+In order to build the transition, we create an instance of the class
+$Transition$ whose constructor expects first the name of the
+transition and the, optionally, the guard of it that is true by
+default. A guard is otherwise specified as $Expression('...')$ where
+$...$ is an arbitrary Python expression, like $Expression('x<5')$ in
+our example. We will details latter on how this expression is
+evaluated.
+
+Arcs are added using one of the methods $add_input$ or $add_output$ of
+$PetriNet$; both expect a place name, a transition name and the arc
+annotation as arguments (always in this order). An input arc is
+directed from a place toward a transition, an output arc is outgoing a
+transition; so arcs are considered from the point of view of the
+transition to which they are connected. Valid arc annotations are:
+
+values:: They are instances of the class $Value$ whose constructor
+simply expects the value that can be any Python object. For instances,
+$Value(1)$ is the integer $1$.
+
+variables:: These are names that are bound to token values when a
+transition if executed. A variable is created by instantiating the
+class $Variable$ whose constructor expects the name of the variable as
+a Python string (valid names are those matching the Python regexp:
+$'[a-zA-Z]\w*'$). For instance, $Variable('x')$, $Variable('count')
+and $Variable('x_1')$ are valid but $Variable('x-1')$ and
+$Variable('1x') are not.
+
+expressions:: They are used to compute new values. An expression is an
+instance of the class $Expression$ whose constructor expects any
+Python expression as a string. How this expression is evaluated is
+explained in the next section. In our example, $Expression('x+1')$ as
+been used on the output arc.
+
+tests:: The class $Test$ is used to implement a test arc: it
+encapsulates another arc annotation and behaves exactly like it,
+except that no token is transported by the arc when the attached
+transition fires. The constructor expects another arc annotation as
+its sole argument, for instance: $Test(Variable('x'))$ on an input arc
+allows to test for a token in a place, its value being usable as $x$.
+On a output arc, $Test(Expression('x+1'))$ may be used to test that
+the value of $x+1$ is accepted by the connected place, without
+actually producing it.
+
+multi-arcs:: When an arc needs to transport several values, the class
+$MultiArc$ may be used. Its constructor expects a list (or tuple) of
+other annotations that are simultaneously transported on the arc. For
+instance, $MultiArc([Variable('x'), Variable('y')])$ on an input arcs
+allows to consume two tokens, binding them to the variables $x$ and
+$y$.
+
+
+Executing transitions
+---------------------
+
+The first step to execute a transition is to bind the variables
+labelling the arcs to actual token values. This is possible by calling
+the method $modes()$ of a transition. It returns a list of
+$Substitution$ instances (this class is defined in $snakes.data$). A
+$Substitution$ is a $dict$-like object that maps variable names to
+other variables names or to values. The method $modes$ returns the
+list of substitutions that are acceptable in order to fire the
+transition, _i.e._, those that respect the usual following conditions:
+
+ * each input arc, evaluated through the substitution, corresponds to
+   a multiset of tokens that is less or equal to the current marking
+   of the connected place;
+
+ * each output arc, evaluated through the substitution, results in a
+   multiset of tokens that respects the type constraint of the
+   connected place;
+
+ * the guard of the transition, evaluates to $True$ through the
+   substitution.
+
+For instance, with our net:
+
+[python]
+^^^^^^^^^^^^^^^^^^
+>>> n1.transition('t').modes()
+[Substitution(x=0)]
+^^^^^^^^^^^^^^^^^^
+
+The only way to fire the transition is to bind $x$ to $0$. Other may
+have been tried, but do not respect at least one of the above
+conditions. For instance, choosing $x=1$ respects the guard and place
+types but not the marking (the token $1$ is missing):
+
+[python]
+^^^^^^^^^^^^^^^^^^
+>>> from snakes.data import Substitution
+>>> s = Substitution(x=1)
+>>> n1.transition('t').enabled(s)
+False
+^^^^^^^^^^^^^^^^^^
+
+In order to fire a transition, we have to call its method $fire$ with
+an enabling substitution as argument (_i.e._, one of those returned by
+$modes()$). In our example, we could run:
+
+[python]
+^^^^^^^^^^^^^^^^^^
+>>> n1.transition('t').fire(Substitution(x=0))
+>>> n1.place('p').tokens
+MultiSet([1])
+^^^^^^^^^^^^^^^^^^
+
+It is important to understand how the firing is performed: the
+substitution is used as a Python environment to evaluate the
+annotations on the arcs and the guard of the transition in order to
+check that the conditions above are respected. For instance, the guard
+$Expression('x<5')$ can be evaluated to $true$ because $x$ is bound to
+$0$ through the substitution. Similarly, the output arc
+$Expression('x+1')$ is evaluated to $1$. The environment used to
+evaluate the guard and output arcs is built using the input arcs, this
+means that all the variables used during the firing must have been
+bound through one of these input arcs. For instance, we could use
+$Expression('x<5 and y==x+1')$ for the guard and $Variable('y')$ for the
+output arc, and $Substitution(x=0, y=1)$ for the firing:
+
+[python]
+^^^^^^^^^^^^^^^^^^
+>>> n2 = PetriNet('Second net')
+>>> n2.add_place(Place('p', [0]))
+>>> n2.add_transition(Transition('t', Expression('x<5 and y==x+1')))
+>>> n2.add_input('p', 't', Variable('x'))
+>>> n2.add_output('p', 't', Variable('y'))
+>>> n2.transition('t').fire(Substitution(x=0, y=1))
+>>> n2.place('p').tokens
+MultiSet([1])
+^^^^^^^^^^^^^^^^^^
+
+This example is correct as long as the substitution is provided by the
+user. But the method $modes$ is unable to deduce the value for $y$, it
+would require to solve the equation $x<5 and y==x+1$ in the guard.
+This is easy here but impossible in general, so, the modes are
+computed only with respect to the input arcs. This is why $Expression$
+instances are not allowed on input arcs, neither directly nor when
+encapsulated in $Test$ or $MultiArc$ instances. So, in this second
+example, if we call $modes()$, we get an error since $y$ in cannot be
+evaluated:
+
+[python]
+^^^^^^^^^^^^^^^^^^
+>>> n2.transition('t').modes()
+Traceback (most recent call last):
+  ...
+NameError: name 'y' is not defined
+^^^^^^^^^^^^^^^^^^
+
+
+Declarations
+------------
+
+There is one more aspect about the evaluation of the expression that
+should be known: it is possible to declare names that are global to a
+Petri net, for instance constants or functions. To do so, we shall use
+the method $declare$ of a $PetriNet$ instance, that expects as its
+argument a Python statement in a string. This statement is executed
+and its effect is remembered in order to be used as a global execution
+environment when expressions are evaluated. For instance, lets
+construct a Petri net that generates random tokens using the standard
+Python function $random.randint$:
+
+[python]
+^^^^^^^^^^^^^^^^^^
+>>> n3 = PetriNet('Thirs net')
+>>> n3.add_place(Place('p', [0]))
+>>> n3.add_transition(Transition('t'))
+>>> n3.add_input('p', 't', Variable('x'))
+>>> n3.add_output('p', 't', Expression('random.randint(0, 100)'))
+>>> n3.transition('t').fire(Substitution(x=0))
+Traceback (most recent call last):
+  ...
+NameError: name 'random' is not defined
+^^^^^^^^^^^^^^^^^^
+
+This result is not surprising as the module as not been imported. This
+must be made with the statements (the second line is to initialise the
+random generator):
+
+[python]
+^^^^^^^^^^^^^^^^^^
+>>> n3.declare('import random')
+>>> n3.declare('random.seed()')
+^^^^^^^^^^^^^^^^^^
+
+Then, the transition can fire; of course, the resulting marking will
+be different from one execution to another since it is random:
+
+//hide 93
+[python]
+^^^^^^^^^^^^^^^^^^
+>>> n3.transition('t').fire(Substitution(x=0))
+>>> n3.place('p').tokens
+MultiSet([93])
+^^^^^^^^^^^^^^^^^^
+
+The effect of the $n3.declare(statement)$ method is to call $exec
+statement in n3.globals$, where $n3.globals$ is a dictionary shared by
+all the expression embedded in the net (in guards or arcs). So,
+another way to influence the evaluation of these expressions is to
+directly assign values to the dictionary $n3.globals$, for instance:
+
+//doc >>> n3.place('p').reset([93])
+//hide 18
+[python]
+^^^^^^^^^^^^^^^^^^
+>>> n3.add_place(Place('x'))
+>>> n3.add_output('x', 't', Expression('y+1'))
+>>> n3.transition('t').fire(Substitution(x=93))
+Traceback (most recent call last):
+  ...
+NameError: name 'y' is not defined
+>>> n3.globals['y'] = 42
+>>> n3.transition('t').fire(Substitution(x=93))
+>>> n3.get_marking()
+Marking({'p': MultiSet([18]), 'x': MultiSet([43])})
+^^^^^^^^^^^^^^^^^^
+
+The first error is expected as $y$ as not been declared and is not
+bound to any token value through an input arc. After assigning it to
+$n3.globals$, it becomes defined so $Expression('y+1')$ can be
+evaluated. The same effect could have been achieved using
+$n3.declare('y=42')$.
+
+The last instruction gets the marking of the net, lets detail now what
+we can do with marking objects.
+
+
+Markings, marking graph
+-----------------------
+
+An instance of $PetriNet$ has methods to get and set its marking,
+which are respectively $get_marking$ and $set_marking$. There are also
+the methods $add_marking$ and $remove_marking$ to increase or decrease
+the current marking.
+
+[NOTE]
+========================
+The marking of an individual place can also be directly manipulated,
+either though its attribute $tokens$ (we used it above) that is a
+multiset, or through the following methods:
+
+$add(toks)$:: adds the tokens in $toks$ to the place ($toks$ can be
+any collection of values: $set$, $list$, $tuple$, $MultiSet$, ...)
+
+$remove(toks)$:: does just the contrary
+
+$reset(toks)$:: replaces the marking with the tokens in $toks$
+
+$empty()$:: removes all the tokens from the place
+
+$is_empty()$:: returns a Boolean indicating whether the place is empty
+or not
+========================
+
+A marking is an instance of the class $snakes.nets.Marking$ and is
+basically a mapping from place names to multisets of values. It has
+been chosen that a marking is independent of any particular Petri net,
+so, empty places are not listed in a marking and when assigning a
+marking to a net, places that are present in the marking but absent
+from the net are simply ignored. Markings can be added with the $+$
+operator, subtracted with $-$ or compared with the usual operators
+$>$, $<=$, $==$, etc. In order to know the marking of a particular
+place, we can use it as a function taking the place name as argument:
+
+[python]
+^^^^^^^^^^^^^^^^
+>>> m = Marking(p1=MultiSet([1, 2, 3]), p2=MultiSet([5]))
+>>> m('p1')
+MultiSet([1, 2, 3])
+>>> m('p')
+MultiSet([])
+^^^^^^^^^^^^^^^^
+
+The last result shows that a place that is not listed in a marking is
+considered empty, which is consistent with the fact that empty places
+are not listed in a marking extracted from a net. If we use the
+marking as a $dict$ instead of a function, we will get errors on non
+existing places:
+
+[python]
+^^^^^^^^^^^^^^^^
+>>> m['p1']
+MultiSet([1, 2, 3])
+>>> m['p']
+Traceback (most recent call last):
+  ...
+KeyError: 'p'
+^^^^^^^^^^^^^^^^
+
+The marking graph of a net can be manipulated using the class
+$StateGraph$. Lets take an example to see how it works:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> n4 = PetriNet('Fourth net')
+>>> n4.add_place(Place('p', [-1]))
+>>> n4.add_transition(Transition('t'))
+>>> n4.add_input('p', 't', Variable('x'))
+>>> n4.add_output('p', 't', Expression('(x+1) % 5'))
+^^^^^^^^^^^^^^^^^^^^^^
+
+This example runs infinitely, incrementing modulo 5 the token in the
+place $'p'$. Its markings can be computed using a simple loop:
+
+//skip
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> while True:
+...     print n4.get_marking()
+...     modes = n4.transition('t').modes()
+...     if len(modes) == 0 :
+...         break
+...     n4.transition('t').fire(modes[0])
+...
+Marking({'p': MultiSet([-1])})
+Marking({'p': MultiSet([0])})
+Marking({'p': MultiSet([1])})
+Marking({'p': MultiSet([2])})
+Marking({'p': MultiSet([3])})
+Marking({'p': MultiSet([4])})
+Marking({'p': MultiSet([0])})
+Marking({'p': MultiSet([1])})
+^^^^^^^^^^^^^^^^^^^^^^
+
+Unfortunately, this loop runs forever as the net has no deadlock.
+Moreover, if in a state there exist several modes, only the first one
+will be used in the exploration. To avoid building ourselves the
+marking graph, we can use instead:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> s = StateGraph(n4)
+>>> s.build()
+>>> for state in s :
+...     print state, s.net.get_marking()
+...     print " =>", s.successors()
+...     print " <=", s.predecessors()
+... 
+0 Marking({'p': MultiSet([-1])})
+ => {1: (Transition('t', Expression('True')), Substitution(x=-1))}
+ <= {}
+1 Marking({'p': MultiSet([0])})
+ => {2: (Transition('t', Expression('True')), Substitution(x=0))}
+ <= {0: (Transition('t', Expression('True')), Substitution(x=-1)), 5: (Transition('t', Expression('True')), Substitution(x=4))}
+2 Marking({'p': MultiSet([1])})
+ => {3: (Transition('t', Expression('True')), Substitution(x=1))}
+ <= {1: (Transition('t', Expression('True')), Substitution(x=0))}
+3 Marking({'p': MultiSet([2])})
+ => {4: (Transition('t', Expression('True')), Substitution(x=2))}
+ <= {2: (Transition('t', Expression('True')), Substitution(x=1))}
+4 Marking({'p': MultiSet([3])})
+ => {5: (Transition('t', Expression('True')), Substitution(x=3))}
+ <= {3: (Transition('t', Expression('True')), Substitution(x=2))}
+5 Marking({'p': MultiSet([4])})
+ => {1: (Transition('t', Expression('True')), Substitution(x=4))}
+ <= {4: (Transition('t', Expression('True')), Substitution(x=3))}
+^^^^^^^^^^^^^^^^^^^^^^
+
+The second statement computes the graph, then, for each state, we
+print its number, the corresponding marking and successors and
+predecessors states that include the state number as well as the
+transition (and its mode) that changed the marking. For instance, the
+state $1$ can be reached from $0$ or $5$ by firing $'t'$ with $x=-1$
+in and $x=4$ respectively.
+
+A marking graph is computed (an thus iterated) in a breadth first
+search. It may be iterated before it has been built completely; in
+this case, successors states are computed on the fly as each state is
+yield by the iteration. However, this results in having wrong
+predecessors states as a state not yet explored may lead to one
+already visited. This is the case here for the state $5$ that can lead
+to $1$ but this is not yet known when we are visiting $1$. This error
+is noticeable when the state $1$ is displayed while running:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> s2 = StateGraph(n4)
+>>> for state in s2 :
+...     print state, s2.net.get_marking()
+...     print " =>", s2.successors()
+...     print " <=", s2.predecessors()
+... 
+0 Marking({'p': MultiSet([-1])})
+ => {1: (Transition('t', Expression('True')), Substitution(x=-1))}
+ <= {}
+1 Marking({'p': MultiSet([0])})
+ => {2: (Transition('t', Expression('True')), Substitution(x=0))}
+ <= {0: (Transition('t', Expression('True')), Substitution(x=-1))}
+2 Marking({'p': MultiSet([1])})
+ => {3: (Transition('t', Expression('True')), Substitution(x=1))}
+ <= {1: (Transition('t', Expression('True')), Substitution(x=0))}
+3 Marking({'p': MultiSet([2])})
+ => {4: (Transition('t', Expression('True')), Substitution(x=2))}
+ <= {2: (Transition('t', Expression('True')), Substitution(x=1))}
+4 Marking({'p': MultiSet([3])})
+ => {5: (Transition('t', Expression('True')), Substitution(x=3))}
+ <= {3: (Transition('t', Expression('True')), Substitution(x=2))}
+5 Marking({'p': MultiSet([4])})
+ => {1: (Transition('t', Expression('True')), Substitution(x=4))}
+ <= {4: (Transition('t', Expression('True')), Substitution(x=3))}
+^^^^^^^^^^^^^^^^^^^^^^
+
+Finally, it is worth noting that no check is performed in order to
+ensure that a marking graph is finite. The method $build$ may run
+forever until it fills the computer memory and crash the program.
+Moreover, if we use strange constructs like random numbers generators,
+the state graph obtained may be partial as the program cannot known
+when all the possibilities have been explored.
+
+
+Places types
+------------
+
+The places defined until now did accept any token value in their
+marking. It is possible to restrict that by providing a type to place
+when it is constructed. A typing system is defined in the module
+$typing$ to provide the flexibility for defining any place type. In
+this context, a type is understood as a set of values that can be
+infinite. Types can be combined to by the usual set operation
+(examples are given below). Several basic types are already defined:
+
+$tAll$:: allows any value, this is the type assigned to a constructed
+place when no other type is given.
+
+$tNothing$:: is the type with no value.
+
+$tInteger$:: is the type of integer values.
+
+$tNatural$:: is a restriction of $tInteger$ to non-negative values.
+
+$tPositive$:: is a restriction of $tInteger$ to strictly positive
+values.
+
+$tFloat$:: is the type of floating point numbers.
+
+$tNumber$:: is the union of $tFloat$ and $tInteger$.
+
+$tString$:: is the type for Python $str$ instances.
+
+$tBoolean$:: is the set holding the two values $False$ and $True$.
+
+$tNone$:: holds the only value $None$.
+
+$tBlackToken$:: holds the only value $dot$ that stands for the usual
+Petri net black token.
+
+$tList$:: allows for values that are instances of the Python class
+$list$.
+
+$tDict$:: allows for values that are instances of the Python class
+$dict$.
+
+$tTuple$:: allows for values that are instances of the Python class
+$tuple$.
+
+$tPair$:: is a restriction of $tTuple$ to tuples of length 2.
+
+The module typing also provides with type constructors, allowing to
+create new types. Moreover, types can be combined using various
+operators, for instance, the module $typing$ makes the following
+definitions:
+
+[python]
+^^^^^^^^^^^^^^^^^
+tInteger = Instance(int)
+# an instance of int
+tNatural = tInteger & GreaterOrEqual(0)
+# an instance of int and a value greater than or equal to zero
+tPositive = tInteger & Greater(0)
+# an instance of int and a value strictly positive
+tFloat = Instance(float)
+tNumber = tInteger|tFloat
+# an instance of int or of float
+tBoolean = OneOf(False, True)
+# one value of False and True
+tNone = OneOf(None)
+# only the value None
+tBlackToken = OneOf(dot)
+# only the value dot
+tTuple = Tuple(tAll)
+# an instance of tuple holding any value
+tPair = Tuple(tAll, min=2, max=2)
+# an instance of tuple holding exactly two items of any type
+^^^^^^^^^^^^^^^^^
+
+A type can be called as a function in which case it returns $True$ if
+all its argument belong to the type and $False$ otherwise, for
+instance:
+
+[python]
+^^^^^^^^^^^^^^^^^
+>>> from snakes.typing import *
+>>> tNatural(2, 3, 4, 0)
+True
+>>> tNatural(-1)
+False
+^^^^^^^^^^^^^^^^^
+
+When a place is constructed a third argument can be given to define
+its type. If later on a token that does not respect the type is added
+to the place, an exception is raised.
+
+[python]
+^^^^^^^^^^^^^^^^^
+>>> from snakes.typing import *
+>>> tNatural(2)
+True
+>>> tNatural(-1)
+False
+>>> p = Place('p', [0, 1, 2, 3], tNatural)
+>>> p.add(3)
+>>> p.tokens
+MultiSet([0, 1, 2, 3, 3])
+>>> p.add(-1)
+Traceback (most recent call last):
+  ...
+ValueError: forbidden token '-1'
+^^^^^^^^^^^^^^^^^
+
+When no type is given at construction time, $tAll$ is actually used,
+which explains why a place accepts any token by default.
+
+
+Plugins
+-------
+
+A system a plugins allow to extend SNAKES. In order to plug the module
+$foo$ into the module $snakes.nets$, one as to use:
+
+//skip
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^
+import snakes.plugins
+snakes.plugins.load('snakes.plugins.foo', 'snakes.nets', 'my_nets')
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Intuitively, this (correct) statements have the effect of the
+(incorrect) statement:
+
+//skip
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^
+import 'snakes.nets extended by snakes.plugins.foo' as my_nets
+^^^^^^^^^^^^^^^^^^^^^^^
+
+So, one could now use:
+
+//skip
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^
+from my_nets import *
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Several plugins may be loaded at the same time:
+
+//skip
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^
+snakes.plugins.load(['snakes.plugins.foo, 'snakes.plugins.bar],
+                    'snakes.nets', 'my_nets')
+^^^^^^^^^^^^^^^^^^^^^^^
+
+This has the effect to load the plugin $foo$ on the top of
+$snakes.nets$ resulting in a module on the top of which $bar$ is then
+loaded.
+
+=== Giving positions to the nodes
+
+The plugin $snakes.plugins.pos$ is a very simple one that allows to
+give _x_/_y_ positions to the nodes of a Petri net.
+
+First we load the plugin:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> import snakes.plugins
+>>> snakes.plugins.load('snakes.plugins.pos', 'snakes.nets', 'nets')
+<module 'nets' from '...'>
+>>> from nets import PetriNet, Place, Transition
+^^^^^^^^^^^^^^^^^^^^^^
+
+A place can be added without specifying a position for it, in which
+case it will be positioned at $(0,0)$. The position is stored in an
+attribute $pos$ of the place as well as in $pos.x$ and $pos.y$:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> n = PetriNet('N')
+>>> p = Place('p00')
+>>> n.add_place(p)
+>>> p.pos
+Position(0, 0)
+>>> p.pos.x, p.pos.y
+(0, 0)
+^^^^^^^^^^^^^^^^^^^^^^
+
+The position can be defined when the node is created or when it is
+added to a net.
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> t10 = Transition('t10', pos=(1, 0))
+>>> n.add_transition(t10)
+>>> t10.pos
+Position(1, 0)
+>>> t = Transition('t01')
+>>> t.pos
+Position(0, 0)
+>>> n.add_transition(t, pos=(0, 1))
+>>> t.pos
+Position(0, 1)
+^^^^^^^^^^^^^^^^^^^^^^
+
+The last statement above shows that the node is copied when added to a
+net and thus $t$ keeps its position $(0,0)$ but its copy in $n$ as
+been positioned at $(0,1)$.
+
+Nodes can be moved using the $shift$ or $moveto$ method, but not by
+directly assigning their attributes $pos.x$ of $pos.y$:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> t = n.transition('t01')
+>>> t.pos
+Position(0, 1)
+>>> t.pos.moveto(1, 2)
+>>> t.pos
+Position(1, 2)
+>>> t.pos.shift(1, -1)
+>>> t.pos
+Position(2, 1)
+>>> t.pos.x = 0
+Traceback (most recent call last):
+  ...
+AttributeError: readonly attribute
+^^^^^^^^^^^^^^^^^^^^^^
+
+A net extended by $snakes.plugins.pos$ has a method to compute its
+bounding box that is a tuple $((xmin, ymin), (xmax, ymax))$ where
+$xmin$ is the $x$ coordinate of the left-most node, and so on. A
+method $shift$ also allows to shift all the nodes of the net and a
+method $transpose$ rotates a whole net by 90° (_i.e._, the top-down
+direction becomes the left-right).
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> n.bbox()
+((0, 0), (2, 1))
+>>> n.shift(10, 10)
+>>> n.bbox()
+((10, 10), (12, 11))
+>>> t.pos
+Position(12, 11)
+>>> n.transpose()
+>>> t.pos
+Position(-11, 12)
+>>> n.bbox()
+((-11, 10), (-10, 12))
+^^^^^^^^^^^^^^^^^^^^^^
+
+Finally, notice that when nodes are merged, the position of the result
+can be defined by giving an argument $pos$ to the $merge_transitions$
+or $merge_places$ method. If no such argument is given, the position
+of the new node is computed as the barycentre of the positions of the
+merged nodes.
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> n.merge_transitions('t11', ['t01', 't10'], pos=(1,1))
+>>> n.transition('t11').pos
+Position(1, 1)
+>>> n.transition('t01').pos
+Position(-11, 12)
+>>> n.transition('t10').pos
+Position(-10, 11)
+>>> n.merge_transitions('t', ['t01', 't10'])
+>>> n.transition('t').pos
+Position(-10.5, 11.5)
+^^^^^^^^^^^^^^^^^^^^^^
+
+=== Drawing nets and marking graphs
+
+The plugin $graphviz$ can be used in order to produce a graphical
+rendering of $PetriNet$ and $StateGraph$ objects. It add to them a
+method $draw$ that saves a picture in various formats (those supported
+by http://www.graphviz.org[GraphViz]), in particular: PNG, JPEG, EPS,
+DOT. For a Petri net, the positions of the nodes is fixed using the
+plugin $pos$ (that is automatically loaded). For a stage graph, the
+nodes are automatically positioned by GraphViz.
+
+[WARNING]
+===========================
+In order to produce a graphical rendering in a format other than DOT,
+the plugin $graphviz$ calls the program $dot$ or $neato$. It is
+possible that a specially crafted file name will result in executing
+arbitrary commands on the system. So, take care when you run a SNAKES
+script that you did not program yourself. (In general, take care when
+your run any script from an unsafe source.)
+===========================
+
+Let's consider a simple example:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> import snakes.plugins
+>>> snakes.plugins.load('snakes.plugins.graphviz', 'snakes.nets', 'nets')
+<module 'nets' from '...'>
+>>> from nets import *
+>>> n = PetriNet('N')
+>>> n.add_place(Place('p00', [0]))
+>>> n.add_transition(Transition('t10', pos=(1, 0)))
+>>> n.add_place(Place('p11', pos=(1, 1)))
+>>> n.add_transition(Transition('t01', pos=(0, 1)))
+>>> n.add_input('p00', 't10', Variable('x'))
+>>> n.add_output('p11', 't10', Expression('(x+1) % 3'))
+>>> n.add_input('p11', 't01', Variable('y'))
+>>> n.add_output('p00', 't01', Expression('(y+2) % 4'))
+>>> n.draw('graphviz-net.png')
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This produces the following picture:
+
+image:graphviz-net.png[GraphViz net]
+
+The rendering is not very beautiful but should be useful in many
+cases. Transitions are labelled with their name and guard, places with
+their marking (inside), name and type (top-right), arcs are labelled
+with their inscription. The picture format is chosen using the
+extension of the created file: $.png$, $.jpg$, $.eps$, $.dot$...
+
+The marking graph can then be built and drawn also:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> s = StateGraph(n)
+>>> s.draw('graphviz-graph.png', landscape=False)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Which produces the picture:
+
+image:graphviz-graph.png[GraphViz stage graph]
+
+Each state is labelled with its number and the corresponding marking,
+arcs are labelled by the transition and binding that produce one
+marking from another.
+
+Notice that the option $landscape$ has been used in order to ask
+GraphViz to produce a vertical layout (it is horizontal by default).
+Other options exist, given here with their default value:
+
+$scale=72.0$:: a scale factor for the whole picture. The greater it is,
+the larger will be the space between the nodes. This option applies to
+both $PetriNet.draw$ and $StateGraoh.draw$.
+
+$nodesize=0.5$:: the size of the nodes (places, transitions or
+states). The greater it is, the wider the nodes are. This option
+applies to both $PetriNet.draw$ and $StateGraoh.draw$.
+
+$engine$:: the rendering program to use (one of $"neato"$, $dot$,
+$"circo"$, $"twopi"$, $"fdp"$). The default for $PetriNet$ objects is
+$"neato"$, the default for $StateGraph$ objects is $dot$.
+
+$layout=False$:: for $PetriNet.draw$ only, controls whether the
+rendering program is allowed to move nodes or not. This only works for
+$"neato"$, other programs are always allowed to move nodes.
+
+$print_state=None$:: for $StateGraph.draw$ only, defines the text
+printed inside each state. If $None$, the number of the state is
+printed with the corresponding marking. Otherwise, a function should
+be provided, taking the state number as its first argument and the
+state graph as its second argument, and returning the string to print.
+
+$print_arc=None$:: for $StateGraph.draw$, similarly to $print_state$,
+defines the text printed on the arcs. The function to provide must
+take five arguments: the source state, the target state, the name of
+the transition fired, its mode (_i.e._ the substitution used), and the
+state graph. For $PetriNet.draw$, the function must take five
+arguments: the label of the arc, the place connected to it, the
+transition connected to it, a Boolean indicating whether this is an
+input (if $True$) or output arc (if $False$) and the Petri net.
+
+$print_trans=None$:: for $PetriNet.draw$ only, the function should
+take as arguments the transition and the net.
+
+$print_place=None$:: for $PetriNet.draw$ only, the function should
+take as arguments the place and the net. This corresponds to the label
+that is drawn outside of the place.
+
+$print_tokens=None$:: for $PetriNet.draw$ only, the function should
+take as arguments the multiset of tokens, the place and the net. This
+corresponds to the label that is drawn inside the place.
+
+=== Merging nodes using name-based rules
+
+The plugin $status$ extends Petri nets nodes with an attribute called
+$status$ that is composed of a _name_ and _value_. The former
+corresponds to a class of similar statuses (_e.g._, $entry$,
+$internal$, $exit$, $buffer$ or $tick$) and the latter to a particular
+subset of this class. The idea is to be able to merge nodes that have
+the same status (name and value). Each status uses its own merge rule.
+
+[NOTE]
+====================
+The principle of places status is well known in PBC and M-nets, see
+for instance the paper
+http://www.univ-paris12.fr/lacl/pommereau/publis/2003-fi.html[Asynchronous
+Box Calculus] where they are used in order to perform compositions
+of Petri net. The plugin extends this notion to transitions.
+====================
+
+For instance, the plugin defines a function $buffer(id)$ that creates
+a status $('buffer', id)$. If several places with the status $buffer$
+and the same $id$ are present in the net, they can be automatically
+merged. Concretely, let's define a net wit three buffer places:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^
+>>> import snakes.plugins
+>>> snakes.plugins.load('snakes.plugins.status', 'snakes.nets', 'nets')
+<module 'nets' from ...>
+>>> from nets import *
+>>> import snakes.plugins.status as status
+>>> n = PetriNet('N')
+>>> n.add_place(Place('p1', [1], status=status.buffer('foo')))
+>>> n.add_place(Place('p2', [2]), status=status.buffer('foo'))
+>>> n.add_place(Place('p3', [3]), status=status.buffer('bar'))
+>>> n.add_place(Place('p4', [4]))
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Notice that the status can be assigned when the place is created (as
+for $p1$) or when it is added to the net (as for $p2$ and $p3$). A
+status has not been specified for $p4$ that thus receives the empty
+status $(None, None)$.
+
+It is now possible to list all the places that have the same status:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^
+>>> n.status(status.buffer('foo'))
+('p2', 'p1')
+>>> n.status(status.buffer('bar'))
+('p3',)
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Moreover, it is possible to merge the places that have the same
+status:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^
+>>> n.status.merge(status.buffer('foo'))
+>>> n.place()
+[Place('p3', MultiSet([3]), tAll, status=Buffer('buffer','bar')),
+ Place('(p1+p2)', MultiSet([1, 2]), tAll, status=Buffer('buffer','foo')),
+ Place('p4', MultiSet([4]), tAll)]
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+The places $p1$ and $p2$ has been merged (and then removed), yielding
+a place $p1+p2$ whose marking is the sum of the marking of $p1$ and
+$p2$. This treatment of the marking is specific to buffer status,
+other status may use other methods.
+
+A Petri net is also enriched with a method in order to change the
+status of a node:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^
+>>> n.set_status('(p1+p2)', status.buffer(None))
+>>> n.place()
+[Place('p3', MultiSet([3]), tAll, status=Buffer('buffer','bar')),
+ Place('(p1+p2)', MultiSet([1, 2]), tAll, status=Buffer('buffer')),
+ Place('p4', MultiSet([4]), tAll)]
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+A buffer status with a value $None$ is particular in that it will be
+ignored by $PetriNet.status.merge$ ans thus not merged (it is a
+private buffer).
+
+One may have noticed that buffer status are actually instances of the
+class $Buffer$ that is itself a subclass of $Status$. In order to
+create a status, one just has to extend the class $Status$ and
+redefine the method $merge$ (with its arguments as below), for example
+the $Buffer$ class is defined as:
+
+//skip
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^
+class Buffer (Status) :
+    def merge (self, net, nodes, name=None) :
+        # net: the net in which the merge occurs
+        # nodes: the nodes to merge
+        # name: the name of the resulting node
+        if self._value is None :
+            return # private buffers are ignored
+        if name is None : # create a name if none has been given
+            name = "(%s)" % "+".join(sorted(nodes))
+        net.merge_places(name, nodes, status=self) # merge the places
+        for src in nodes : # remove the merged places
+            net.remove_place(src)
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+[NOTE]
+==========================
+Using this class $Buffer$, a helper function $buffer$ is defined as:
+
+//skip
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+def buffer (name) :
+    return Buffer('buffer', name)
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+==========================
+
+The plugin defines other statuses:
+
+$variable(id)$:: is similar to $buffer$ except that when places are
+merged, they must all have the same marking. So, $variable$ places are
+like variables in a program that store a single value (possibly
+structured).
+
+$tick(id)$:: is a transition status. When $tick$ transitions are
+merged, their guards are and-ed.
+
+$entry$, $internal$ and $exit$:: are the traditional place status
+allowing to define control flow operations between Petri nets in PBC
+and its successors.
+
+=== PBC/M-nets control flow operations
+
+The plugin $ops$ defines the control flow operations usually defined
+for PBC and M-nets. To do so, it relies on places status (the plugin
+$status$ is automatically loaded) and in particular on the $entry$,
+$internal$ and $exit$ statuses. Indeed, it is expected that a Petri
+net starts its execution with one token in each entry place (entry
+marking) and evolves until it reaches a marking with one token in each
+exit place (exit marking). In order to produce the expected control
+flow, the operations use combinations of the entry and exit places of
+the composed nets. All the details about these operations can be found
+in the paper
+http://www.univ-paris12.fr/lacl/pommereau/publis/2003-fi.html[Asynchronous
+Box Calculus].
+
+[NOTE]
+======================
+There are basically two approaches for such combinations. The PBC
+approach relies on cross-products of sets of places with simple types
+(low-level places). This has the advantage to be simple but may
+produce a large number of places. On the other hand, the M-nets
+approach relies on building fewer high-level places whose type are
+cross-products of the types of the combined places (this is a
+simplification). This has the advantage to produce less places than
+in PBC but their types are very complicated and the resulting transition
+rule is hard to implement (it is necessary to match tree-structured
+tokens against tree-structures annotations). Because of this
+complexity, we have chosen to implement to PBC approach which is also
+what is used in the most recent models of the family.
+======================
+
+The plugin defines four control flow operations. Let $n1$ and $n2$ be
+two nets:
+
+ * the _sequence_ $n1 & n2$ is obtained by combining the exit places
+   of $n1$ with the entry places of $n2$ so that when $n1$ reaches its
+   exit marking, it corresponds to the entry marking of $n2$. As a
+   result, $n1$ is executed first and is followed by the execution of
+   $n2$;
+
+ * the _choice_ $n1 + n2$ combines the entry places of $n1$ and $n2$
+   on the one hand, and their exit places on the other hand. As a
+   result, either $n1$ or $n2$ is executed and they have the same exit
+   marking;
+
+ * the _iteration_ $n1 * n2$ combines the entry and exit places of
+   $n1$ with the $entry$ places of $n2$. As a result, $n1$ can be
+   executed an arbitrary number of time (including zero) and is
+   followed by one execution of $n2$;
+
+ * the _parallel_ composition $n1 | n2$ does not combine any place so
+   that $n1$ and $n2$ can evolve concurrently.
+
+When two nets are combined using one of these operators, their nodes
+are automatically merged according to their status, in particular:
+buffer or variables places, and tick transitions are merged using the
+method that is defined by each status.
+
+Two operations that are not related to control flow are also defined:
+
+ * the node hiding $n1.hide(old)$ gives the empty status to all the
+   nodes in $n1$ that used to have the status $old$ before. It may be
+   called with a second argument in order to choose the new status.
+   For instance $n1.hide(buffer('foo'), buffer(None))$ makes private
+   all the buffer places with the status $('buffer', 'foo')$;
+
+ * a variant of the node hiding is $n1 / val$. Its right argument must
+   be a status value, the result is a copy of $n1$ in which all the
+   nodes with a status $(x,val)$ are given the status $(x,None)$.
+
+This has the effect to disable further merges of, _e.g._, buffer
+places if the net is later combined with another one.
+
+The plugin $posops$ is a combination of $pos$ and $ops$ that tries to
+take into account the positions of the nodes when nets are composed.
+It avoids overlapping the composed nets and tries to distribute evenly
+the combined places in order to have a acceptable result (as far as
+possible). Let's see it in action:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^
+>>> import snakes.plugins
+>>> snakes.plugins.load(['snakes.plugins.posops', 'snakes.plugins.graphviz'], 'snakes.nets', 'nets')
+<module 'nets' from ...>
+>>> from nets import *
+>>> from snakes.plugins.status import entry, internal, exit, safebuffer
+>>> n = PetriNet('basic')
+>>> n.add_place(Place('e', status=entry, pos=(0, 2)))
+>>> n.add_place(Place('x', status=exit, pos=(0, 0)))
+>>> n.add_transition(Transition('t', pos=(0, 1)))
+>>> n.add_input('e', 't', Value(dot))
+>>> n.add_output('x', 't', Value(dot))
+>>> n.add_place(Place('v', [0], status=safebuffer('var'), pos=(1,1)))
+>>> n.add_input('v', 't', Variable('x'))
+>>> n.add_output('v', 't', Expression('x+1'))
+>>> n.draw('basic.png')
+^^^^^^^^^^^^^^^^^^^^^^
+
+This basic net is as follows:
+
+image:basic.png[Basic net]
+
+It can be composed with itself in order to produce a more complex net,
+for instance:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> complex = n & (n * (n + n))
+>>> var = complex.status(safebuffer('var'))[0]
+>>> complex.place(var).pos.moveto(-1,-1)
+>>> complex.draw('complex.png', scale=60)
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+On the second line, the new name of the variable place is retrieved
+from its status. Then the place is moved in order to have a prettier
+result:
+
+image:complex.png[Complex net]
+
+=== PBC/M-nets synchronisation
+
+Another important operation featured by the models in the PBC and
+M-nets family is the synchronization. This operation is similar to the
+CCS synchronization but operates on multi-actions (_i.e_, several
+synchronizations may take place at the same transition). In PBC,
+actions have no parameters while the have in M-nets (which implies the
+unification of these parameters). With respect to CCS, the
+synchronization is here a static operation that builds all the
+possible transitions corresponding to synchronized actions. The plugin
+$synchro$ implements a generalisation of the M-nets synchronisation.
+It is generalised in that it does not impose a fixed arity associated
+to each action name. For more information about M-nets
+synchronisation, see for instance the section 4 of the paper
+http://www.univ-paris12.fr/lacl/pommereau/publis/2002-mtcs.html[Petri
+nets with causal time for system verification].
+
+Let's consider a simple example: three transitions have to
+synchronize, doing so, one transition can receive a value from each
+other transition. To do this with SNAKES, one may run the following
+code:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> import snakes.plugins
+>>> snakes.plugins.load(['snakes.plugins.synchro', 'snakes.plugins.graphviz'], 'snakes.nets', 'nets')
+<module 'nets' from ...>
+>>> from nets import *
+>>> from snakes.plugins.synchro import Action
+>>> n = PetriNet('N')
+>>> n.add_place(Place('e1', [dot], pos=(0,2)))
+>>> n.add_place(Place('e2', [dot], pos=(1,2)))
+>>> n.add_place(Place('e3', [dot], pos=(2,2)))
+>>> n.add_place(Place('x1', [], pos=(0,0)))
+>>> n.add_place(Place('x2', [], pos=(1,0)))
+>>> n.add_place(Place('x3', [], pos=(2,0)))
+>>> n.add_transition(Transition('t1', pos=(0,1),
+...                  actions=[Action('a', True, [Value(2)])]))
+>>> n.add_transition(Transition('t2', pos=(1,1),
+...                  actions=[Action('a', False, [Variable('x')]),
+...                           Action('a', False, [Variable('y')])]))
+>>> n.add_transition(Transition('t3', pos=(2,1),
+...                  actions=[Action('a', True, [Value(3)])]))
+>>> n.add_input("e1", "t1", Value(dot))
+>>> n.add_input("e2", "t2", Value(dot))
+>>> n.add_input("e3", "t3", Value(dot))
+>>> n.add_output("x1", "t1", Value(dot))
+>>> n.add_output("x2", "t2", Value(dot))
+>>> n.add_output("x3", "t3", Value(dot))
+>>> def pt (trans, net) :
+...     return "%s\\n%s" % (trans.name, str(trans.actions))
+>>> n.draw('synchro-1.png', print_trans=pt)
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The resulting picture is the following:
+
+image:synchro-1.png[Before synchronisation]
+
+Applying the synchronisation is possible by calling the method
+$synchronise$ that expects an action name as parameter. The code below
+performs the synchronisation then draws the net with a new layout in
+order to make it more readable (by default, a synchronised transition
+is place in the middle of the transition that participated to the
+synchronisation).
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> n.synchronise('a')
+>>> n.draw('synchro-2.png', print_trans=pt, layout=True, engine='circo')
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+image:synchro-2.png[After synchronisation]
+
+The result is not really readable, but let's see what happened:
+
+ - $t1$ has two ways to synchronise with $t2$, which results in
+   building two transitions, that still hold one receive action $a$;
+
+ - this is the same for $t3$ and $t2$, we have so far created 4 new
+   transitions;
+
+ - then, both $t1$ and $t3$ can synchronise with the 4 new
+   transitions, which results in 8 new transitions.
+
+So their are now 15 transitions in the net. The names of the new
+transitions correspond to how they were obtained. For instance, the
+one on the left of $x1$ (on the top) has the name
+$(t1{x->2}+t2{x->2}[a(2)]$, which means that is was obtained from the
+synchronisation of $t1$ and $t2$ for which the variable $x$ was bound
+to $2$ (the two substitutions are the way to unify the synchronised
+actions) that communicated the value $2$ on the action $a$.
+
+It may be observed that only the last 8 transitions correspond to the
+full synchronisation of $t2$ with both $t1$ and $t3$ (and each of
+these 8 transition corresponds to one way of achieving the
+synchronisation, some being equivalent). But if the net is executed,
+it is possible to fire $t1$, $t2$, $t3$ or any of the partially
+synchronised transitions. In order to force the execution of the full
+synchronisation, one can call the method $restrict$ that remove all
+the transitions that still hold an action $a$. Most of time, a
+restriction always follows a synchronisation; so, there is also a
+method $scope$ that perform both in turn.
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> n.restrict('a')
+>>> n.draw('synchro-3.png', print_trans=pt, layout=True, engine='circo')
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This results in the following picture where only 8 transitions are
+remaining:
+
+image:synchro-3.png[After restriction]
+
+On this last picture, one may notice that some transitions consume or
+produce two tokens. This is the case for instance for the top-left
+transition that results from the synchronisation of $t1$ with $t2$
+which was then synchronised again with $t1$. In a model of safe or
+colour-safe Petri nets like PBC or M-nets, this is a dead transition
+that could be removed. This can be made easily with the following
+code, resulting in the picture below:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^
+>>> for trans in n.transition() :
+...     for place, label in trans.pre.items() :
+...         if label == MultiArc([Value(dot), Value(dot)]) :
+...             n.remove_transition(trans.name)
+...             break
+>>> n.draw('synchro-4.png', print_trans=pt, layout=True, engine='circo')
+^^^^^^^^^^^^^^^^^^^^^^^
+
+image:synchro-4.png[After removing the dead transitions]
+
+It may be interesting also to remove the duplicated transitions, but
+this is beyond the scope of this tutorial.
+
+
+=== Representing infinite data domains
+
+[NOTE]
+=======================
+This section describes the implementation that corresponds to the
+paper
+http://www.univ-paris12.fr/lacl/pommereau/publis/2007-infinity.html[Efficient
+reachability graph representation of Petri nets with unbounded
+counters]. The only difference with respect to the paper is that
+SNAKES is not limited to P/T nets but happily handles high-level nets
+together with Lash data. The rest of the section uses the example
+developed in the paper, taking $omega=8$.
+=======================
+
+The first thing to do is to load the plugin $lashdata$ do that we are
+able to store data in Lash, we also import load $graphviz$ in order to
+draw the resulting graphs:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> import snakes.plugins
+>>> nets = snakes.plugins.load(["snakes.plugins.graphviz",
+...                             "snakes.plugins.lashdata"],
+...                             "snakes.nets", "nets")
+>>> from nets import *
+>>> from snakes.typing import *
+>>> from snakes.data import *
+>>> from snakes.plugins.lashdata import Data
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+$Data$ is a class that allows to store integer variables into Lash.
+This library actually store data under the form of sets of vectors of
+integers but the class $Data$ hides this under the usual concept of
+variables. When we build a Petri net, we must give a $lash$ argument
+that is one instance of $Data$. Its constructor simply takes a list of
+variables with their initial values:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> n = PetriNet("N", lash=Data(x=0))
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Then we add the places:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> n.add_place(Place("s_1", [dot], tBlackToken, pos=(0, 0)))
+>>> n.add_place(Place("s_2", [], tBlackToken, pos=(2, 0)))
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+And last the transitions. Each transition is given a $condition$ under
+the form of a linear Python expression ($or$, $not$ nor $=!$ allowed).
+An $update$ is also provided in order to modify the variables, this a
+single assignment of one variable with a linear expression (several
+assignment may be combined using $;$).
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> n.add_transition(Transition("t_3", pos=(1, -1)),
+...                  condition="x<8",
+...                  update="x=x+1")
+>>> n.add_input("s_2", "t_3", Value(dot))
+>>> n.add_output("s_1", "t_3", Value(dot))
+>>> n.add_transition(Transition("t_2", pos=(1, 1)),
+...                  condition="x>0", update="x=x-1")
+>>> n.add_input("s_1", "t_2", Value(dot))
+>>> n.add_output("s_2", "t_2", Value(dot))
+>>> n.add_transition(Transition("t_5", pos=(3, 1)),
+...                  condition="x>0", update="x=x-1")
+>>> n.add_input("s_2", "t_5", Value(dot))
+>>> n.add_output("s_2", "t_5", Value(dot))
+>>> n.add_transition(Transition("t_4", pos=(3, -1)),
+...                  condition="x<8",
+...                  update="x=x+1")
+>>> n.add_input("s_2", "t_4", Value(dot))
+>>> n.add_output("s_2", "t_4", Value(dot))
+>>> n.add_transition(Transition("t_1", pos=(-1, 0)),
+...                  condition="x<4",
+...                  update="x=x+1")
+>>> n.add_input("s_1", "t_1", Value(dot))
+>>> n.add_output("s_1", "t_1", Value(dot))
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Then, we can build four different marking graph. The first one is the
+full, usual, marking graph:
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> m = StateGraph(n)
+>>> m.build()
+>>> def ps (state, graph) :
+...     return str(state)
+>>> def pa (source, target, trans, mode, graph) :
+...     return trans
+>>> m.draw("lash-full.png", landscape=True, print_state=ps, print_arc=pa)
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+That results in the following picture:
+
+image:lash-full.png[Full marking graph]
+
+Then come the compact graphs. First we can ask SNAKES to add a meta
+transition for each detected side-loop (a transition that does not
+change the marking).
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> m = StateGraph(n, loops=True)
+>>> m.build()
+>>> m.draw("lash-loops.png", landscape=True, print_state=ps, print_arc=pa)
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+That results in:
+
+image:lash-loops.png[First compact marking graph]
+
+We can then ask to add a meta transition when cycles are detected (a
+new state that covers an existing one). We can further ask to remove
+states that are covered when cycles are detected.
+
+[python]
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+>>> m = StateGraph(n, cycles=True)
+>>> m.build()
+>>> m.draw("lash-cycles.png", landscape=True, print_state=ps, print_arc=pa)
+>>> m = StateGraph(n, remove=True)
+>>> m.build()
+>>> m.draw("lash-remove.png", landscape=True, print_state=ps, print_arc=pa)
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In this particular example, exploiting cycles results in
+link:lash-cycles.png[the same graph as above], but with the $remove$
+option, we get a more compact graph:
+
+image:lash-remove.png[The most compact graph]
+
+Finally, note that using the $cycles$ option automatically turns on
+the $loops$ option, and using the $remove$ option turns on the
+$cycles$ option (and thus also the $loops$ one).
+
+
+Exporting to PNML and other formats
+-----------------------------------
+
+To do...
+
+
+Writing a plugin
+----------------
+
+To do...

+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="744.09448819"
+   height="1052.3622047"
+   id="svg4049"
+   sodipodi:version="0.32"
+   inkscape:version="0.46"
+   sodipodi:docname="snakes-logo.svg"
+   inkscape:output_extension="org.inkscape.output.svg.inkscape">
+  <defs
+     id="defs4051">
+    <linearGradient
+       id="linearGradient4671">
+      <stop
+         style="stop-color:#ffd43b;stop-opacity:1;"
+         offset="0"
+         id="stop4673" />
+      <stop
+         style="stop-color:#ffe873;stop-opacity:1"
+         offset="1"
+         id="stop4675" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient4689">
+      <stop
+         style="stop-color:#5a9fd4;stop-opacity:1;"
+         offset="0"
+         id="stop4691" />
+      <stop
+         style="stop-color:#306998;stop-opacity:1;"
+         offset="1"
+         id="stop4693" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient3275">
+      <stop
+         style="stop-color:#5a9fd4;stop-opacity:1;"
+         offset="0"
+         id="stop3277" />
+      <stop
+         style="stop-color:#ffd43b;stop-opacity:1;"
+         offset="1"
+         id="stop3279" />
+    </linearGradient>
+    <marker
+       inkscape:stockid="Arrow2Mend"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow2Mend"
+       style="overflow:visible;">
+      <path
+         id="path4724"
+         style="font-size:12.0;fill-rule:evenodd;stroke-width:0.62500000;stroke-linejoin:round;"
+         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
+         transform="scale(0.6) rotate(180) translate(0,0)" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow1Mend"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow1Mend"
+       style="overflow:visible;">
+      <path
+         id="path4706"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none;"
+         transform="scale(0.4) rotate(180) translate(10,0)" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow2Lend"
+       style="overflow:visible;">
+      <path
+         id="path4718"
+         style="font-size:12.0;fill-rule:evenodd;stroke-width:0.62500000;stroke-linejoin:round;"
+         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
+         transform="scale(1.1) rotate(180) translate(1,0)" />
+    </marker>
+    <linearGradient
+       id="linearGradient4671-685">
+      <stop
+         id="stop3989"
+         offset="0"
+         style="stop-color:#9d9d9d;stop-opacity:1;" />
+      <stop
+         id="stop3991"
+         offset="1"
+         style="stop-color:#b9b9b9;stop-opacity:1" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient4689-776">
+      <stop
+         id="stop3983"
+         offset="0"
+         style="stop-color:#979797;stop-opacity:1;" />
+      <stop
+         id="stop3985"
+         offset="1"
+         style="stop-color:#646464;stop-opacity:1;" />
+    </linearGradient>
+    <inkscape:perspective
+       sodipodi:type="inkscape:persp3d"
+       inkscape:vp_x="0 : 526.18109 : 1"
+       inkscape:vp_y="0 : 1000 : 0"
+       inkscape:vp_z="744.09448 : 526.18109 : 1"
+       inkscape:persp3d-origin="372.04724 : 350.78739 : 1"
+       id="perspective4057" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4689-776"
+       id="linearGradient4656"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.562541,0,0,0.567972,78.198395,2.6157917)"
+       x1="26.648937"
+       y1="20.603781"
+       x2="135.66525"
+       y2="114.39767" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4671-685"
+       id="linearGradient4658"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.562541,0,0,0.567972,78.198395,2.6157917)"
+       x1="150.96111"
+       y1="192.35176"
+       x2="112.03144"
+       y2="137.27299" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4689-776"
+       id="linearGradient7767"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.562541,0,0,0.567972,78.198395,2.6157917)"
+       x1="26.648937"
+       y1="20.603781"
+       x2="135.66525"
+       y2="114.39767" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4671-685"
+       id="linearGradient7769"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.562541,0,0,0.567972,78.198395,2.6157917)"
+       x1="150.96111"
+       y1="192.35176"
+       x2="112.03144"
+       y2="137.27299" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4689-776"
+       id="linearGradient7775"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.562541,0,0,0.567972,78.198395,2.6157917)"
+       x1="26.648937"
+       y1="20.603781"
+       x2="135.66525"
+       y2="114.39767" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4671-685"
+       id="linearGradient7777"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.562541,0,0,0.567972,78.198395,2.6157917)"
+       x1="150.96111"
+       y1="192.35176"
+       x2="112.03144"
+       y2="137.27299" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4671-685"
+       id="linearGradient7780"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.2881307,0,0,0.2909125,159.73956,131.18265)"
+       x1="150.96111"
+       y1="192.35176"
+       x2="112.03144"
+       y2="137.27299" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4689-776"
+       id="linearGradient7783"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.2881307,0,0,0.2909125,159.73956,131.18265)"
+       x1="26.648937"
+       y1="20.603781"
+       x2="135.66525"
+       y2="114.39767" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient3275"
+       id="linearGradient3281"
+       x1="28.148954"
+       y1="-295.26871"
+       x2="296.6087"
+       y2="-295.26871"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0,1,-1,0,-2,0)" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4689"
+       id="linearGradient3978"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.562541,0,0,0.567972,-9.399749,-5.305317)"
+       x1="26.648937"
+       y1="20.603781"
+       x2="135.66525"
+       y2="114.39767" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient4671"
+       id="linearGradient3980"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.562541,0,0,0.567972,-9.399749,-5.305317)"
+       x1="150.96111"
+       y1="192.35176"
+       x2="112.03144"
+       y2="137.27299" />
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     gridtolerance="10000"
+     guidetolerance="10"
+     objecttolerance="10"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.98994949"
+     inkscape:cx="322.98744"
+     inkscape:cy="827.15881"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     inkscape:window-width="1440"
+     inkscape:window-height="878"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     showguides="true"
+     inkscape:guide-bbox="true" />
+  <metadata
+     id="metadata4054">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1">
+    <g
+       id="g4096">
+      <path
+         id="rect4073"
+         d="M 53.21875 28.4375 L 53.21875 296.3125 L 131.5625 296.3125 L 131.5625 254.96875 C 127.40006 255.10395 123.06445 255.05613 122.53125 254.25 C 121.71364 253.01388 127.57742 239.04558 128.15625 237.59375 C 128.35581 237.09321 129.06594 235.3019 129.9375 233.09375 C 86.808636 220.67326 55.21875 180.88942 55.21875 133.78125 C 55.218752 76.74507 101.52631 30.4375 158.5625 30.4375 C 215.59868 30.4375 261.875 76.745063 261.875 133.78125 C 261.87501 181.48268 229.49465 221.65529 185.53125 233.53125 L 185.53125 277.28125 C 189.44172 277.51593 194.36954 277.98504 194.625 278.96875 C 195.04299 280.57833 189.62262 291.82522 187.4375 296.3125 L 321.0625 296.3125 L 321.0625 28.4375 L 53.21875 28.4375 z M 173.125 236.0625 C 168.3641 236.73542 163.50817 237.09375 158.5625 237.09375 C 154.43899 237.09375 150.37275 236.84547 146.375 236.375 C 148.86246 241.49268 153.47528 251.18709 153.09375 252.65625 C 152.83829 253.63995 147.91047 254.10906 144 254.34375 L 144 296.3125 L 170.59375 296.3125 C 170.24478 295.4181 169.79764 294.30751 169.6875 294.03125 C 169.10867 292.57942 163.2449 278.61112 164.0625 277.375 C 164.59703 276.56685 168.95311 276.51976 173.125 276.65625 L 173.125 236.0625 z "
+         style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:3;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-opacity:1" />
+      <path
+         id="text4087"
+         d="M 284.16123,61.264954 C 279.36122,61.264918 275.47323,59.896919 272.49723,57.160954 C 269.52123,54.424924 268.00923,50.680928 267.96123,45.928954 C 267.91323,41.272938 269.49723,37.360941 272.71323,34.192954 C 275.68923,31.264948 279.57722,29.416949 284.37723,28.648954 L 288.55323,40.600954 C 285.57722,40.600938 283.58522,40.792938 282.57723,41.176954 C 280.70522,41.848937 279.76922,43.408935 279.76923,45.856954 C 279.81722,48.64093 280.87322,50.032929 282.93723,50.032954 C 284.95322,50.032929 286.89722,48.40093 288.76923,45.136954 C 291.93721,39.616939 293.73721,36.592942 294.16923,36.064954 C 296.80921,32.800946 300.0972,31.168948 304.03323,31.168954 C 308.06519,31.168948 311.40119,32.608946 314.04123,35.488954 C 316.63319,38.224941 317.92918,41.632937 317.92923,45.712954 C 317.92918,49.552929 316.60919,52.744926 313.96923,55.288954 C 312.14519,57.064922 309.09719,58.91292 304.82523,60.832954 L 300.50523,50.104954 C 302.5692,49.09693 303.7212,48.54493 303.96123,48.448954 C 305.4492,47.536931 306.1932,46.600932 306.19323,45.640954 C 306.1932,44.872934 305.9772,44.176935 305.54523,43.552954 C 305.1132,42.928936 304.5132,42.592936 303.74523,42.544954 C 303.6972,42.640936 302.0412,45.328934 298.77723,50.608954 C 296.71321,53.968925 294.76921,56.440922 292.94523,58.024954 C 290.40121,60.184919 287.52121,61.264918 284.30523,61.264954 L 284.16123,61.264954 M 284.23323,60.904954 C 288.07321,60.904918 291.19321,59.680919 293.59323,57.232954 C 294.98521,55.840923 296.68921,53.200926 298.70523,49.312954 C 300.5772,45.760933 302.2572,43.384935 303.74523,42.184954 L 303.88923,42.184954 C 304.7532,42.184937 305.4012,42.520936 305.83323,43.192954 C 306.3132,43.912935 306.5532,44.704934 306.55323,45.568954 C 306.5052,47.056932 304.6572,48.61693 301.00923,50.248954 L 305.04123,60.328954 C 309.12119,58.45692 312.04919,56.656922 313.82523,54.928954 C 316.36919,52.432926 317.64118,49.33693 317.64123,45.640954 C 317.64118,41.656937 316.36919,38.296941 313.82523,35.560954 C 311.32919,32.824946 308.08919,31.456947 304.10523,31.456954 C 300.2652,31.456947 297.0492,33.088946 294.45723,36.352954 C 294.21721,36.640942 292.41721,39.688939 289.05723,45.496954 C 287.18521,48.76093 285.19322,50.392928 283.08123,50.392954 C 281.88122,50.392928 280.96922,49.936929 280.34523,49.024954 C 279.72122,48.160931 279.40922,47.104932 279.40923,45.856954 C 279.40922,43.408935 280.32122,41.776937 282.14523,40.960954 C 283.24922,40.480938 285.26522,40.240939 288.19323,40.240954 L 284.16123,29.080954 C 279.60122,29.848949 275.88123,31.672947 273.00123,34.552954 C 269.92923,37.624941 268.39323,41.392937 268.39323,45.856954 C 268.39323,50.560928 269.83323,54.232925 272.71323,56.872954 C 275.64123,59.560919 279.48122,60.904918 284.23323,60.904954 M 305.47323,59.392954 L 304.53723,57.160954 L 306.33723,58.960954 L 305.47323,59.392954 M 308.85723,57.664954 C 304.2492,53.056926 301.9452,50.728928 301.94523,50.680954 C 302.9532,50.200929 303.8652,49.696929 304.68123,49.168954 L 311.52123,55.936954 C 310.60919,56.608922 309.72119,57.184922 308.85723,57.664954 M 313.46523,54.280954 L 306.62523,47.512954 C 307.00919,46.936932 307.22519,46.312933 307.27323,45.640954 C 307.27319,45.016934 307.05719,44.176935 306.62523,43.120954 L 315.33723,51.832954 C 314.90519,52.648926 314.28119,53.464925 313.46523,54.280954 M 316.34523,49.096954 L 300.14523,32.824954 C 301.4412,32.440946 302.6892,32.248947 303.88923,32.248954 L 316.70523,45.136954 L 316.70523,45.712954 C 316.70519,46.768932 316.58519,47.896931 316.34523,49.096954 M 315.91323,40.528954 L 308.42523,32.968954 C 311.83319,34.408944 314.32919,36.928942 315.91323,40.528954 M 292.00923,57.376954 L 285.31323,50.752954 C 286.03322,50.320929 286.82522,49.624929 287.68923,48.664954 L 294.31323,55.216954 C 293.49721,56.128923 292.72921,56.848922 292.00923,57.376954 M 295.96923,53.200954 L 289.20123,46.432954 C 289.58521,45.856933 290.16121,44.944934 290.92923,43.696954 L 297.76923,50.608954 C 297.0012,51.760927 296.40121,52.624926 295.96923,53.200954 M 299.06523,48.232954 L 292.22523,41.320954 L 293.73723,38.512954 L 300.64923,45.424954 L 299.06523,48.232954 M 302.08923,43.048954 L 295.32123,36.352954 C 296.13721,35.440943 296.90521,34.720944 297.62523,34.192954 L 305.40123,42.040954 C 304.6332,41.752937 304.0572,41.608937 303.67323,41.608954 C 303.2412,41.608937 302.7132,42.088937 302.08923,43.048954 M 286.60923,60.112954 L 269.32923,42.832954 C 269.52123,41.728937 269.88123,40.624938 270.40923,39.520954 L 278.90523,48.016954 C 279.24122,49.600929 280.20122,50.560928 281.78523,50.896954 L 289.77723,58.888954 C 288.67321,59.416919 287.61721,59.824919 286.60923,60.112954 M 282.93723,60.328954 C 279.76922,60.040919 277.96922,59.680919 277.53723,59.248954 L 269.90523,51.616954 C 269.56923,51.280928 269.25723,49.528929 268.96923,46.360954 L 282.93723,60.328954 M 282.86523,40.096954 L 275.88123,33.112954 C 276.50523,32.728946 277.44122,32.200947 278.68923,31.528954 L 286.75323,39.664954 C 285.21722,39.664939 283.92122,39.808939 282.86523,40.096954 M 278.76123,44.200954 L 271.70523,37.144954 C 272.18523,36.424942 272.85723,35.632943 273.72123,34.768954 L 280.27323,41.392954 C 279.55322,42.016937 279.04922,42.952936 278.76123,44.200954 M 285.02523,34.192954 L 281.35323,30.520954 C 282.31322,30.232949 283.05722,30.064949 283.58523,30.016954 L 285.02523,34.192954 M 305.61723,58.888954 L 305.76123,58.888954 L 305.54523,58.672954 L 305.61723,58.888954 M 308.85723,57.304954 C 309.81719,56.728922 310.51319,56.272923 310.94523,55.936954 L 304.60923,49.600954 C 304.1292,49.888929 303.4092,50.272929 302.44923,50.752954 L 308.92923,57.232954 L 308.85723,57.304954 M 313.39323,53.704954 C 313.92119,53.224926 314.42519,52.624926 314.90523,51.904954 L 307.48923,44.416954 C 307.58519,44.992934 307.60919,45.400933 307.56123,45.640954 C 307.60919,46.264933 307.46519,46.864932 307.12923,47.440954 L 313.39323,53.704954 M 316.20123,48.376954 C 316.34519,47.512931 316.41719,46.648932 316.41723,45.784954 L 316.34523,45.280954 L 303.74523,32.608954 C 302.7372,32.608946 301.7532,32.752946 300.79323,33.040954 L 316.20123,48.376954 M 314.61723,38.656954 C 313.46519,36.688942 311.95319,35.176944 310.08123,34.120954 L 314.61723,38.656954 M 292.08123,56.944954 C 292.46521,56.608922 293.04121,56.056923 293.80923,55.288954 L 287.68923,49.168954 C 287.06521,49.840929 286.48922,50.368928 285.96123,50.752954 L 292.08123,56.944954 M 295.89723,52.552954 C 296.37721,51.976927 296.83321,51.328928 297.26523,50.608954 L 291.00123,44.272954 L 289.70523,46.432954 L 295.89723,52.552954 M 298.99323,47.656954 L 300.21723,45.496954 L 293.88123,39.088954 L 292.58523,41.248954 L 298.99323,47.656954 M 302.01723,42.472954 C 302.6892,41.560937 303.4092,41.176938 304.17723,41.320954 L 297.55323,34.624954 C 296.9772,35.056944 296.40121,35.608943 295.82523,36.280954 L 302.01723,42.472954 M 286.68123,59.680954 C 287.59321,59.440919 288.43321,59.15292 289.20123,58.816954 L 281.64123,51.256954 C 279.91322,50.824928 278.88122,49.792929 278.54523,48.160954 L 270.55323,40.096954 C 270.16923,41.056938 269.90523,41.944937 269.76123,42.760954 L 286.68123,59.680954 M 282.07323,59.896954 L 269.47323,47.296954 C 269.80923,49.840929 270.07323,51.208928 270.26523,51.400954 L 277.82523,58.888954 C 278.20922,59.27292 279.62522,59.608919 282.07323,59.896954 M 283.00923,39.664954 C 283.68122,39.520939 284.66522,39.400939 285.96123,39.304954 L 278.61723,32.032954 C 277.65722,32.512946 276.93722,32.896946 276.45723,33.184954 L 283.00923,39.664954 M 278.54523,43.480954 C 278.73722,42.712936 279.14522,41.992937 279.76923,41.320954 L 273.72123,35.272954 C 273.19323,35.848943 272.66523,36.448942 272.13723,37.072954 L 278.54523,43.480954 M 284.16123,32.824954 L 283.36923,30.448954 L 282.07323,30.664954 L 284.16123,32.824954 M 268.17723,113.0622 L 268.10523,105.5022 L 295.75323,82.318204 L 268.03323,82.318204 L 267.96123,70.150204 L 318.21723,70.078204 L 318.28923,79.870204 L 292.44123,101.1102 L 318.43323,100.9662 L 318.50523,113.0622 L 268.17723,113.0622 M 268.60923,112.7022 L 318.14523,112.7022 L 318.21723,101.3262 L 291.50523,101.4702 L 317.92923,79.726204 L 318.00123,70.438204 L 268.46523,70.510204 L 268.39323,81.958204 L 296.83323,81.958204 L 268.53723,105.6462 L 268.60923,112.7022 M 317.49723,110.7582 L 308.85723,102.1182 L 313.60923,102.1182 L 317.42523,105.9342 L 317.49723,110.7582 M 310.51323,111.9822 L 300.64923,102.1182 L 305.40123,102.1182 L 315.26523,111.9822 L 310.51323,111.9822 M 302.37723,111.9822 L 292.58523,102.1902 L 297.33723,102.1902 L 307.12923,111.9822 L 302.37723,111.9822 M 294.24123,111.9822 L 279.55323,97.294204 L 282.14523,95.134204 L 298.99323,111.9822 L 294.24123,111.9822 M 286.10523,111.9822 L 275.08923,101.0382 L 277.68123,98.878204 L 290.85723,111.9822 L 286.10523,111.9822 M 317.20923,77.926204 L 310.44123,71.158204 L 315.19323,71.158204 L 317.13723,73.174204 L 317.20923,77.926204 M 300.00123,93.406204 L 292.80123,86.206204 L 295.39323,83.974204 L 302.66523,91.246204 L 300.00123,93.406204 M 313.39323,82.390204 L 302.23323,71.230204 L 306.98523,71.158204 L 316.05723,80.230204 L 313.39323,82.390204 M 295.53723,97.078204 L 288.33723,89.878204 L 290.92923,87.718204 L 298.20123,94.918204 L 295.53723,97.078204 M 291.07323,100.7502 L 283.87323,93.622204 L 286.53723,91.462204 L 293.66523,98.590204 L 291.07323,100.7502 M 277.82523,111.9822 L 270.62523,104.7822 L 273.21723,102.5502 L 282.64923,111.9822 L 277.82523,111.9822 M 308.92923,86.062204 L 294.09723,71.230204 L 298.84923,71.230204 L 311.59323,83.902204 L 308.92923,86.062204 M 269.68923,111.9822 L 269.18523,111.4062 L 269.11323,106.6542 L 274.51323,111.9822 L 269.68923,111.9822 M 304.46523,89.734204 L 297.19323,82.462204 L 298.63323,81.238204 L 295.96923,81.238204 L 285.96123,71.230204 L 290.71323,71.230204 L 307.12923,87.574204 L 304.46523,89.734204 M 287.83323,81.238204 L 277.82523,71.230204 L 282.57723,71.230204 L 292.65723,81.238204 L 287.83323,81.238204 M 279.69723,81.238204 L 269.68923,71.230204 L 274.44123,71.230204 L 284.44923,81.238204 L 279.69723,81.238204 M 271.56123,81.238204 L 269.04123,78.718204 L 268.96923,73.894204 L 276.31323,81.238204 L 271.56123,81.238204 M 317.06523,109.8942 L 317.13723,106.0782 L 313.46523,102.4782 L 309.72123,102.4782 L 317.06523,109.8942 M 310.65723,111.6222 L 314.40123,111.6222 L 305.25723,102.4782 L 301.51323,102.4782 L 310.65723,111.6222 M 302.52123,111.6222 L 306.26523,111.6222 L 297.19323,102.5502 L 293.44923,102.5502 L 302.52123,111.6222 M 294.38523,111.6222 L 298.12923,111.6222 L 289.05723,102.5502 L 288.40923,102.5502 L 288.76923,102.2622 L 282.14523,95.638204 L 280.05723,97.366204 L 294.38523,111.6222 M 316.77723,77.062204 L 316.84923,73.318204 L 315.04923,71.518204 L 311.30523,71.518204 L 316.77723,77.062204 M 286.24923,111.6222 L 289.99323,111.6222 L 277.68123,99.310204 L 275.66523,101.0382 L 286.24923,111.6222 M 300.00123,92.974204 L 302.08923,91.246204 L 295.32123,84.478204 L 293.30523,86.206204 L 300.00123,92.974204 M 313.46523,81.886204 L 315.48123,80.230204 L 306.84123,71.518204 L 303.09723,71.590204 L 313.46523,81.886204 M 295.53723,96.646204 L 297.62523,94.918204 L 290.92923,88.222204 L 288.84123,89.950204 L 295.53723,96.646204 M 291.07323,100.3182 L 293.16123,98.590204 L 286.46523,91.894204 L 284.44923,93.622204 L 291.07323,100.3182 M 277.96923,111.6222 L 281.78523,111.6222 L 273.21723,103.0542 L 271.12923,104.7822 L 277.96923,111.6222 M 309.00123,85.558204 L 311.01723,83.902204 L 298.70523,71.590204 L 294.96123,71.590204 L 309.00123,85.558204 M 269.83323,111.6222 L 273.64923,111.6222 L 269.54523,107.5182 L 269.47323,111.2622 L 269.83323,111.6222 M 304.53723,89.230204 L 306.55323,87.574204 L 290.56923,71.590204 L 286.82523,71.590204 L 296.11323,80.878204 L 299.64123,80.878204 L 297.69723,82.462204 L 304.53723,89.230204 M 287.97723,80.878204 L 291.79323,80.878204 L 282.43323,71.590204 L 278.68923,71.590204 L 287.97723,80.878204 M 279.84123,80.878204 L 283.58523,80.878204 L 274.29723,71.590204 L 270.55323,71.590204 L 279.84123,80.878204 M 271.70523,80.878204 L 275.44923,80.878204 L 269.40123,74.830204 L 269.32923,78.574204 L 271.70523,80.878204 M 267.96123,168.68333 L 268.03323,168.68333 L 267.96123,155.79533 L 280.92123,151.33133 L 280.99323,138.87533 L 268.03323,134.26733 L 267.96123,121.45133 L 318.14523,139.95533 L 318.21723,150.03533 L 268.03323,168.68333 L 268.03323,168.68333 L 267.96123,168.68333 M 268.46523,168.17933 L 317.85723,149.74733 L 317.92923,140.24333 L 268.46523,121.95533 L 268.39323,133.97933 L 281.35323,138.58733 L 281.42523,151.61933 L 268.39323,156.08333 L 268.46523,168.17933 M 317.20923,143.91533 L 312.16923,138.87533 L 317.13723,140.74733 L 317.20923,143.91533 M 303.16923,154.42733 L 295.60923,146.86733 L 298.77723,145.64333 L 306.40923,153.27533 L 303.16923,154.42733 M 315.04923,150.03533 L 299.13723,134.12333 C 303.5052,135.75531 305.8332,136.57131 306.12123,136.57133 C 307.36919,137.53131 309.21719,139.30731 311.66523,141.89933 C 313.48919,143.8193 315.28919,145.7393 317.06523,147.65933 L 317.13723,149.24333 L 315.04923,150.03533 M 293.01723,147.08333 L 293.08923,147.08333 L 293.01723,143.05133 L 298.34523,145.06733 L 293.08923,147.08333 L 293.08923,147.08333 L 293.01723,147.08333 M 291.21723,158.81933 L 282.00123,149.60333 L 281.92923,145.21133 L 294.45723,157.66733 L 291.21723,158.81933 M 309.07323,152.26733 L 286.10523,129.29933 C 288.40921,130.11532 290.76121,130.97932 293.16123,131.89133 C 295.75321,134.05131 298.9932,137.17131 302.88123,141.25133 C 309.02519,147.6833 312.14519,150.9473 312.24123,151.04333 L 309.07323,152.26733 M 285.31323,161.05133 L 277.82523,153.56333 L 281.06523,152.41133 L 288.48123,159.89933 L 285.31323,161.05133 M 279.33723,163.28333 L 271.70523,155.65133 L 275.01723,154.49933 L 282.57723,162.05933 L 279.33723,163.28333 M 268.96923,167.09933 L 269.04123,167.09933 L 268.96923,164.79533 L 270.69723,166.52333 L 269.04123,167.09933 L 269.04123,167.09933 L 268.96923,167.09933 M 273.43323,165.44333 L 269.04123,161.05133 L 268.96923,156.65933 L 276.60123,164.29133 L 273.43323,165.44333 M 297.19323,156.65933 L 281.92923,141.39533 L 282.00123,138.15533 C 280.12922,138.05931 277.72922,136.78731 274.80123,134.33933 C 272.40123,132.37131 270.48123,130.40332 269.04123,128.43533 L 268.96923,124.11533 L 292.29723,147.37133 L 292.22523,148.09133 L 292.80123,147.87533 L 300.36123,155.43533 L 297.19323,156.65933 M 296.76123,143.69933 L 292.22523,141.97133 L 292.29723,143.55533 L 273.21723,124.47533 C 275.52123,125.33932 277.84922,126.22732 280.20123,127.13933 C 282.26522,128.81932 285.07322,131.50732 288.62523,135.20333 C 291.31321,138.03531 294.02521,140.86731 296.76123,143.69933 M 270.98523,134.26733 L 269.04123,133.54733 L 268.96923,132.32333 L 270.98523,134.26733 M 316.77723,143.05133 L 316.84923,140.96333 L 313.53723,139.81133 L 316.77723,143.05133 M 303.31323,153.99533 L 305.76123,153.13133 L 298.70523,146.07533 L 296.25723,147.01133 L 303.31323,153.99533 M 315.19323,149.60333 L 316.70523,149.02733 L 316.77723,147.80333 C 314.23319,145.0673 310.60919,141.44331 305.90523,136.93133 C 305.7612,136.78731 303.9852,136.13931 300.57723,134.98733 L 315.19323,149.60333 M 309.14523,151.83533 L 311.59323,150.89933 L 292.87323,132.17933 C 292.72921,132.03532 290.95321,131.38732 287.54523,130.23533 L 309.14523,151.83533 M 293.44923,146.50733 L 297.33723,145.06733 L 293.37723,143.55533 L 293.44923,146.50733 M 291.36123,158.45933 L 293.80923,157.52333 L 282.36123,146.07533 L 282.28923,149.38733 L 291.36123,158.45933 M 285.38523,160.61933 L 287.83323,159.75533 L 280.99323,152.84333 L 278.47323,153.70733 L 285.38523,160.61933 M 297.26523,156.22733 L 299.71323,155.29133 L 292.72923,148.30733 L 291.86523,148.59533 L 291.93723,147.51533 L 282.36123,137.93933 L 282.28923,141.25133 L 297.26523,156.22733 M 279.48123,162.85133 L 281.92923,161.91533 L 274.87323,154.93133 L 272.42523,155.79533 L 279.48123,162.85133 M 269.47323,166.59533 L 270.12123,166.37933 L 269.40123,165.65933 L 269.47323,166.59533 M 273.50523,165.08333 L 275.95323,164.14733 L 269.40123,157.52333 L 269.32923,160.90733 L 273.50523,165.08333 M 295.17723,142.69133 C 291.81721,139.04331 286.75322,133.93131 279.98523,127.35533 C 279.79322,127.16332 278.01722,126.51532 274.65723,125.41133 L 291.93723,142.69133 L 291.86523,141.46733 L 295.17723,142.69133 M 282.21723,137.79533 L 269.40123,124.97933 L 269.32923,128.36333 C 271.20123,130.37932 273.76923,132.89931 277.03323,135.92333 C 277.17722,136.06731 278.90522,136.69131 282.21723,137.79533 M 269.61723,133.40333 L 269.40123,133.18733 L 269.32923,133.33133 L 269.61723,133.40333 M 318.21723,218.70983 L 295.10523,193.79783 L 268.03323,218.34983 L 267.96123,201.78983 L 282.21723,189.04583 L 268.03323,189.04583 L 267.96123,176.08583 L 318.14523,176.08583 L 318.21723,189.04583 L 307.05723,189.04583 L 318.14523,201.14183 L 318.21723,218.70983 M 317.78523,217.77383 L 317.85723,201.28583 L 306.19323,188.68583 L 317.78523,188.68583 L 317.85723,176.44583 L 268.39323,176.44583 L 268.32123,188.68583 L 283.15323,188.68583 L 268.39323,202.00583 L 268.32123,217.48583 L 295.10523,193.29383 L 317.78523,217.77383 M 316.99323,180.90983 L 316.99323,180.83783 L 313.24923,177.16583 L 317.06523,177.16583 L 316.99323,180.83783 L 317.06523,180.90983 L 316.99323,180.90983 M 316.99323,205.38983 L 288.76923,177.16583 L 293.16123,177.09383 C 299.7852,183.62182 303.8412,187.62981 305.32923,189.11783 C 309.88919,193.72581 313.75319,197.8778 316.92123,201.57383 L 316.99323,205.38983 M 316.92123,213.52583 L 280.48923,177.16583 L 284.88123,177.16583 L 316.84923,209.13383 L 316.92123,213.52583 M 315.69723,187.96583 L 304.89723,177.16583 L 309.28923,177.16583 L 316.77723,184.72583 L 316.84923,187.96583 L 315.69723,187.96583 M 307.56123,187.96583 L 296.76123,177.16583 L 301.15323,177.16583 L 311.95323,187.96583 L 307.56123,187.96583 M 269.61723,215.18183 L 268.82523,214.38983 L 268.75323,209.99783 L 271.92123,213.09383 L 269.61723,215.18183 M 286.68123,199.70183 L 279.62523,192.57383 L 281.92923,190.48583 L 288.98523,197.61383 L 286.68123,199.70183 M 273.86523,211.29383 L 268.82523,206.18183 L 268.75323,202.29383 L 269.04123,202.07783 L 276.16923,209.20583 L 273.86523,211.29383 M 282.43323,203.51783 L 275.30523,196.46183 L 277.60923,194.37383 L 284.73723,201.50183 L 282.43323,203.51783 M 278.11323,207.40583 L 270.98523,200.27783 L 273.36123,198.26183 L 280.41723,205.31783 L 278.11323,207.40583 M 291.00123,195.81383 L 283.87323,188.75783 L 284.73723,187.96583 L 283.08123,187.96583 L 272.28123,177.16583 L 276.67323,177.16583 L 293.23323,193.72583 L 291.00123,195.81383 M 274.94523,187.96583 L 268.82523,181.77383 L 268.75323,177.38183 L 279.33723,187.96583 L 274.94523,187.96583 M 268.82523,187.96583 L 268.75323,185.51783 L 271.20123,187.96583 L 268.82523,187.96583 M 316.63323,180.04583 L 316.70523,177.52583 L 314.11323,177.52583 L 316.63323,180.04583 M 316.56123,204.52583 L 316.63323,201.71783 C 311.97719,196.29381 304.0812,188.22981 292.94523,177.52583 L 289.63323,177.52583 L 316.56123,204.52583 M 316.48923,212.66183 L 316.56123,209.27783 L 284.73723,177.52583 L 281.42523,177.52583 L 316.48923,212.66183 M 315.84123,187.60583 L 316.41723,187.60583 L 316.48923,184.86983 L 309.14523,177.52583 L 305.76123,177.52583 L 315.84123,187.60583 M 307.70523,187.60583 L 311.08923,187.60583 L 301.00923,177.52583 L 297.62523,177.52583 L 307.70523,187.60583 M 269.61723,214.67783 L 271.34523,213.09383 L 269.18523,210.86183 L 269.11323,214.24583 L 269.61723,214.67783 M 286.68123,199.19783 L 288.48123,197.61383 L 281.92923,190.98983 L 280.12923,192.57383 L 286.68123,199.19783 M 273.86523,210.78983 L 275.66523,209.20583 L 269.18523,202.72583 L 269.11323,206.03783 L 273.86523,210.78983 M 282.43323,203.08583 L 284.16123,201.42983 L 277.60923,194.87783 L 275.80923,196.46183 L 282.43323,203.08583 M 278.18523,206.90183 L 279.91323,205.31783 L 273.28923,198.69383 L 271.56123,200.34983 L 278.18523,206.90183 M 291.00123,195.30983 L 292.72923,193.72583 L 276.52923,177.52583 L 273.14523,177.52583 L 283.22523,187.60583 L 285.74523,187.60583 L 284.44923,188.75783 L 291.00123,195.30983 M 269.25723,187.60583 L 270.40923,187.60583 L 269.18523,186.38183 L 269.25723,187.60583 M 275.08923,187.60583 L 278.47323,187.60583 L 269.18523,178.24583 L 269.11323,181.62983 L 275.08923,187.60583 M 268.03323,258.31433 L 267.96123,224.47433 L 318.50523,224.47433 L 318.57723,258.31433 L 306.62523,258.31433 L 306.69723,236.57033 L 297.91323,236.57033 L 297.98523,253.99433 L 286.03323,253.99433 L 286.10523,236.57033 L 279.84123,236.49833 L 279.91323,258.31433 L 268.03323,258.31433 M 268.46523,257.95433 L 279.62523,257.95433 L 279.55323,236.13833 L 286.53723,236.21033 L 286.46523,253.63433 L 297.69723,253.63433 L 297.62523,236.21033 L 307.12923,236.21033 L 307.05723,257.95433 L 318.21723,257.95433 L 318.28923,224.83433 L 268.39323,224.83433 L 268.39323,225.55433 L 268.96923,225.55433 L 278.83323,235.41833 L 278.04123,235.41833 L 278.11323,239.01833 L 268.39323,229.29833 L 268.39323,233.04233 L 278.11323,242.76233 L 278.18523,247.15433 L 268.46523,237.43433 L 268.39323,234.26633 L 268.46523,257.95433 M 277.75323,246.29033 L 277.82523,242.90633 L 268.82523,233.90633 L 268.75323,237.29033 L 277.75323,246.29033 M 277.75323,238.15433 L 277.68123,235.05833 L 277.96923,235.05833 L 268.75323,225.91433 L 268.68123,229.15433 L 277.75323,238.15433 M 313.39323,257.23433 L 307.84923,251.69033 L 307.77723,247.29833 L 317.71323,257.23433 L 313.39323,257.23433 M 307.84923,257.23433 L 307.77723,255.43433 L 309.57723,257.23433 L 307.84923,257.23433 M 317.49723,253.27433 L 307.77723,243.55433 L 307.70523,239.16233 L 317.42523,248.88233 L 317.49723,253.27433 M 317.42523,228.79433 L 314.11323,225.55433 L 317.35323,225.55433 L 317.42523,228.79433 M 317.35323,236.93033 L 305.90523,225.55433 L 310.29723,225.55433 L 317.28123,232.53833 L 317.35323,236.93033 M 317.20923,245.06633 C 315.09719,242.95431 311.92919,239.76231 307.70523,235.49033 L 307.63323,235.49033 L 297.69723,225.55433 L 302.08923,225.55433 L 317.20923,240.74633 L 317.28123,245.06633 L 317.20923,245.06633 M 292.29723,252.91433 L 286.82523,247.37033 L 286.75323,242.97833 L 296.68923,252.91433 L 292.29723,252.91433 M 286.82523,252.91433 L 286.75323,251.11433 L 288.55323,252.91433 L 286.82523,252.91433 M 299.28123,235.49033 L 289.34523,225.55433 L 293.66523,225.55433 L 303.60123,235.49033 L 299.28123,235.49033 M 272.13723,257.23433 L 268.68123,253.70633 L 268.60923,249.38633 L 276.52923,257.23433 L 272.13723,257.23433 M 296.47323,248.95433 L 286.68123,239.23433 L 286.75323,235.49033 L 282.93723,235.41833 L 273.00123,225.55433 L 277.39323,225.55433 L 296.40123,244.56233 L 296.47323,248.95433 M 296.40123,240.81833 L 281.06523,225.55433 L 285.45723,225.55433 L 296.32923,236.42633 L 296.40123,240.81833 M 278.18523,255.29033 L 278.18523,255.21833 L 268.53723,245.57033 L 268.46523,241.17833 L 278.25723,250.89833 L 278.18523,255.21833 L 278.25723,255.29033 L 278.18523,255.29033 M 313.53723,256.87433 L 316.84923,256.87433 L 308.20923,248.16233 L 308.13723,251.54633 L 313.53723,256.87433 M 308.20923,256.87433 L 308.71323,256.87433 L 308.13723,256.29833 L 308.20923,256.87433 M 317.06523,252.33833 L 317.13723,249.02633 L 308.13723,240.02633 L 308.06523,243.33833 L 317.06523,252.33833 M 316.99323,227.93033 L 317.06523,225.91433 L 314.97723,225.91433 L 316.99323,227.93033 M 316.92123,236.06633 L 316.99323,232.75433 L 310.15323,225.91433 L 306.76923,225.91433 L 316.92123,236.06633 M 316.77723,244.20233 L 316.84923,240.89033 L 301.87323,225.91433 L 298.48923,225.91433 L 316.77723,244.20233 M 292.44123,252.55433 L 295.82523,252.55433 L 287.18523,243.84233 L 287.11323,247.22633 L 292.44123,252.55433 M 287.18523,252.55433 L 287.68923,252.55433 L 287.11323,251.97833 L 287.18523,252.55433 M 296.04123,248.09033 L 296.11323,244.70633 L 287.11323,235.70633 L 287.04123,239.09033 L 296.04123,248.09033 M 299.42523,235.13033 L 302.73723,235.13033 L 293.52123,225.91433 L 290.20923,225.91433 L 299.42523,235.13033 M 272.28123,256.87433 L 275.66523,256.87433 L 269.04123,250.25033 L 268.96923,253.56233 L 272.28123,256.87433 M 295.96923,239.95433 L 296.04123,236.57033 L 285.31323,225.91433 L 282.00123,225.91433 L 295.96923,239.95433 M 277.82523,254.42633 L 277.89723,251.04233 L 268.89723,242.04233 L 268.82523,245.42633 L 277.82523,254.42633 M 286.39323,235.13033 L 277.17723,225.91433 L 273.79323,225.91433 L 283.00923,235.05833 L 286.39323,235.13033 M 284.16123,296.1087 C 279.36122,296.10867 275.47323,294.74067 272.49723,292.0047 C 269.52123,289.26867 268.00923,285.52468 267.96123,280.7727 C 267.91323,276.11669 269.49723,272.20469 272.71323,269.0367 C 275.68923,266.1087 279.57722,264.2607 284.37723,263.4927 L 288.55323,275.4447 C 285.57722,275.44469 283.58522,275.63669 282.57723,276.0207 C 280.70522,276.69269 279.76922,278.25269 279.76923,280.7007 C 279.81722,283.48468 280.87322,284.87668 282.93723,284.8767 C 284.95322,284.87668 286.89722,283.24468 288.76923,279.9807 C 291.93721,274.46069 293.73721,271.43669 294.16923,270.9087 C 296.80921,267.6447 300.0972,266.0127 304.03323,266.0127 C 308.06519,266.0127 311.40119,267.4527 314.04123,270.3327 C 316.63319,273.06869 317.92918,276.47669 317.92923,280.5567 C 317.92918,284.39668 316.60919,287.58868 313.96923,290.1327 C 312.14519,291.90867 309.09719,293.75667 304.82523,295.6767 L 300.50523,284.9487 C 302.5692,283.94068 303.7212,283.38868 303.96123,283.2927 C 305.4492,282.38068 306.1932,281.44468 306.19323,280.4847 C 306.1932,279.71668 305.9772,279.02068 305.54523,278.3967 C 305.1132,277.77269 304.5132,277.43669 303.74523,277.3887 C 303.6972,277.48469 302.0412,280.17268 298.77723,285.4527 C 296.71321,288.81267 294.76921,291.28467 292.94523,292.8687 C 290.40121,295.02867 287.52121,296.10867 284.30523,296.1087 L 284.16123,296.1087 M 284.23323,295.7487 C 288.07321,295.74867 291.19321,294.52467 293.59323,292.0767 C 294.98521,290.68467 296.68921,288.04468 298.70523,284.1567 C 300.5772,280.60468 302.2572,278.22869 303.74523,277.0287 L 303.88923,277.0287 C 304.7532,277.02869 305.4012,277.36469 305.83323,278.0367 C 306.3132,278.75668 306.5532,279.54868 306.55323,280.4127 C 306.5052,281.90068 304.6572,283.46068 301.00923,285.0927 L 305.04123,295.1727 C 309.12119,293.30067 312.04919,291.50067 313.82523,289.7727 C 316.36919,287.27668 317.64118,284.18068 317.64123,280.4847 C 317.64118,276.50069 316.36919,273.14069 313.82523,270.4047 C 311.32919,267.6687 308.08919,266.3007 304.10523,266.3007 C 300.2652,266.3007 297.0492,267.9327 294.45723,271.1967 C 294.21721,271.48469 292.41721,274.53269 289.05723,280.3407 C 287.18521,283.60468 285.19322,285.23668 283.08123,285.2367 C 281.88122,285.23668 280.96922,284.78068 280.34523,283.8687 C 279.72122,283.00468 279.40922,281.94868 279.40923,280.7007 C 279.40922,278.25269 280.32122,276.62069 282.14523,275.8047 C 283.24922,275.32469 285.26522,275.08469 288.19323,275.0847 L 284.16123,263.9247 C 279.60122,264.6927 275.88123,266.5167 273.00123,269.3967 C 269.92923,272.46869 268.39323,276.23669 268.39323,280.7007 C 268.39323,285.40468 269.83323,289.07667 272.71323,291.7167 C 275.64123,294.40467 279.48122,295.74867 284.23323,295.7487 M 305.47323,294.2367 L 304.53723,292.0047 L 306.33723,293.8047 L 305.47323,294.2367 M 308.85723,292.5087 C 304.2492,287.90068 301.9452,285.57268 301.94523,285.5247 C 302.9532,285.04468 303.8652,284.54068 304.68123,284.0127 L 311.52123,290.7807 C 310.60919,291.45267 309.72119,292.02867 308.85723,292.5087 M 313.46523,289.1247 L 306.62523,282.3567 C 307.00919,281.78068 307.22519,281.15668 307.27323,280.4847 C 307.27319,279.86068 307.05719,279.02068 306.62523,277.9647 L 315.33723,286.6767 C 314.90519,287.49268 314.28119,288.30868 313.46523,289.1247 M 316.34523,283.9407 L 300.14523,267.6687 C 301.4412,267.2847 302.6892,267.0927 303.88923,267.0927 L 316.70523,279.9807 L 316.70523,280.5567 C 316.70519,281.61268 316.58519,282.74068 316.34523,283.9407 M 315.91323,275.3727 L 308.42523,267.8127 C 311.83319,269.25269 314.32919,271.77269 315.91323,275.3727 M 292.00923,292.2207 L 285.31323,285.5967 C 286.03322,285.16468 286.82522,284.46868 287.68923,283.5087 L 294.31323,290.0607 C 293.49721,290.97267 292.72921,291.69267 292.00923,292.2207 M 295.96923,288.0447 L 289.20123,281.2767 C 289.58521,280.70068 290.16121,279.78868 290.92923,278.5407 L 297.76923,285.4527 C 297.0012,286.60468 296.40121,287.46868 295.96923,288.0447 M 299.06523,283.0767 L 292.22523,276.1647 L 293.73723,273.3567 L 300.64923,280.2687 L 299.06523,283.0767 M 302.08923,277.8927 L 295.32123,271.1967 C 296.13721,270.28469 296.90521,269.56469 297.62523,269.0367 L 305.40123,276.8847 C 304.6332,276.59669 304.0572,276.45269 303.67323,276.4527 C 303.2412,276.45269 302.7132,276.93269 302.08923,277.8927 M 286.60923,294.9567 L 269.32923,277.6767 C 269.52123,276.57269 269.88123,275.46869 270.40923,274.3647 L 278.90523,282.8607 C 279.24122,284.44468 280.20122,285.40468 281.78523,285.7407 L 289.77723,293.7327 C 288.67321,294.26067 287.61721,294.66867 286.60923,294.9567 M 282.93723,295.1727 C 279.76922,294.88467 277.96922,294.52467 277.53723,294.0927 L 269.90523,286.4607 C 269.56923,286.12468 269.25723,284.37268 268.96923,281.2047 L 282.93723,295.1727 M 282.86523,274.9407 L 275.88123,267.9567 C 276.50523,267.5727 277.44122,267.0447 278.68923,266.3727 L 286.75323,274.5087 C 285.21722,274.50869 283.92122,274.65269 282.86523,274.9407 M 278.76123,279.0447 L 271.70523,271.9887 C 272.18523,271.26869 272.85723,270.47669 273.72123,269.6127 L 280.27323,276.2367 C 279.55322,276.86069 279.04922,277.79669 278.76123,279.0447 M 285.02523,269.0367 L 281.35323,265.3647 C 282.31322,265.0767 283.05722,264.9087 283.58523,264.8607 L 285.02523,269.0367 M 305.61723,293.7327 L 305.76123,293.7327 L 305.54523,293.5167 L 305.61723,293.7327 M 308.85723,292.1487 C 309.81719,291.57267 310.51319,291.11667 310.94523,290.7807 L 304.60923,284.4447 C 304.1292,284.73268 303.4092,285.11668 302.44923,285.5967 L 308.92923,292.0767 L 308.85723,292.1487 M 313.39323,288.5487 C 313.92119,288.06868 314.42519,287.46868 314.90523,286.7487 L 307.48923,279.2607 C 307.58519,279.83668 307.60919,280.24468 307.56123,280.4847 C 307.60919,281.10868 307.46519,281.70868 307.12923,282.2847 L 313.39323,288.5487 M 316.20123,283.2207 C 316.34519,282.35668 316.41719,281.49268 316.41723,280.6287 L 316.34523,280.1247 L 303.74523,267.4527 C 302.7372,267.4527 301.7532,267.5967 300.79323,267.8847 L 316.20123,283.2207 M 314.61723,273.5007 C 313.46519,271.53269 311.95319,270.02069 310.08123,268.9647 L 314.61723,273.5007 M 292.08123,291.7887 C 292.46521,291.45267 293.04121,290.90067 293.80923,290.1327 L 287.68923,284.0127 C 287.06521,284.68468 286.48922,285.21268 285.96123,285.5967 L 292.08123,291.7887 M 295.89723,287.3967 C 296.37721,286.82068 296.83321,286.17268 297.26523,285.4527 L 291.00123,279.1167 L 289.70523,281.2767 L 295.89723,287.3967 M 298.99323,282.5007 L 300.21723,280.3407 L 293.88123,273.9327 L 292.58523,276.0927 L 298.99323,282.5007 M 302.01723,277.3167 C 302.6892,276.40469 303.4092,276.02069 304.17723,276.1647 L 297.55323,269.4687 C 296.9772,269.90069 296.40121,270.45269 295.82523,271.1247 L 302.01723,277.3167 M 286.68123,294.5247 C 287.59321,294.28467 288.43321,293.99667 289.20123,293.6607 L 281.64123,286.1007 C 279.91322,285.66868 278.88122,284.63668 278.54523,283.0047 L 270.55323,274.9407 C 270.16923,275.90069 269.90523,276.78869 269.76123,277.6047 L 286.68123,294.5247 M 282.07323,294.7407 L 269.47323,282.1407 C 269.80923,284.68468 270.07323,286.05268 270.26523,286.2447 L 277.82523,293.7327 C 278.20922,294.11667 279.62522,294.45267 282.07323,294.7407 M 283.00923,274.5087 C 283.68122,274.36469 284.66522,274.24469 285.96123,274.1487 L 278.61723,266.8767 C 277.65722,267.3567 276.93722,267.7407 276.45723,268.0287 L 283.00923,274.5087 M 278.54523,278.3247 C 278.73722,277.55669 279.14522,276.83669 279.76923,276.1647 L 273.72123,270.1167 C 273.19323,270.69269 272.66523,271.29269 272.13723,271.9167 L 278.54523,278.3247 M 284.16123,267.6687 L 283.36923,265.2927 L 282.07323,265.5087 L 284.16123,267.6687"
+         style="font-size:72px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:none;fill-opacity:1;stroke:url(#linearGradient3281);stroke-width:1px;stroke-linecap:round;stroke-linejoin:round;stroke-opacity:1;font-family:Malabars Tryout;-inkscape-font-specification:Malabars Tryout" />
+      <g
+         transform="translate(-4.7251541,72.197657)"
+         id="g3972">
+        <path
+           transform="matrix(0.5473468,0,0,0.5565847,134.61044,56.187104)"
+           d="M 160.75191,61.069302 A 56.146683,55.214787 0 1 1 48.458549,61.069302 A 56.146683,55.214787 0 1 1 160.75191,61.069302 z"
+           sodipodi:ry="55.214787"
+           sodipodi:rx="56.146683"
+           sodipodi:cy="61.069302"
+           sodipodi:cx="104.60523"
+           id="path3915"
+           style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:2.78393936;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+           sodipodi:type="arc" />
+        <g
+           id="g3930"
+           transform="matrix(0.4966719,0,0,0.4966719,161.48334,59.089877)">
+          <path
+             id="path3943"
+             d="M 60.510156,6.3979729 C 55.926503,6.4192712 51.549217,6.8101906 47.697656,7.4917229 C 36.35144,9.4962267 34.291407,13.691825 34.291406,21.429223 L 34.291406,31.647973 L 61.103906,31.647973 L 61.103906,35.054223 L 34.291406,35.054223 L 24.228906,35.054223 C 16.436447,35.054223 9.6131468,39.73794 7.4789058,48.647973 C 5.0170858,58.860939 4.9078907,65.233996 7.4789058,75.897973 C 9.3848341,83.835825 13.936449,89.491721 21.728906,89.491723 L 30.947656,89.491723 L 30.947656,77.241723 C 30.947656,68.391821 38.6048,60.585475 47.697656,60.585473 L 74.478906,60.585473 C 81.933857,60.585473 87.885159,54.447309 87.885156,46.960473 L 87.885156,21.429223 C 87.885156,14.162884 81.755176,8.7044455 74.478906,7.4917229 C 69.872919,6.7249976 65.093809,6.3766746 60.510156,6.3979729 z M 46.010156,14.616723 C 48.779703,14.616723 51.041406,16.915369 51.041406,19.741723 C 51.041404,22.558059 48.779703,24.835473 46.010156,24.835473 C 43.23068,24.835472 40.978906,22.558058 40.978906,19.741723 C 40.978905,16.91537 43.23068,14.616723 46.010156,14.616723 z"
+             style="fill:url(#linearGradient3978);fill-opacity:1" />
+          <path
+             id="path3945"
+             d="M 91.228906,35.054223 L 91.228906,46.960473 C 91.228906,56.191228 83.403011,63.960472 74.478906,63.960473 L 47.697656,63.960473 C 40.361823,63.960473 34.291407,70.238956 34.291406,77.585473 L 34.291406,103.11672 C 34.291406,110.38306 40.609994,114.65704 47.697656,116.74172 C 56.184987,119.23733 64.323893,119.68835 74.478906,116.74172 C 81.229061,114.78733 87.885159,110.85411 87.885156,103.11672 L 87.885156,92.897973 L 61.103906,92.897973 L 61.103906,89.491723 L 87.885156,89.491723 L 101.29141,89.491723 C 109.08387,89.491723 111.98766,84.056315 114.69765,75.897973 C 117.49698,67.499087 117.37787,59.422197 114.69765,48.647973 C 112.77187,40.890532 109.09378,35.054223 101.29141,35.054223 L 91.228906,35.054223 z M 76.166406,99.710473 C 78.945884,99.710476 81.197656,101.98789 81.197656,104.80422 C 81.197654,107.63057 78.945881,109.92922 76.166406,109.92922 C 73.396856,109.92922 71.135156,107.63057 71.135156,104.80422 C 71.135158,101.98789 73.396853,99.710473 76.166406,99.710473 z"
+             style="fill:url(#linearGradient3980);fill-opacity:1" />
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>

+import os, os.path
+
+snakes_version = open("VERSION").readline().strip()
+package_version = open("debian/VERSION").readline().strip()
+ppa_version = open("debian/PPA").readline().strip()
+changelog_version = open("debian/changelog").readline().split()[1].strip("()")
+distribs = [l.strip().split()[0] for l in open("debian/DISTRIB")]
+base_dir = os.getcwd()
+base_dist_dir = "dist"
+dput_sh = open("dput.sh", "w")
+
+def system (command) :
+    print("*** %s" % command)
+    retcode = os.system(command)
+    if retcode != 0 :
+        print("*** error return status (%s)" % retcode)
+        sys.exit(retcode)
+
+def chdir (path) :
+    print("*** cd %s" % path)
+    os.chdir(path)
+
+def changelog (path, dist) :
+    full_version = "%s-%s~ppa%s~%s1" % (snakes_version, package_version,
+                                        ppa_version, dist)
+    chdir(path)
+    system("debchange -b --newversion %s --distribution %s 'see NEWS'"
+           % (full_version, dist))
+    chdir(base_dir)
+
+def build_package (dist_dir, dist) :
+    full_version = "%s-%s~ppa%s~%s1" % (snakes_version, package_version,
+                                        ppa_version, dist)
+    deb_dir = os.path.join(dist_dir, "python-snakes_%s" % full_version)
+    if not os.path.isdir(dist_dir) :
+        print("*** make dir %r" % dist_dir)
+        os.makedirs(dist_dir)
+    if os.path.isdir(deb_dir) :
+        system("rm -rf %s" % deb_dir)
+    system("hg archive %s" % deb_dir)
+    changelog(deb_dir, dist)
+    system("sed -i -e 's/DATE/$(date -R)/' %s/debian/copyright" % deb_dir)
+    system("sed -i -e 's/UNRELEASED/%s/' %s/debian/changelog" % (dist, deb_dir))
+    chdir(deb_dir)
+    system("make doc")
+    system("dpkg-buildpackage")
+    system("dpkg-buildpackage -S -sa")
+    chdir(base_dir)
+    dput_sh.write("dput lp %s_source.changes\n" % deb_dir)
+
+main_version = "%s-%s" % (snakes_version, package_version)
+if main_version != changelog_version :
+    system("debchange --newversion %s --distribution UNRELEASED 'see NEWS'"
+           % main_version)
+    system("hg commit -m 'updated debian/changelog' debian/changelog")
+
+for dist in distribs :
+    build_package(base_dist_dir, dist)
+dput_sh.close()

+import glob, os, os.path
+
+for src in glob.glob("snakes/lang/*/*.pgen") :
+    tgt = os.path.join(os.path.dirname(src), "pgen.py")
+    if not os.path.isfile(tgt) or os.path.getmtime(src) > os.path.getmtime(tgt) :
+        print("python snakes/lang/pgen.py --output=%s %s" % (tgt, src))
+        os.system("python snakes/lang/pgen.py --output=%s %s" % (tgt, src))
+
+for src in glob.glob("snakes/lang/*/*.asdl") :
+    tgt = os.path.join(os.path.dirname(src), "asdl.py")
+    if not os.path.isfile(tgt) or os.path.getmtime(src) > os.path.getmtime(tgt) :
+        print("python snakes/lang/asdl.py --output=%s %s" % (tgt, src))
+        os.system("python snakes/lang/asdl.py --output=%s %s" % (tgt, src))

+#!/usr/bin/env python
+
+import sys, os
+from distutils.core import setup
+
+def doc_files() :
+    import os, os.path
+    result = {}
+    for root, dirs, files in os.walk("doc") :
+        target_dir = os.path.join("share/doc/python-snakes",
+                                  *root.split(os.sep)[1:])
+        for name in files :
+            if target_dir not in result :
+                result[target_dir] = []
+            result[target_dir].append(os.path.join(root, name))
+    return list(result.items())
+
+if __name__ == "__main__" :
+    print("Compiling Emacs files...")
+    os.system("emacs -batch -f batch-byte-compile utils/abcd-mode.el")
+    #
+    setup(name="SNAKES",
+          version=open("VERSION").read().strip(),
+          description="SNAKES is the Net Algebra Kit for Editors and Simulators",
+          long_description="""SNAKES is a general purpose Petri net Python
+          library allowing to define and execute most classes of Petri
+          nets. It features a plugin system to allow its extension. In
+          particular, plugins are provided to implement the operations
+          usually found in the PBC and M-nets family.""",
+          author="Franck Pommereau",
+          author_email="pommereau@univ-paris12.fr",
+          maintainer="Franck Pommereau",
+          maintainer_email="pommereau@univ-paris12.fr",
+          url="http://lacl.univ-paris12.fr/pommereau/soft/snakes",
+          scripts=["bin/abcd",
+                   "bin/snkc",
+                   "bin/snkd",
+                   ],
+          packages=["snakes",
+                    "snakes.lang",
+                    "snakes.lang.pylib",
+                    "snakes.lang.python",
+                    "snakes.lang.abcd",
+                    "snakes.lang.ctlstar",
+                    "snakes.plugins",
+                    "snakes.utils",
+                    "snakes.utils.abcd",
+                    "snakes.utils.ctlstar",
+                    ],
+          data_files=(doc_files()
+                      + [("share/emacs/site-lisp", ["utils/abcd-mode.el",
+                                                    "utils/abcd-mode.elc"])]),
+          )

+"""SNAKES is the Net Algebra Kit for Editors and Simulators
+
+@author: Franck Pommereau
+@organization: University of Paris 12
+@copyright: (C) 2005 Franck Pommereau
+@license: GNU Lesser General Public Licence (aka. GNU LGPL),
+    see the file C{doc/COPYING} in the distribution or visit U{the GNU
+    web site<http://www.gnu.org/licenses/licenses.html#LGPL>}
+@contact: pommereau@univ-paris12.fr
+
+SNAKES is a Python library allowing to model all sorts of Petri nets
+and to execute them. It is very general as most Petri nets annotations
+can be arbitrary Python expressions while most values can be arbitrary
+Python objects.
+
+SNAKES can be further extended with plugins, several ones being
+already provided, in particular two plugins implement the Petri nets
+compositions defined for the Petri Box Calculus and its successors.
+"""
+
+version = "0.9.16"
+defaultencoding = "utf-8"
+
+class SnakesError (Exception) :
+    "An error in SNAKES"
+    pass
+
+class ConstraintError (SnakesError) :
+    "Violation of a constraint"
+    pass
+
+class NodeError (SnakesError) :
+    "Error related to a place or a transition"
+    pass
+
+class DomainError (SnakesError) :
+    "Function applied out of its domain"
+    pass
+
+class ModeError (SnakesError) :
+    "The modes of a transition cannot be found"
+    pass
+
+class PluginError (SnakesError) :
+    "Error when adding a plugin"
+    pass
+
+class UnificationError (SnakesError) :
+    "Error while unifying parameters"
+    pass

+"""Python 2 and 3 compatibility layer
+"""
+
+import sys
+
+try :
+    xrange
+except NameError :
+    xrange = range
+
+try :
+    reduce
+except NameError :
+    from functools import reduce
+
+try :
+    import StringIO as io
+except ImportError :
+    import io
+
+try :
+    next
+except NameError :
+    def next (obj) :
+        return obj.next()
+
+PY3 = sys.version > "3"

+"""Basic data types and functions used in SNAKES"""
+
+import operator, inspect
+from snakes.compat import *
+from snakes import DomainError
+from snakes.hashables import hdict
+from snakes.pnml import Tree
+
+def cross (sets) :
+    """Cross-product.
+
+    >>> list(cross([[1, 2], [3, 4, 5]]))
+    [(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)]
+    >>> list(cross([[1, 2], [3, 4, 5], [6, 7, 8, 9]]))
+    [(1, 3, 6), (1, 3, 7), (1, 3, 8), (1, 3, 9), (1, 4, 6), (1, 4, 7),
+     (1, 4, 8), (1, 4, 9), (1, 5, 6), (1, 5, 7), (1, 5, 8), (1, 5, 9),
+     (2, 3, 6), (2, 3, 7), (2, 3, 8), (2, 3, 9), (2, 4, 6), (2, 4, 7),
+     (2, 4, 8), (2, 4, 9), (2, 5, 6), (2, 5, 7), (2, 5, 8), (2, 5, 9)]
+    >>> list(cross([[], [1]]))
+    []
+
+    @param sets: the sets of values to use
+    @type sets: C{iterable(iterable(object))}
+    @return: the C{list} of obtained tuples (lists are used to allow
+      unhashable objects)
+    @rtype: C{generator(tuple(object))}
+    """
+    if len(sets) == 0 :
+        pass
+    elif len(sets) == 1 :
+        for item in sets[0] :
+            yield (item,)
+    else :
+        for item in sets[0] :
+            for others in cross(sets[1:]) :
+                yield (item,) + others
+
+def iterate (value) :
+    """Like Python's builtin C{iter} but consider strings as atomic.
+
+    >>> list(iter([1, 2, 3]))
+    [1, 2, 3]
+    >>> list(iterate([1, 2, 3]))
+    [1, 2, 3]
+    >>> list(iter('foo'))
+    ['f', 'o', 'o']
+    >>> list(iterate('foo'))
+    ['foo']
+
+    @param value: any object
+    @type value: C{object}
+    @return: an iterator on the elements of C{value} if is is iterable
+        and is not string, an iterator on the sole C{value} otherwise
+    @rtype: C{generator}
+    """
+    if isinstance(value, str) :
+        return iter([value])
+    else :
+        try :
+            return iter(value)
+        except TypeError :
+            return iter([value])
+
+class WordSet (set) :
+    """A set of words being able to generate fresh words."""
+    def fresh (self, add=False, min=1, allowed="abcdefghijklmnopqrstuvwxyz",
+               base="") :
+        """Create a fresh word (ie, which is not in the set).
+
+        >>> w = WordSet(['foo', 'bar'])
+        >>> list(sorted(w))
+        ['bar', 'foo']
+        >>> w.fresh(True, 3)
+        'aaa'
+        >>> list(sorted(w))
+        ['aaa', 'bar', 'foo']
+        >>> w.fresh(True, 3)
+        'baa'
+        >>> list(sorted(w))
+        ['aaa', 'baa', 'bar', 'foo']
+
+        @param add: add the created word to the set if C{add=True}
+        @type add: C{bool}
+        @param min: minimal length of the new word
+        @type min: C{int}
+        @param allowed: characters allowed in the new word
+        @type allowed: C{str}
+        """
+        if base :
+            result = [base] + [allowed[0]] * max(0, min - len(base))
+            if base in self :
+                result.append(allowed[0])
+                pos = len(result) - 1
+            elif len(base) < min :
+                pos = 1
+            else :
+                pos = 0
+        else :
+            result = [allowed[0]] * min
+            pos = 0
+        while "".join(result) in self :
+            for c in allowed :
+                try :
+                    result[pos] = c
+                except IndexError :
+                    result.append(c)
+                if "".join(result) not in self :
+                    break
+            pos += 1
+        if add :
+            self.add("".join(result))
+        return "".join(result)
+
+class MultiSet (hdict) :
+    """Set with repetitions, ie, function from values to integers.
+
+    MultiSets support various operations, in particular: addition
+    (C{+}), substraction (C{-}), multiplication by a non negative
+    integer (C{*k}), comparisons (C{<}, C{>}, etc.), length (C{len})"""
+    def __init__ (self, values=[]) :
+        """Initialise the multiset, adding values to it.
+
+        >>> MultiSet([1, 2, 3, 1, 2])
+        MultiSet([...])
+        >>> MultiSet()
+        MultiSet([])
+
+        @param values: a single value or an iterable object holding
+          values (strings are not iterated)
+        @type values: any atomic object (C{str} included) or an
+          iterable object
+        """
+        self.add(values)
+    def copy (self) :
+        """Copy a C{MultiSet}
+
+        >>> MultiSet([1, 2, 3, 1, 2]).copy()
+        MultiSet([...])
+
+        @return: a copy of the multiset
+        @rtype: C{MultiSet}
+        """
+        result = MultiSet()
+        result.update(self)
+        return result
+    __pnmltag__ = "multiset"
+    def __pnmldump__ (self) :
+        """
+        >>> MultiSet([1, 2, 3, 4, 1, 2]).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <multiset>
+          <item>
+           <value>
+            <object type="int">
+            ...
+            </object>
+           </value>
+           <multiplicity>
+           ...
+           </multiplicity>
+          </item>
+          <item>
+           <value>
+            <object type="int">
+            ...
+            </object>
+           </value>
+           <multiplicity>
+           ...
+           </multiplicity>
+          </item>
+          <item>
+           <value>
+            <object type="int">
+            ...
+            </object>
+           </value>
+           <multiplicity>
+           ...
+           </multiplicity>
+          </item>
+          <item>
+           <value>
+            <object type="int">
+            ...
+            </object>
+           </value>
+           <multiplicity>
+           ...
+           </multiplicity>
+          </item>
+         </multiset>
+        </pnml>
+        """
+        nodes = []
+        for value in hdict.__iter__(self) :
+            nodes.append(Tree("item", None,
+                              Tree("value", None, Tree.from_obj(value)),
+                              Tree("multiplicity", str(self[value]))))
+        return Tree(self.__pnmltag__, None, *nodes)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Load a multiset from its PNML representation
+
+        >>> t = MultiSet([1, 2, 3, 4, 1, 2]).__pnmldump__()
+        >>> MultiSet.__pnmlload__(t)
+        MultiSet([...])
+        """
+        result = cls()
+        for item in tree :
+            times = int(item.child("multiplicity").data)
+            value = item.child("value").child().to_obj()
+            result._add(value, times)
+        return result
+    def _add (self, value, times=1) :
+        """Add a single value C{times} times.
+
+        @param value: the value to add
+        @type value: any object
+        @param times: the number of times that C{value} has to be
+          added
+        @type times: non negative C{int}
+        """
+        if times < 0 :
+            raise ValueError("negative values are forbidden")
+        try :
+            self[value] += times
+        except KeyError :
+            self[value] = times
+    def add (self, values, times=1) :
+        """Add values to the multiset.
+
+        >>> m = MultiSet()
+        >>> m.add([1, 2, 2, 3], 2)
+        >>> list(sorted(m.items()))
+        [1, 1, 2, 2, 2, 2, 3, 3]
+        >>> m.add(5, 3)
+        >>> list(sorted(m.items()))
+        [1, 1, 2, 2, 2, 2, 3, 3, 5, 5, 5]
+
+        @param values: the values to add or a single value to add
+        @type values: any atomic object (C{str} included) or an
+          iterable object
+        @param times: the number of times each value should be added
+        @type times: non negative C{int}"""
+        self.__mutable__()
+        for value in iterate(values) :
+            self._add(value, times)
+    def _remove (self, value, times=1) :
+        """Remove a single value C{times} times.
+
+        @param value: the value to remove
+        @type value: any object
+        @param times: the number of times that C{value} has to be
+          removed
+        @type times: non negative C{int}
+        """
+        if times < 0 :
+            raise ValueError("negative values are forbidden")
+        if times > self.get(value, 0) :
+            raise ValueError("not enough occurrences")
+        self[value] -= times
+        if self[value] == 0 :
+            del self[value]
+    def remove (self, values, times=1) :
+        """Remove values to the multiset.
+
+        >>> m = MultiSet()
+        >>> m.add([1, 2, 2, 3], 2)
+        >>> list(sorted(m.items()))
+        [1, 1, 2, 2, 2, 2, 3, 3]
+        >>> m.remove(2, 3)
+        >>> list(sorted(m.items()))
+        [1, 1, 2, 3, 3]
+        >>> m.remove([1, 3], 2)
+        >>> list(sorted(m.items()))
+        [2]
+
+        @param values: the values to remove or a single value to remove
+        @type values: any atomic object (C{str} included) or an
+          iterable object
+        @param times: the number of times each value should be removed
+        @type times: non negative C{int}"""
+        self.__mutable__()
+        for value in iterate(values) :
+            self._remove(value, times)
+    def __call__ (self, value) :
+        """Number of occurrences of C{value}.
+
+        >>> m = MultiSet([1, 1, 2, 3, 3, 3])
+        >>> m(1), m(2), m(3), m(4)
+        (2, 1, 3, 0)
+
+        @param value: the value the count
+        @type value: C{object}
+        @rtype: C{int}
+        """
+        return self.get(value, 0)
+    def __iter__ (self) :
+        """Iterate over the values (with repetitions).
+
+        Use C{MultiSet.keys} to ignore repetitions.
+
+        >>> list(sorted(iter(MultiSet([1, 2, 3, 1, 2]))))
+        [1, 1, 2, 2, 3]
+
+        @return: an iterator on the elements
+        @rtype: C{iterator}"""
+        for value in dict.__iter__(self) :
+            for count in range(self[value]) :
+                yield value
+    def items (self) :
+        """
+        Return the list of items with repetitions. The list without
+        repetitions can be retrieved with the C{key} method.
+
+        >>> m = MultiSet([1, 2, 2, 3])
+        >>> list(sorted(m.items()))
+        [1, 2, 2, 3]
+        >>> list(sorted(m.keys()))
+        [1, 2, 3]
+
+        @return: list of items with repetitions
+        @rtype: C{list}"""
+        return list(iter(self))
+    def __str__ (self) :
+        """Return a simple string representation of the multiset
+
+        >>> str(MultiSet([1, 2, 2, 3]))
+        '{...}'
+
+        @return: simple string representation of the multiset
+        @rtype: C{str}
+        """
+        return "{%s}" % ", ".join(repr(x) for x in self)
+    def __repr__ (self) :
+        """Return a string representation of the multiset that is
+        suitable for C{eval}
+
+        >>> repr(MultiSet([1, 2, 2, 3]))
+        'MultiSet([...])'
+
+        @return: precise string representation of the multiset
+        @rtype: C{str}
+        """
+        return "MultiSet([%s])" % ", ".join(repr(x) for x in self)
+    def __len__ (self) :
+        """Return the number of elements, including repetitions.
+
+        >>> len(MultiSet([1, 2] * 3))
+        6
+
+        @rtype: C{int}
+        """
+        if self.size() == 0 :
+            return 0
+        else :
+            return reduce(operator.add, self.values())
+    def size (self) :
+        """Return the number of elements, excluding repetitions.
+
+        >>> MultiSet([1, 2] * 3).size()
+        2
+
+        @rtype: C{int}
+        """
+        return dict.__len__(self)
+    def __add__ (self, other) :
+        """Adds two multisets.
+
+        >>> MultiSet([1, 2, 3]) + MultiSet([2, 3, 4])
+        MultiSet([...])
+
+        @param other: the multiset to add
+        @type other: C{MultiSet}
+        @rtype: C{MultiSet}
+        """
+        result = self.copy()
+        for value, times in dict.items(other) :
+            result._add(value, times)
+        return result
+    def __sub__ (self, other) :
+        """Substract two multisets.
+
+        >>> MultiSet([1, 2, 3]) - MultiSet([2, 3])
+        MultiSet([1])
+        >>> MultiSet([1, 2, 3]) - MultiSet([2, 3, 4])
+        Traceback (most recent call last):
+        ...
+        ValueError: not enough occurrences
+
+        @param other: the multiset to substract
+        @type other: C{MultiSet}
+        @rtype: C{MultiSet}
+        """
+        result = self.copy()
+        for value, times in dict.items(other) :
+            result._remove(value, times)
+        return result
+    def __mul__ (self, other) :
+        """Multiplication by a non-negative integer.
+
+        >>> MultiSet([1, 2]) * 3
+        MultiSet([...])
+
+        @param other: the integer to multiply
+        @type other: non-negative C{int}
+        @rtype: C{MultiSet}
+        """
+        if other < 0 :
+            raise ValueError("negative values are forbidden")
+        elif other == 0 :
+            return MultiSet()
+        else :
+            result = self.copy()
+            for value in self.keys() :
+                result[value] *= other
+            return result
+    __hash__ = hdict.__hash__
+    def __eq__ (self, other) :
+        """Test for equality.
+
+        >>> MultiSet([1, 2, 3]*2) == MultiSet([1, 2, 3]*2)
+        True
+        >>> MultiSet([1, 2, 3]) == MultiSet([1, 2, 3, 3])
+        False
+
+        @param other: the multiset to compare with
+        @type other: C{MultiSet}
+        @rtype: C{bool}
+        """
+        if len(self) != len(other) :
+            return False
+        else :
+            for val in self :
+                try :
+                    if self[val] != other[val] :
+                        return False
+                except (KeyError, TypeError) :
+                    return False
+        return True
+    def __ne__ (self, other) :
+        """Test for difference.
+
+        >>> MultiSet([1, 2, 3]*2) != MultiSet([1, 2, 3]*2)
+        False
+        >>> MultiSet([1, 2, 3]) != MultiSet([1, 2, 3, 3])
+        True
+
+        @param other: the multiset to compare with
+        @type other: C{MultiSet}
+        @rtype: C{bool}
+        """
+        return not(self == other)
+    def __lt__ (self, other) :
+        """Test for strict inclusion.
+
+        >>> MultiSet([1, 2, 3]) < MultiSet([1, 2, 3, 4])
+        True
+        >>> MultiSet([1, 2, 3]) < MultiSet([1, 2, 3, 3])
+        True
+        >>> MultiSet([1, 2, 3]) < MultiSet([1, 2, 3])
+        False
+        >>> MultiSet([1, 2, 3]) < MultiSet([1, 2])
+        False
+        >>> MultiSet([1, 2, 2]) < MultiSet([1, 2, 3, 4])
+        False
+
+        @param other: the multiset to compare with
+        @type other: C{MultiSet}
+        @rtype: C{bool}
+        """
+        if not set(self.keys()) <= set(other.keys()) :
+            return False
+        result = False
+        for value, times in dict.items(self) :
+            count = other(value)
+            if times > count :
+                return False
+            elif times < count :
+                result = True
+        return result or (dict.__len__(self) < dict.__len__(other))
+    def __le__ (self, other) :
+        """Test for inclusion inclusion.
+
+        >>> MultiSet([1, 2, 3]) <= MultiSet([1, 2, 3, 4])
+        True
+        >>> MultiSet([1, 2, 3]) <= MultiSet([1, 2, 3, 3])
+        True
+        >>> MultiSet([1, 2, 3]) <= MultiSet([1, 2, 3])
+        True
+        >>> MultiSet([1, 2, 3]) <= MultiSet([1, 2])
+        False
+        >>> MultiSet([1, 2, 2]) <= MultiSet([1, 2, 3, 4])
+        False
+
+        @param other: the multiset to compare with
+        @type other: C{MultiSet}
+        @rtype: C{bool}
+        """
+        if not set(self.keys()) <= set(other.keys()) :
+            return False
+        for value, times in dict.items(self) :
+            count = other(value)
+            if times > count :
+                return False
+        return True
+    def __gt__ (self, other) :
+        """Test for strict inclusion.
+
+        >>> MultiSet([1, 2, 3, 4]) > MultiSet([1, 2, 3])
+        True
+        >>> MultiSet([1, 2, 3, 3]) > MultiSet([1, 2, 3])
+        True
+        >>> MultiSet([1, 2, 3]) > MultiSet([1, 2, 3])
+        False
+        >>> MultiSet([1, 2]) > MultiSet([1, 2, 3])
+        False
+        >>> MultiSet([1, 2, 3, 4]) > MultiSet([1, 2, 2])
+        False
+
+        @param other: the multiset to compare with
+        @type other: C{MultiSet}
+        @rtype: C{bool}
+        """
+        return other.__lt__(self)
+    def __ge__ (self, other) :
+        """Test for inclusion.
+
+        >>> MultiSet([1, 2, 3, 4]) >= MultiSet([1, 2, 3])
+        True
+        >>> MultiSet([1, 2, 3, 3]) >= MultiSet([1, 2, 3])
+        True
+        >>> MultiSet([1, 2, 3]) >= MultiSet([1, 2, 3])
+        True
+        >>> MultiSet([1, 2]) >= MultiSet([1, 2, 3])
+        False
+        >>> MultiSet([1, 2, 3, 4]) >= MultiSet([1, 2, 2])
+        False
+
+        @param other: the multiset to compare with
+        @type other: C{MultiSet}
+        @rtype: C{bool}
+        """
+        return other.__le__(self)
+    def domain (self) :
+        """Return the domain of the multiset
+
+        >>> list(sorted((MultiSet([1, 2, 3, 4]) + MultiSet([1, 2, 3])).domain()))
+        [1, 2, 3, 4]
+
+        @return: the set of values in the domain
+        @rtype: C{set}
+        """
+        return set(self.keys())
+
+class Substitution (object) :
+    """Map names to values or names, equals the identity where not defined.
+
+    Substitutions support the C{+} operation (union with consistency
+    check between the two operands) and the C{*} operation which is
+    the composition of functions (C{(f*g)(x)} is C{f(g(x))}).
+
+    Several methods (eg, C{image}) return lists instead of sets, this
+    avoids the restriction of having only hashable values in a
+    substitution image.
+    """
+    def __init__ (self, *largs, **dargs) :
+        """Initialise using a dictionnary as a mapping.
+
+        The expected arguments are any ones acceptables for
+        initializing a dictionnary.
+
+        >>> Substitution()
+        Substitution()
+        >>> Substitution(x=1, y=2)
+        Substitution(...)
+        >>> Substitution([('x', 1), ('y', 2)])
+        Substitution(...)
+        >>> Substitution({'x': 1, 'y': 2})
+        Substitution(...)
+        """
+        self._dict = dict(*largs, **dargs)
+    def __hash__ (self) :
+        """
+        >>> hash(Substitution(x=1, y=2)) == hash(Substitution(y=2, x=1))
+        True
+        """
+        # 153913524 = hash('snakes.data.Substitution')
+        return reduce(operator.xor,
+                      (hash(i) for i in self._dict.items()),
+                      153913524)
+    def __eq__ (self, other) :
+        """
+        >>> Substitution(x=1, y=2) == Substitution(y=2, x=1)
+        True
+        >>> Substitution(x=1, y=2) == Substitution(y=1, x=1)
+        False
+        """
+        try :
+            return self._dict == other._dict
+        except :
+            return False
+    def __ne__ (self, other) :
+        """
+        >>> Substitution(x=1, y=2) != Substitution(y=2, x=1)
+        False
+        >>> Substitution(x=1, y=2) != Substitution(y=1, x=1)
+        True
+        """
+        return not self.__eq__(other)
+    __pnmltag__ = "substitution"
+    def __pnmldump__ (self) :
+        """Dumps a substitution to a PNML tree
+
+        >>> Substitution(x=1, y=2).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <substitution>
+          <item>
+           <name>
+           ...
+           </name>
+           <value>
+            <object type="int">
+            ...
+            </object>
+           </value>
+          </item>
+          <item>
+           <name>
+           ...
+           </name>
+           <value>
+            <object type="int">
+            ...
+            </object>
+           </value>
+          </item>
+         </substitution>
+        </pnml>
+
+        @return: PNML representation
+        @rtype: C{snakes.pnml.Tree}
+        """
+        nodes = []
+        for name, value in self._dict.items() :
+            nodes.append(Tree("item", None,
+                              Tree("name", name),
+                              Tree("value", None,
+                                   Tree.from_obj(value))))
+        return Tree(self.__pnmltag__, None, *nodes)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Load a substitution from its PNML representation
+
+        >>> t = Substitution(x=1, y=2).__pnmldump__()
+        >>> Substitution.__pnmlload__(t)
+        Substitution(...)
+
+        @param tree: the PNML tree to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: the substitution loaded
+        @rtype: C{Substitution}
+        """
+        result = cls()
+        for item in tree :
+            name = item.child("name").data
+            value = item.child("value").child().to_obj()
+            result._dict[name] = value
+        return result
+    def items (self) :
+        """Return the list of pairs (name, value).
+
+        >>> Substitution(x=1, y=2).items()
+        [('...', ...), ('...', ...)]
+
+        @return: a list of pairs (name, value) for each mapped name
+        @rtype: C{list}
+        """
+        return list(self._dict.items())
+    def domain (self) :
+        """Return the set of mapped names.
+
+        >>> list(sorted(Substitution(x=1, y=2).domain()))
+        ['x', 'y']
+
+        @return: the set of mapped names
+        @rtype: C{set}
+        """
+        return set(self._dict.keys())
+    def image (self) :
+        """Return the set of values associated to the names.
+
+        >>> list(sorted(Substitution(x=1, y=2).image()))
+        [1, 2]
+
+        @return: the set of values associated to names
+        @rtype: C{set}
+        """
+        return set(self._dict.values())
+    def __contains__ (self, name) :
+        """Test if a name is mapped.
+
+        >>> 'x' in Substitution(x=1, y=2)
+        True
+        >>> 'z' in Substitution(x=1, y=2)
+        False
+
+        @param name: the name to test
+        @type name: C{str} (usually)
+        @return: a Boolean indicating whether this name is in the
+          domain or not
+        @rtype: C{bool}
+        """
+        return name in self._dict
+    def __iter__ (self) :
+        """Iterate over the mapped names.
+
+        >>> list(sorted(iter(Substitution(x=1, y=2))))
+        ['x', 'y']
+
+        @return: an iterator over the domain of the substitution
+        @rtype: C{generator}
+        """
+        return iter(self._dict)
+    def __str__ (self) :
+        """Return a compact string representation.
+
+        >>> str(Substitution(x=1, y=2))
+        '{... -> ..., ... -> ...}'
+
+        @return: a simple string representation
+        @rtype: C{str}
+        """
+        return "{%s}" % ", ".join(["%s -> %r" % (str(var), val)
+                                   for var, val in self.items()])
+    def __repr__ (self) :
+        """Return a string representation suitable for C{eval}.
+
+        >>> repr(Substitution(x=1, y=2))
+        'Substitution(...)'
+
+        @return: a precise string representation
+        @rtype: C{str}
+        """
+        return "%s(%s)" % (self.__class__.__name__,
+                           ", ".join(("%s=%s" % (str(var), repr(val))
+                                      for var, val in self.items())))
+    def dict (self) :
+        """Return the mapping as a dictionnary.
+
+        >>> Substitution(x=1, y=2).dict()
+        {'...': ..., '...': ...}
+
+        @return: a dictionnary that does the same mapping as the
+          substitution
+        @rtype: C{dict}
+        """
+        return self._dict.copy()
+    def copy (self) :
+        """Copy the mapping.
+
+        >>> Substitution(x=1, y=2).copy()
+        Substitution(...)
+
+        @return: a copy of the substitution
+        @rtype: C{Substitution}
+        """
+        return Substitution(self.dict())
+    def __setitem__ (self, var, value) :
+        """Assign an entry to the substitution
+
+        >>> s = Substitution()
+        >>> s['x'] = 42
+        >>> s
+        Substitution(x=42)
+
+        @param var: the name of the variable
+        @type var: C{str}
+        @param value: the value to which C{var} is bound
+        @type value: C{object}
+        """
+        self._dict[var] = value
+    def __getitem__ (self, var) :
+        """Return the mapped value.
+
+        Fails with C{DomainError} if C{var} is not mapped.
+
+        >>> s = Substitution(x=1, y=2)
+        >>> s['x']
+        1
+        >>> try : s['z']
+        ... except DomainError : print(sys.exc_info()[1])
+        unbound variable 'z'
+
+        @param var: the name of the variable
+        @type var: C{str} (usually)
+        @return: the value that C{var} maps to
+        @rtype: C{object}
+        @raise DomainError: if C{var} does not belong to the domain
+        """
+        try :
+            return self._dict[var]
+        except KeyError :
+            raise DomainError("unbound variable '%s'" % var)
+    def __call__ (self, var) :
+        """Return the mapped value.
+
+        Never fails but return C{var} if it is not mapped.
+
+        >>> s = Substitution(x=1, y=2)
+        >>> s('x')
+        1
+        >>> s('z')
+        'z'
+
+        @param var: the name of the variable
+        @type var: C{str} (usually)
+        @return: the value that C{var} maps to or C{var} itself if it
+          does not belong to the domain
+        @rtype: C{object}
+        """
+        try :
+            return self._dict[var]
+        except KeyError :
+            return var
+    def __add__ (self, other) :
+        """Add two substitution.
+
+        Fails with C{DomainError} if the two substitutions map a same
+        name to different values.
+
+        >>> s = Substitution(x=1, y=2) + Substitution(y=2, z=3)
+        >>> s('x'), s('y'), s('z')
+        (1, 2, 3)
+        >>> try : Substitution(x=1, y=2) + Substitution(y=4, z=3)
+        ... except DomainError : print(sys.exc_info()[1])
+        conflict on 'y'
+
+        @param other: another substitution
+        @type other: C{Substitution}
+        @return: the union of the substitutions
+        @rtype: C{Substitution}
+        @raise DomainError: when one name is mapped to distinct values
+        """
+        for var in self :
+            if var in other and (self[var] != other[var]) :
+                raise DomainError("conflict on '%s'" % var)
+        s = self.__class__(self.dict())
+        s._dict.update(other.dict())
+        return s
+    def __mul__ (self, other) :
+        """Compose two substitutions.
+
+        The composition of f and g is such that (f*g)(x) = f(g(x)).
+
+        >>> f = Substitution(a=1, d=3, y=5)
+        >>> g = Substitution(b='d', c=2, e=4, y=6)
+        >>> h = f*g
+        >>> h('a'), h('b'), h('c'), h('d'), h('e'), h('y'), h('x')
+        (1, 3, 2, 3, 4, 6, 'x')
+
+        @param other: another substitution
+        @type other: C{Substitution}
+        @return: the composition of the substitutions
+        @rtype: C{Substitution}
+        """
+        res = self.copy()
+        for var in other :
+            res._dict[var] = self(other(var))
+        return res
+
+class Symbol (object) :
+    """A symbol that may be used as a constant
+    """
+    def __init__ (self, name, export=True) :
+        """
+        If C{export} is C{True}, the created symbol is exported under
+        its name. If C{export} is C{False}, no export is made.
+        Finally, if C{export} is a string, it specifies the name of
+        the exported symbol.
+
+        @param name: the name (or value of the symbol)
+        @type name: C{str}
+        @param export: the name under which the symbol is exported
+        @type export: C{str} or C{bool} or C{None}
+
+        >>> Symbol('foo')
+        Symbol('foo')
+        >>> foo
+        Symbol('foo')
+        >>> Symbol('egg', 'spam')
+        Symbol('egg', 'spam')
+        >>> spam
+        Symbol('egg', 'spam')
+        >>> Symbol('bar', False)
+        Symbol('bar', False)
+        >>> bar
+        Traceback (most recent call last):
+         ...
+        NameError: ...
+
+        """
+        self.name = name
+        if export is True :
+            export = name
+        self._export = export
+        if export :
+            inspect.stack()[1][0].f_globals[export] = self
+    __pnmltag__ = "symbol"
+    def __pnmldump__ (self) :
+        """
+        >>> Symbol('egg', 'spam').__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <symbol name="egg">
+          <object type="str">
+           spam
+          </object>
+         </symbol>
+        </pnml>
+        >>> Symbol('foo').__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <symbol name="foo"/>
+        </pnml>
+        >>> Symbol('bar', False).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <symbol name="bar">
+          <object type="bool">
+           False
+          </object>
+         </symbol>
+        </pnml>
+        """
+        if self.name == self._export :
+            children = []
+        else :
+            children = [Tree.from_obj(self._export)]
+        return Tree(self.__pnmltag__, None, *children, **dict(name=self.name))
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """
+        >>> Symbol.__pnmlload__(Symbol('foo', 'bar').__pnmldump__())
+        Symbol('foo', 'bar')
+        >>> Symbol.__pnmlload__(Symbol('foo').__pnmldump__())
+        Symbol('foo')
+        >>> Symbol.__pnmlload__(Symbol('foo', False).__pnmldump__())
+        Symbol('foo', False)
+        """
+        name = tree["name"]
+        try :
+            export = tree.child().to_obj()
+        except :
+            export = name
+        return cls(name, export)
+    def __eq__ (self, other) :
+        """
+        >>> Symbol('foo', 'bar') == Symbol('foo')
+        True
+        >>> Symbol('egg') == Symbol('spam')
+        False
+        """
+        try :
+            return (self.__class__.__name__ == other.__class__.__name__
+                    and self.name == other.name)
+        except AttributeError :
+            return False
+    def __ne__ (self, other) :
+        """
+        >>> Symbol('foo', 'bar') != Symbol('foo')
+        False
+        >>> Symbol('egg') != Symbol('spam')
+        True
+        """
+        return not (self == other)
+    def __hash__ (self) :
+        """
+        >>> hash(Symbol('foo', 'bar')) == hash(Symbol('foo'))
+        True
+        """
+        return hash((self.__class__.__name__, self.name))
+    def __str__ (self) :
+        """
+        >>> str(Symbol('foo'))
+        'foo'
+        """
+        return self.name
+    def __repr__ (self) :
+        """
+        >>> Symbol('foo')
+        Symbol('foo')
+        >>> Symbol('egg', 'spam')
+        Symbol('egg', 'spam')
+        >>> Symbol('bar', False)
+        Symbol('bar', False)
+        """
+        if self._export == self.name :
+            return "%s(%r)" % (self.__class__.__name__, self.name)
+        else :
+            return "%s(%r, %r)" % (self.__class__.__name__, self.name,
+                                   self._export)

+"""Hashable mutable objets.
+
+This module proposes hashable version of the mutable containers
+C{list}, C{dict} and C{set}, called respectively C{hlist}, C{hdict}
+and C{hset}. After one object has been hashed, it becomes not mutable
+and raises a ValueError if a method which changes the object (let call
+a I{mutation} such a method) is invoqued. The object can be then
+un-hashed by calling C{unhash} on it so that it becomes mutable again.
+Notice that this may cause troubles if the object is stored in a set
+or dict which uses its hashcode to locate it. Notice also that
+hashable containers cannot be hashed if they contain non hashable
+objects.
+
+>>> l = hlist(range(5))
+>>> l
+hlist([0, 1, 2, 3, 4])
+>>> _ = hash(l)
+>>> l.append(5)
+Traceback (most recent call last):
+...
+ValueError: hashed 'hlist' object is not mutable
+>>> unhash(l)
+>>> l.append(5)
+>>> l
+hlist([0, 1, 2, 3, 4, 5])
+
+Testing if a C{hlist} is in a C{set}, C{dict}, C{hset} or C{hdict}
+causes its hashing. If this is not desirable, you should either
+compensate with a call to C{unhash}, or test if a copy is in the set:
+
+>>> s = set()
+>>> s.add(list(range(4)))
+Traceback (most recent call last):
+...
+TypeError: ...
+>>> s.add(hlist(range(4)))
+>>> l = hlist(range(3))
+>>> l in s
+False
+>>> l.append(3)
+Traceback (most recent call last):
+...
+ValueError: hashed 'hlist' object is not mutable
+>>> unhash(l)
+>>> l.append(3)
+>>> l[:] in s
+True
+>>> l.append(4)
+"""
+
+import inspect
+from operator import xor
+from snakes.compat import *
+
+def unhash (obj) :
+    """Make the object hashable again.
+
+    >>> l = hlist(range(3))
+    >>> _ = hash(l)
+    >>> l.append(3)
+    Traceback (most recent call last):
+    ...
+    ValueError: hashed 'hlist' object is not mutable
+    >>> unhash(l)
+    >>> l.append(3)
+
+    @param obj: any object
+    @type obj: C{object}
+    """
+    try :
+        del obj._hash
+    except :
+        pass
+
+def hashable (cls) :
+    """Wrap methods in a class in order to make it hashable.
+    """
+    classname, bases, classdict = cls.__name__, cls.__bases__, cls.__dict__
+    for name, attr in classdict.items() :
+        try :
+            doc = inspect.getdoc(attr)
+            if doc is None :
+                attr.__doc__ = getattr(bases[0], name).__doc__
+            else :
+                attr.__doc__ = "\n".join([inspect.getdoc(getattr(bases[0],
+                                                                 name)),
+                                          doc])
+        except :
+            pass
+    def __hash__ (self) :
+        if not hasattr(self, "_hash") :
+            self._hash = self.__hash__.HASH(self)
+        return self._hash
+    __hash__.HASH = classdict["__hash__"]
+    __hash__.__doc__ = classdict["__hash__"].__doc__
+    cls.__hash__ = __hash__
+    def __mutable__ (self) :
+        "Raise C{ValueError} if the %s has been hashed."
+        if self.hashed() :
+            raise ValueError("hashed '%s' object is not mutable" % classname)
+    try :
+        __mutable__.__doc__ = __mutable__.__doc__ % classname
+    except :
+        pass
+    cls.__mutable__ = __mutable__
+    def hashed (self) :
+        "Return 'True' if the %s has been hashed, 'False' otherwise."
+        return hasattr(self, "_hash")
+    try :
+        hashed.__doc__ = hashed.__doc__ % classname
+    except :
+        pass
+    cls.hashed = hashed
+    def mutable (self) :
+        "Return 'True' if the %s is not hashed, 'False' otherwise."
+        return not self.hashed()
+    try :
+        mutable.__doc__ = mutable.__doc__ % classname
+    except :
+        pass
+    cls.mutable = mutable
+    return cls
+
+class hlist (list) :
+    """Hashable lists.
+
+    >>> l = hlist(range(5))
+    >>> l
+    hlist([0, 1, 2, 3, 4])
+    >>> l.append(5)
+    >>> l
+    hlist([0, 1, 2, 3, 4, 5])
+    >>> _ = hash(l)
+    >>> l.append(6)
+    Traceback (most recent call last):
+    ...
+    ValueError: hashed 'hlist' object is not mutable
+    >>> unhash(l)
+    >>> l.append(6)
+    """
+    def __add__ (self, other) :
+        return self.__class__(list.__add__(self, other))
+    def __delitem__ (self, item) :
+        self.__mutable__()
+        list.__delitem__(self, item)
+    def __delslice__ (self, *l, **d) :
+        self.__mutable__()
+        list.__delslice__(self, *l, **d)
+    def __getslice__ (self, first, last) :
+        return self.__class__(list.__getslice__(self, first, last))
+    def __getitem__ (self, item) :
+        ret = list.__getitem__(self, item)
+        if ret.__class__ is list :
+            return self.__class__(ret)
+        return ret
+    def __hash__ (self) :
+        return hash(tuple(self))
+    def __iadd__ (self, other) :
+        return self.__class__(list.__iadd__(self, other))
+    def __imul__ (self, n) :
+        return self.__class__(list.__imul__(self, n))
+    def __mul__ (self, n) :
+        return self.__class__(list.__mul__(self, n))
+    def __repr__ (self) :
+        """
+        >>> repr(hlist(range(3)))
+        'hlist([0, 1, 2])'
+        """
+        return "%s(%s)" % (self.__class__.__name__, list.__repr__(self))
+    def __rmul__ (self, n) :
+        return self._class__(list.__rmul__(self, n))
+    def __setitem__ (self, index, item) :
+        self.__mutable__()
+        list.__setitem__(self, index, item)
+    def __setslice__ (self, first, last, item) :
+        self.__mutable__()
+        list.__setslice__(self, first, last, item)
+    def append (self, item) :
+        self.__mutable__()
+        list.append(self, item)
+    def extend (self, iterable) :
+        self.__mutable__()
+        list.extend(self, iterable)
+    def insert (self, index, item) :
+        self.__mutable__()
+        list.insert(self, index, item)
+    def pop (self, index=-1) :
+        self.__mutable__()
+        return list.pop(self, index)
+    def remove (self, item) :
+        self.__mutable__()
+        list.remove(self, item)
+    def reverse (self) :
+        self.__mutable__()
+        list.reverse(self)
+    def sort (self, cmp=None, key=None, reverse=False) :
+        self.__mutable__()
+        list.sort(self, cmp, key, reverse)
+
+hlist = hashable(hlist)
+
+class hdict (dict) :
+    """Hashable dictionnaries.
+
+    >>> l = hlist(range(5))
+    >>> d = hdict([(l, 0)])
+    >>> d
+    hdict({hlist([0, 1, 2, 3, 4]): 0})
+    >>> l in d
+    True
+    >>> [0, 1, 2, 3, 4] in d
+    Traceback (most recent call last):
+    ...
+    TypeError: ...
+    >>> hlist([0, 1, 2, 3, 4]) in d
+    True
+    >>> d[hlist([0, 1, 2, 3, 4])]
+    0
+    >>> l.append(5)
+    Traceback (most recent call last):
+    ...
+    ValueError: hashed 'hlist' object is not mutable
+    >>> _ = hash(d)
+    >>> d.pop(l)  # any mutation would produce the same error
+    Traceback (most recent call last):
+    ...
+    ValueError: hashed 'hdict' object is not mutable
+    >>> unhash(d)
+    >>> d.pop(l)
+    0
+    """
+    def __delitem__ (self, key) :
+        self.__mutable__()
+        dict.__delitem__(self, key)
+    def __hash__ (self) :
+        """
+        >>> _ = hash(hdict(a=1, b=2))
+        """
+        # 252756382 = hash("snakes.hashables.hlist")
+        return reduce(xor, (hash(i) for i in self.items()), 252756382)
+    def __repr__ (self) :
+        """
+        >>> repr(hdict(a=1))
+        "hdict({'a': 1})"
+        """
+        return "%s(%s)" % (self.__class__.__name__, dict.__repr__(self))
+    def __setitem__ (self, key, item) :
+        self.__mutable__()
+        dict.__setitem__(self, key, item)
+    def clear (self) :
+        self.__mutable__()
+        dict.clear(self)
+    def copy (self) :
+        return self.__class__(dict.copy(self))
+    @classmethod
+    def fromkeys (_class, *args) :
+        return _class(dict.fromkeys(*args))
+    def pop (self, *args) :
+        self.__mutable__()
+        return dict.pop(self, *args)
+    def popitem (self) :
+        self.__mutable__()
+        return dict.popitem(self)
+    def setdefault (self, key, item=None) :
+        self.__mutable__()
+        return dict.setdefault (self, key, item)
+    def update (self, other, **more) :
+        self.__mutable__()
+        return dict.update(self, other, **more)
+
+hdict = hashable(hdict)
+
+class hset (set) :
+    """Hashable sets.
+
+    >>> s = hset()
+    >>> l = hlist(range(5))
+    >>> s.add(l)
+    >>> s
+    hset([hlist([0, 1, 2, 3, 4])])
+    >>> l in s
+    True
+    >>> [0, 1, 2, 3, 4] in s
+    Traceback (most recent call last):
+    ...
+    TypeError: ...
+    >>> hlist([0, 1, 2, 3, 4]) in s
+    True
+    >>> l.append(5)
+    Traceback (most recent call last):
+    ...
+    ValueError: hashed 'hlist' object is not mutable
+    >>> _ = hash(s)
+    >>> s.discard(l)  # any mutation would produce the same error
+    Traceback (most recent call last):
+    ...
+    ValueError: hashed 'hset' object is not mutable
+    >>> unhash(s)
+    >>> s.discard(l)
+    """
+    def __and__ (self, other) :
+        return self.__class__(set.__and__(self, other))
+    def __hash__ (self) :
+        """
+        >>> _ = hash(hset([1, 2, 3]))
+        >>> _ = hash(hset(range(5)) - set([0, 4]))
+        """
+        # 196496309 = hash("snakes.hashables.hset")
+        return reduce(xor, (hash(x) for x in self), 196496309)
+    def __iand__ (self, other) :
+        return self.__class__(set.__iand__(self, other))
+    def __ior__ (self, other) :
+        return self.__class__(set.__ior__(self, other))
+    def __isub__ (self, other) :
+        return self.__class__(set.__isub__(self, other))
+    def __ixor__ (self, other) :
+        return self.__class__(set.__ixor__(self, other))
+    def __or__ (self, other) :
+        return self.__class__(set.__or__(self, other))
+    def __rand__ (self, other) :
+        return self.__class__(set.__rand__(self, other))
+    def __repr__ (self) :
+        """
+        >>> repr(hset([1]))
+        'hset([1])'
+        """
+        return "%s([%s])" % (self.__class__.__name__,
+                             set.__repr__(self)[6:-2])
+    def __ror__ (self, other) :
+        return self.__class__(set.__ror__(self, other))
+    def __rsub__ (self, other) :
+        return self.__class__(set.__rsub__(self, other))
+    def __rxor__ (self, other) :
+        return self.__class__(set.__rxor__(self, other))
+    def __str__ (self) :
+        return self.__class__.__name__ + "(" + set.__str__(self).split("(", 1)[1]
+    def __sub__ (self, other) :
+        return self.__class__(set.__sub__(self, other))
+    def __xor__ (self, other) :
+        return self.__class__(set.__xor__(self, other))
+    def add (self, item) :
+        self.__mutable__()
+        set.add(self, item)
+    def clear (self) :
+        self.__mutable__()
+        set.clear(self)
+    def copy (self) :
+        return self.__class__(set.copy(self))
+    def difference (self, other) :
+        return self.__class__(set.difference(self, other))
+    def difference_update (self, other) :
+        self.__mutable__()
+        set.difference_update(self, other)
+    def discard (self, item) :
+        self.__mutable__()
+        set.discard(self, item)
+    def intersection (self, other) :
+        return self._class__(set.intersection(self, other))
+    def intersection_update (self, other) :
+        self.__mutable__()
+        set.intersection_update(self, other)
+    def pop (self) :
+        self.__mutable__()
+        return set.pop(self)
+    def remove (self, item) :
+        self.__mutable__()
+        set.remove(self, item)
+    def symmetric_difference (self, other) :
+        self.__mutable__()
+        set.symmetric_difference(self, other)
+    def symmetric_difference_update (self, other) :
+        self.__mutable__()
+        set.symmetric_difference_update(self, other)
+    def union (self, other) :
+        return self.__class__(set.union(self, other))
+    def update (self, other) :
+        self.__mutable__()
+        set.update(self, other)
+
+hset = hashable(hset)

+import sys
+if sys.version_info[:2] in ((2, 6), (2, 7)) :
+    import ast
+elif sys.version_info[0] == 3 :
+    import ast
+elif hasattr(sys, "pypy_version_info") :
+    import astpypy as ast
+elif hasattr(sys, "JYTHON_JAR") :
+    import astjy25 as ast
+elif sys.version_info[:2] == (2, 5) :
+    import astpy25 as ast
+else :
+    raise NotImplementedError("unsupported Python version")
+
+sys.modules["snkast"] = ast
+
+from . import unparse as _unparse
+from snakes.compat import *
+
+class Names (ast.NodeVisitor) :
+    def __init__ (self) :
+        ast.NodeVisitor.__init__(self)
+        self.names = set()
+    def visit_Name (self, node) :
+        self.names.add(node.id)
+
+def getvars (expr) :
+    """
+    >>> list(sorted(getvars('x+y<z')))
+    ['x', 'y', 'z']
+    >>> list(sorted(getvars('x+y<z+f(3,t)')))
+    ['f', 't', 'x', 'y', 'z']
+    """
+    names = Names()
+    names.visit(ast.parse(expr))
+    return names.names - set(['None', 'True', 'False'])
+
+class Unparser(_unparse.Unparser) :
+    boolops = {"And": 'and', "Or": 'or'}
+    def _Interactive (self, tree) :
+        for stmt in tree.body :
+            self.dispatch(stmt)
+    def _Expression (self, tree) :
+        self.dispatch(tree.body)
+    def _ClassDef(self, tree):
+        self.write("\n")
+        for deco in tree.decorator_list:
+            self.fill("@")
+            self.dispatch(deco)
+        self.fill("class "+tree.name)
+        if tree.bases:
+            self.write("(")
+            for a in tree.bases:
+                self.dispatch(a)
+                self.write(", ")
+            self.write(")")
+        self.enter()
+        self.dispatch(tree.body)
+        self.leave()
+
+def unparse (st) :
+    output = io.StringIO()
+    Unparser(st, output)
+    return output.getvalue().strip()
+
+class Renamer (ast.NodeTransformer) :
+    def __init__ (self, map_names) :
+        ast.NodeTransformer.__init__(self)
+        self.map = [map_names]
+    def visit_ListComp (self, node) :
+        bind = self.map[-1].copy()
+        for comp in node.generators :
+            for name in getvars(comp.target) :
+                if name in bind :
+                    del bind[name]
+        self.map.append(bind)
+        node.elt = self.visit(node.elt)
+        self.map.pop(-1)
+        return node
+    def visit_SetComp (self, node) :
+        return self.visit_ListComp(node)
+    def visit_DictComp (self, node) :
+        bind = self.map[-1].copy()
+        for comp in node.generators :
+            for name in getvars(comp.target) :
+                if name in bind :
+                    del bind[name]
+        self.map.append(bind)
+        node.key = self.visit(node.key)
+        node.value = self.visit(node.value)
+        self.map.pop(-1)
+        return node
+    def visit_Name (self, node) :
+        return ast.copy_location(ast.Name(id=self.map[-1].get(node.id,
+                                                              node.id),
+                                          ctx=ast.Load()), node)
+
+def rename (expr, map={}, **ren) :
+    """
+    >>> rename('x+y<z', x='t')
+    '((t + y) < z)'
+    >>> rename('x+y<z+f(3,t)', f='g', t='z', z='t')
+    '((x + y) < (t + g(3, z)))'
+    >>> rename('[x+y for x in range(3)]', x='z')
+    '[(x + y) for x in range(3)]'
+    >>> rename('[x+y for x in range(3)]', y='z')
+    '[(x + z) for x in range(3)]'
+    """
+    map_names = dict(map)
+    map_names.update(ren)
+    transf = Renamer(map_names)
+    return unparse(transf.visit(ast.parse(expr)))
+
+class Binder (Renamer) :
+    def visit_Name (self, node) :
+        if node.id in self.map[-1] :
+            return self.map[-1][node.id]
+        else :
+            return node
+
+def bind (expr, map={}, **ren) :
+    """
+    >>> bind('x+y<z', x=ast.Num(n=2))
+    '((2 + y) < z)'
+    >>> bind('x+y<z', y=ast.Num(n=2))
+    '((x + 2) < z)'
+    >>> bind('[x+y for x in range(3)]', x=ast.Num(n=2))
+    '[(x + y) for x in range(3)]'
+    >>> bind('[x+y for x in range(3)]', y=ast.Num(n=2))
+    '[(x + 2) for x in range(3)]'
+    """
+    map_names = dict(map)
+    map_names.update(ren)
+    transf = Binder(map_names)
+    return unparse(transf.visit(ast.parse(expr)))
+
+if __name__ == "__main__" :
+    import doctest
+    doctest.testmod()

+module ABCD version "$Revision: 1 $"
+{
+        abcd = AbcdSpec(decl* context, process body, expr* asserts)
+
+        decl = AbcdTypedef(identifier name, abcdtype type)
+	      | AbcdBuffer(identifier name, abcdtype type,
+                           Slice? capacity, expr content)
+	      | AbcdSymbol(identifier* symbols)
+	      | AbcdConst(identifier name, expr value)
+	      | AbcdNet(identifier name, arguments args, AbcdSpec body)
+	      | AbcdTask(identifier name, AbcdSpec body,
+                         abcdtype* input, ancdtype* output)
+	      | stmt -- this too much, but does not harm
+
+	       attributes (int lineno, int col_offset)
+
+	process = AbcdAction(access* accesses, object guard)
+	       | AbcdFlowOp(process left, flowop op, process right)
+               | AbcdInstance(identifier net, identifier? asname, expr* args,
+                              keyword* keywords, expr? starargs, expr? kwargs)
+
+	        attributes (int lineno, int col_offset)
+
+	flowop = Sequence | Choice | Parallel | Loop
+
+	access = SimpleAccess(identifier buffer, arc arc, expr tokens)
+               | FlushAccess(identifier buffer, identifier target)
+               | SwapAccess(identifier buffer, expr target, expr tokens)
+               | Spawn(identifier net, expr pid, expr args)
+               | Wait(identifier net, expr pid, expr args)
+               | Suspend(identifier net, expr pid)
+               | Resume(identifier net, expr pid)
+
+	        attributes (int lineno, int col_offset)
+
+	arc = Produce | Test | Consume | Fill
+
+	abcdtype = UnionType(abcdtype* types)
+                 | IntersectionType(abcdtype* types)
+		 | CrossType(abcdtype* types)
+		 | ListType(abcdtype items)
+		 | TupleType(abcdtype items)
+		 | SetType(abcdtype items)
+		 | DictType(abcdtype keys, abcdtype values)
+		 | EnumType(expr* items)
+		 | NamedType(identifier name)
+
+	          attributes (int lineno, int col_offset)
+
+	--------------------------------------------------------------
+	-- the rest is copied from "snakes/lang/python/python.asdl" --
+	--------------------------------------------------------------
+
+	stmt = FunctionDef(identifier name, arguments args, 
+                           stmt* body, expr* decorator_list, expr? returns)
+	      | ClassDef(identifier name, 
+			 expr* bases,
+			 keyword* keywords,
+			 expr? starargs,
+			 expr? kwargs,
+			 stmt* body,
+			 expr *decorator_list)
+	      | Return(expr? value)
+
+	      | Delete(expr* targets)
+	      | Assign(expr* targets, expr value)
+	      | AugAssign(expr target, operator op, expr value)
+
+	      | For(expr target, expr iter, stmt* body, stmt* orelse)
+	      | While(expr test, stmt* body, stmt* orelse)
+	      | If(expr test, stmt* body, stmt* orelse)
+	      | With(expr context_expr, expr? optional_vars, stmt* body)
+
+	      | Raise(expr? exc, expr? cause)
+	      | TryExcept(stmt* body, excepthandler* handlers, stmt* orelse)
+	      | TryFinally(stmt* body, stmt* finalbody)
+	      | Assert(expr test, expr? msg)
+
+	      | Import(alias* names)
+	      | ImportFrom(identifier module, alias* names, int? level)
+
+	      | Exec(expr body, expr? globals, expr? locals)
+
+	      | Global(identifier* names)
+	      | Nonlocal(identifier* names)
+	      | Expr(expr value)
+	      | Pass | Break | Continue
+
+	      attributes (int lineno, int col_offset)
+
+	expr = BoolOp(boolop op, expr* values)
+	     | BinOp(expr left, operator op, expr right)
+	     | UnaryOp(unaryop op, expr operand)
+	     | Lambda(arguments args, expr body)
+	     | IfExp(expr test, expr body, expr orelse)
+	     | Dict(expr* keys, expr* values)
+	     | Set(expr* elts)
+	     | ListComp(expr elt, comprehension* generators)
+	     | SetComp(expr elt, comprehension* generators)
+	     | DictComp(expr key, expr value, comprehension* generators)
+	     | GeneratorExp(expr elt, comprehension* generators)
+	     | Yield(expr? value)
+	     | Compare(expr left, cmpop* ops, expr* comparators)
+	     | Call(expr func, expr* args, keyword* keywords,
+			 expr? starargs, expr? kwargs)
+	     | Num(object n)
+	     | Str(string s)
+	     | Ellipsis
+
+	     | Attribute(expr value, identifier attr, expr_context ctx)
+	     | Subscript(expr value, slice slice, expr_context ctx)
+	     | Starred(expr value, expr_context ctx)
+	     | Name(identifier id, expr_context ctx)
+	     | List(expr* elts, expr_context ctx) 
+	     | Tuple(expr* elts, expr_context ctx)
+
+	      attributes (int lineno, int col_offset)
+
+	expr_context = Load | Store | Del | AugLoad | AugStore | Param
+
+	slice = Slice(expr? lower, expr? upper, expr? step) 
+	      | ExtSlice(slice* dims) 
+	      | Index(expr value) 
+
+	boolop = And | Or 
+
+	operator = Add | Sub | Mult | Div | Mod | Pow | LShift 
+                 | RShift | BitOr | BitXor | BitAnd | FloorDiv
+
+	unaryop = Invert | Not | UAdd | USub
+
+	cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn
+
+	comprehension = (expr target, expr iter, expr* ifs)
+
+	excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)
+	                attributes (int lineno, int col_offset)
+
+	arguments = (arg* args, identifier? vararg, expr? varargannotation,
+                     arg* kwonlyargs, identifier? kwarg,
+                     expr? kwargannotation, expr* defaults,
+                     expr* kw_defaults)
+	arg = (identifier arg, expr? annotation)
+
+        keyword = (identifier arg, expr value)
+
+        alias = (identifier name, identifier? asname)
+}

+# Grammar for ABCD
+
+# new tokens
+$QUESTION '?'
+$ELLIPSIS '...'
+
+file_input: abcd_main ENDMARKER
+
+abcd_main: (NEWLINE | abcd_global)* abcd_expr abcd_prop*
+abcd_global: import_stmt | abcd_symbol | abcd_typedef | abcd_const | abcd_decl
+abcd_spec: (NEWLINE | abcd_decl)* abcd_expr
+abcd_decl: abcd_net | abcd_task | abcd_buffer
+
+abcd_const: 'const' NAME '=' testlist
+abcd_symbol: 'symbol' abcd_namelist
+abcd_typedef: 'typedef' NAME ':' abcd_type
+abcd_net: 'net' NAME parameters ':' abcd_suite
+abcd_task: 'task' NAME typelist '-' '>' typelist ':' abcd_suite
+abcd_suite: abcd_expr | NEWLINE INDENT abcd_spec DEDENT
+abcd_buffer: [ decorators ] 'buffer' NAME ['[' test ']'] ':' abcd_type '=' testlist
+
+abcd_namelist: NAME (',' NAME)*
+typelist: '(' [abcd_type (',' abcd_type)*] ')'
+
+abcd_type: abcd_and_type ('|' abcd_and_type)*
+abcd_and_type: abcd_cross_type ('&' abcd_cross_type)*
+abcd_cross_type: abcd_base_type ('*' abcd_base_type)*
+abcd_base_type: (NAME ['(' abcd_type (',' abcd_type)* ')']
+                 | 'enum' '(' test (',' test)* ')' | '(' abcd_type ')')
+
+abcd_expr: abcd_choice_expr ('|' abcd_choice_expr)*
+abcd_choice_expr: abcd_iter_expr ('+' abcd_iter_expr)*
+abcd_iter_expr: abcd_seq_expr ('*' abcd_seq_expr)*
+abcd_seq_expr: abcd_base_expr (';' abcd_base_expr)*
+abcd_base_expr: (abcd_action | '(' abcd_expr ')') (NEWLINE)*
+abcd_action: ('[' 'True' ']' |
+              '[' 'False' ']' |
+              '[' abcd_access_list ['if' test] ']' |
+              abcd_instance)
+abcd_access_list: abcd_access (',' abcd_access)*
+abcd_access: (NAME '+' '(' testlist ')' |
+              NAME '?' '(' testlist ')' |
+              NAME '-' '(' testlist ')' |
+              NAME '<>' '(' testlist '=' testlist ')' |
+              NAME '>>' '(' NAME ')' |
+              NAME '<<' '(' testlist_comp ')' |
+              NAME '.' NAME '(' test (',' test)* ')')
+abcd_instance: [NAME ':' ':'] NAME '(' [arglist] ')'
+
+tfpdef: NAME [':' ('net' | 'buffer' | 'task')]
+
+abcd_prop: 'assert' test (NEWLINE)*
+
+#
+# the rest is from SNAKES/Python grammar
+#
+
+decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
+decorators: decorator+
+decorated: decorators (classdef | funcdef)
+funcdef: 'def' NAME parameters ['-' '>' test] ':' suite
+parameters: '(' [typedargslist] ')'
+typedargslist: ((tfpdef ['=' test] ',')*
+                ('*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef]
+                 | '**' tfpdef)
+                | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
+varargslist: ((vfpdef ['=' test] ',')*
+              ('*' [vfpdef] (',' vfpdef ['=' test])*  [',' '**' vfpdef]
+               | '**' vfpdef)
+              | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
+vfpdef: NAME
+
+stmt: simple_stmt | compound_stmt
+simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
+small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt |
+             import_stmt | global_stmt | nonlocal_stmt | assert_stmt)
+expr_stmt: testlist (augassign (yield_expr|testlist) |
+                     ('=' (yield_expr|testlist))*)
+augassign: ('+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' |
+            '<<=' | '>>=' | '**=' | '//=')
+del_stmt: 'del' exprlist
+pass_stmt: 'pass'
+flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
+break_stmt: 'break'
+continue_stmt: 'continue'
+return_stmt: 'return' [testlist]
+yield_stmt: yield_expr
+raise_stmt: 'raise' [test ['from' test]]
+import_stmt: import_name | import_from
+import_name: 'import' dotted_as_names
+import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+)
+              'import' ('*' | '(' import_as_names ')' | import_as_names))
+import_as_name: NAME ['as' NAME]
+dotted_as_name: dotted_name ['as' NAME]
+import_as_names: import_as_name (',' import_as_name)* [',']
+dotted_as_names: dotted_as_name (',' dotted_as_name)*
+dotted_name: NAME ('.' NAME)*
+global_stmt: 'global' NAME (',' NAME)*
+nonlocal_stmt: 'nonlocal' NAME (',' NAME)*
+assert_stmt: 'assert' test [',' test]
+
+compound_stmt: (if_stmt | while_stmt | for_stmt | try_stmt | with_stmt
+                | funcdef | classdef | decorated)
+if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
+while_stmt: 'while' test ':' suite ['else' ':' suite]
+for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+try_stmt: ('try' ':' suite
+           ((except_clause ':' suite)+
+	    ['else' ':' suite]
+	    ['finally' ':' suite] |
+	   'finally' ':' suite))
+with_stmt: 'with' test [ with_var ] ':' suite
+with_var: 'as' expr
+except_clause: 'except' [test ['as' NAME]]
+suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
+
+test: or_test ['if' or_test 'else' test] | lambdef
+test_nocond: or_test | lambdef_nocond
+lambdef: 'lambda' [varargslist] ':' test
+lambdef_nocond: 'lambda' [varargslist] ':' test_nocond
+or_test: and_test ('or' and_test)*
+and_test: not_test ('and' not_test)*
+not_test: 'not' not_test | comparison
+comparison: star_expr (comp_op star_expr)*
+comp_op: '<'|'>'|'=='|'>='|'<='|'!='|'<>'|'in'|'not' 'in'|'is'|'is' 'not'
+star_expr: ['*'] expr
+expr: xor_expr ('|' xor_expr)*
+xor_expr: and_expr ('^' and_expr)*
+and_expr: shift_expr ('&' shift_expr)*
+shift_expr: arith_expr (('<<'|'>>') arith_expr)*
+arith_expr: term (('+'|'-') term)*
+term: factor (('*'|'/'|'%'|'//') factor)*
+factor: ('+'|'-'|'~') factor | power
+power: atom trailer* ['**' factor]
+atom: ('(' [yield_expr|testlist_comp] ')' |
+       '[' [testlist_comp] ']' |
+       '{' [dictorsetmaker] '}' |
+       NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False')
+testlist_comp: test ( comp_for | (',' test)* [','] )
+trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
+subscriptlist: subscript (',' subscript)* [',']
+subscript: test | [test] ':' [test] [sliceop]
+sliceop: ':' [test]
+exprlist: star_expr (',' star_expr)* [',']
+testlist: test (',' test)* [',']
+dictorsetmaker: ( (test ':' test (comp_for | (',' test ':' test)* [','])) |
+                  (test (comp_for | (',' test)* [','])) )
+
+classdef: 'class' NAME ['(' [arglist] ')'] ':' suite
+
+arglist: (argument ',')* (argument [',']
+                         |'*' test (',' argument)* [',' '**' test]
+                         |'**' test)
+argument: test [comp_for] | test '=' test
+
+comp_iter: comp_for | comp_if
+comp_for: 'for' exprlist 'in' or_test [comp_iter]
+comp_if: 'if' test_nocond [comp_iter]
+
+yield_expr: 'yield' [testlist]

+# this file has been automatically generated running:
+# snakes/lang/asdl.py --output=snakes/lang/abcd/asdl.py snakes/lang/abcd/abcd.asdl
+# timestamp: 2011-09-29 11:07:13.505687
+
+from snakes.lang import ast
+from ast import *
+
+class _AST (ast.AST):
+    def __init__ (self, **ARGS):
+        ast.AST.__init__(self)
+        for k, v in ARGS.items():
+            setattr(self, k, v)
+
+class abcd (_AST):
+    pass
+
+class AbcdSpec (abcd):
+    _fields = ('context', 'body', 'asserts')
+    _attributes = ()
+    def __init__ (self, body, context=[], asserts=[], **ARGS):
+        abcd.__init__(self, **ARGS)
+        self.context = list(context)
+        self.body = body
+        self.asserts = list(asserts)
+
+class decl (_AST):
+    pass
+
+class AbcdTypedef (decl):
+    _fields = ('name', 'type')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, type, lineno=0, col_offset=0, **ARGS):
+        decl.__init__(self, **ARGS)
+        self.name = name
+        self.type = type
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class AbcdBuffer (decl):
+    _fields = ('name', 'type', 'capacity', 'content')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, type, content, capacity=None, lineno=0, col_offset=0, **ARGS):
+        decl.__init__(self, **ARGS)
+        self.name = name
+        self.type = type
+        self.capacity = capacity
+        self.content = content
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class AbcdSymbol (decl):
+    _fields = ('symbols',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, symbols=[], lineno=0, col_offset=0, **ARGS):
+        decl.__init__(self, **ARGS)
+        self.symbols = list(symbols)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class AbcdConst (decl):
+    _fields = ('name', 'value')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, value, lineno=0, col_offset=0, **ARGS):
+        decl.__init__(self, **ARGS)
+        self.name = name
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class AbcdNet (decl):
+    _fields = ('name', 'args', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, args, body, lineno=0, col_offset=0, **ARGS):
+        decl.__init__(self, **ARGS)
+        self.name = name
+        self.args = args
+        self.body = body
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class AbcdTask (decl):
+    _fields = ('name', 'body', 'input', 'output')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, body, input=[], output=[], lineno=0, col_offset=0, **ARGS):
+        decl.__init__(self, **ARGS)
+        self.name = name
+        self.body = body
+        self.input = list(input)
+        self.output = list(output)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class stmt (decl):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        decl.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class slice (_AST):
+    pass
+
+class Slice (slice):
+    _fields = ('lower', 'upper', 'step')
+    _attributes = ()
+    def __init__ (self, lower=None, upper=None, step=None, **ARGS):
+        slice.__init__(self, **ARGS)
+        self.lower = lower
+        self.upper = upper
+        self.step = step
+
+class ExtSlice (slice):
+    _fields = ('dims',)
+    _attributes = ()
+    def __init__ (self, dims=[], **ARGS):
+        slice.__init__(self, **ARGS)
+        self.dims = list(dims)
+
+class Index (slice):
+    _fields = ('value',)
+    _attributes = ()
+    def __init__ (self, value, **ARGS):
+        slice.__init__(self, **ARGS)
+        self.value = value
+
+class arc (_AST):
+    pass
+
+class Produce (arc):
+    _fields = ()
+    _attributes = ()
+
+class Test (arc):
+    _fields = ()
+    _attributes = ()
+
+class Consume (arc):
+    _fields = ()
+    _attributes = ()
+
+class Fill (arc):
+    _fields = ()
+    _attributes = ()
+
+class expr_context (_AST):
+    pass
+
+class Load (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class Store (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class Del (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class AugLoad (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class AugStore (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class Param (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class keyword (_AST):
+    _fields = ('arg', 'value')
+    _attributes = ()
+    def __init__ (self, arg, value, **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.arg = arg
+        self.value = value
+
+class unaryop (_AST):
+    pass
+
+class Invert (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class Not (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class UAdd (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class USub (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class process (_AST):
+    pass
+
+class AbcdAction (process):
+    _fields = ('accesses', 'guard')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, guard, accesses=[], lineno=0, col_offset=0, **ARGS):
+        process.__init__(self, **ARGS)
+        self.accesses = list(accesses)
+        self.guard = guard
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class AbcdFlowOp (process):
+    _fields = ('left', 'op', 'right')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, left, op, right, lineno=0, col_offset=0, **ARGS):
+        process.__init__(self, **ARGS)
+        self.left = left
+        self.op = op
+        self.right = right
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class AbcdInstance (process):
+    _fields = ('net', 'asname', 'args', 'keywords', 'starargs', 'kwargs')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, net, asname=None, args=[], keywords=[], starargs=None, kwargs=None, lineno=0, col_offset=0, **ARGS):
+        process.__init__(self, **ARGS)
+        self.net = net
+        self.asname = asname
+        self.args = list(args)
+        self.keywords = list(keywords)
+        self.starargs = starargs
+        self.kwargs = kwargs
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class expr (_AST):
+    pass
+
+class BoolOp (expr):
+    _fields = ('op', 'values')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, op, values=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.op = op
+        self.values = list(values)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class BinOp (expr):
+    _fields = ('left', 'op', 'right')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, left, op, right, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.left = left
+        self.op = op
+        self.right = right
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class UnaryOp (expr):
+    _fields = ('op', 'operand')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, op, operand, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.op = op
+        self.operand = operand
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Lambda (expr):
+    _fields = ('args', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, args, body, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.args = args
+        self.body = body
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class IfExp (expr):
+    _fields = ('test', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, body, orelse, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.test = test
+        self.body = body
+        self.orelse = orelse
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Dict (expr):
+    _fields = ('keys', 'values')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, keys=[], values=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.keys = list(keys)
+        self.values = list(values)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Set (expr):
+    _fields = ('elts',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elts=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elts = list(elts)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class ListComp (expr):
+    _fields = ('elt', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elt, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elt = elt
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class SetComp (expr):
+    _fields = ('elt', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elt, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elt = elt
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class DictComp (expr):
+    _fields = ('key', 'value', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, key, value, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.key = key
+        self.value = value
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class GeneratorExp (expr):
+    _fields = ('elt', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elt, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elt = elt
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Yield (expr):
+    _fields = ('value',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Compare (expr):
+    _fields = ('left', 'ops', 'comparators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, left, ops=[], comparators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.left = left
+        self.ops = list(ops)
+        self.comparators = list(comparators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Call (expr):
+    _fields = ('func', 'args', 'keywords', 'starargs', 'kwargs')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, func, args=[], keywords=[], starargs=None, kwargs=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.func = func
+        self.args = list(args)
+        self.keywords = list(keywords)
+        self.starargs = starargs
+        self.kwargs = kwargs
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Num (expr):
+    _fields = ('n',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, n, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.n = n
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Str (expr):
+    _fields = ('s',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, s, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.s = s
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Ellipsis (expr):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Attribute (expr):
+    _fields = ('value', 'attr', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, attr, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.attr = attr
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Subscript (expr):
+    _fields = ('value', 'slice', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, slice, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.slice = slice
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Starred (expr):
+    _fields = ('value', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Name (expr):
+    _fields = ('id', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, id, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.id = id
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class List (expr):
+    _fields = ('elts', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elts=[], ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elts = list(elts)
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Tuple (expr):
+    _fields = ('elts', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elts=[], ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elts = list(elts)
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class cmpop (_AST):
+    pass
+
+class Eq (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class NotEq (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class Lt (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class LtE (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class Gt (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class GtE (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class Is (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class IsNot (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class In (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class NotIn (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class boolop (_AST):
+    pass
+
+class And (boolop):
+    _fields = ()
+    _attributes = ()
+
+class Or (boolop):
+    _fields = ()
+    _attributes = ()
+
+class stmt (_AST):
+    pass
+
+class FunctionDef (stmt):
+    _fields = ('name', 'args', 'body', 'decorator_list', 'returns')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, args, body=[], decorator_list=[], returns=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.name = name
+        self.args = args
+        self.body = list(body)
+        self.decorator_list = list(decorator_list)
+        self.returns = returns
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class ClassDef (stmt):
+    _fields = ('name', 'bases', 'keywords', 'starargs', 'kwargs', 'body', 'decorator_list')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, bases=[], keywords=[], starargs=None, kwargs=None, body=[], decorator_list=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.name = name
+        self.bases = list(bases)
+        self.keywords = list(keywords)
+        self.starargs = starargs
+        self.kwargs = kwargs
+        self.body = list(body)
+        self.decorator_list = list(decorator_list)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Return (stmt):
+    _fields = ('value',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Delete (stmt):
+    _fields = ('targets',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, targets=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.targets = list(targets)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Assign (stmt):
+    _fields = ('targets', 'value')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, targets=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.targets = list(targets)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class AugAssign (stmt):
+    _fields = ('target', 'op', 'value')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, target, op, value, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.target = target
+        self.op = op
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class For (stmt):
+    _fields = ('target', 'iter', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, target, iter, body=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.target = target
+        self.iter = iter
+        self.body = list(body)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class While (stmt):
+    _fields = ('test', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, body=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.test = test
+        self.body = list(body)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class If (stmt):
+    _fields = ('test', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, body=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.test = test
+        self.body = list(body)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class With (stmt):
+    _fields = ('context_expr', 'optional_vars', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, context_expr, optional_vars=None, body=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.context_expr = context_expr
+        self.optional_vars = optional_vars
+        self.body = list(body)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Raise (stmt):
+    _fields = ('exc', 'cause')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, exc=None, cause=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.exc = exc
+        self.cause = cause
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class TryExcept (stmt):
+    _fields = ('body', 'handlers', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, body=[], handlers=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.body = list(body)
+        self.handlers = list(handlers)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class TryFinally (stmt):
+    _fields = ('body', 'finalbody')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, body=[], finalbody=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.body = list(body)
+        self.finalbody = list(finalbody)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Assert (stmt):
+    _fields = ('test', 'msg')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, msg=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.test = test
+        self.msg = msg
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Import (stmt):
+    _fields = ('names',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, names=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.names = list(names)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class ImportFrom (stmt):
+    _fields = ('module', 'names', 'level')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, module, names=[], level=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.module = module
+        self.names = list(names)
+        self.level = level
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Exec (stmt):
+    _fields = ('body', 'globals', 'locals')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, body, globals=None, locals=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.body = body
+        self.globals = globals
+        self.locals = locals
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Global (stmt):
+    _fields = ('names',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, names=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.names = list(names)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Nonlocal (stmt):
+    _fields = ('names',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, names=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.names = list(names)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Expr (stmt):
+    _fields = ('value',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Pass (stmt):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Break (stmt):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Continue (stmt):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class access (_AST):
+    pass
+
+class SimpleAccess (access):
+    _fields = ('buffer', 'arc', 'tokens')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, buffer, arc, tokens, lineno=0, col_offset=0, **ARGS):
+        access.__init__(self, **ARGS)
+        self.buffer = buffer
+        self.arc = arc
+        self.tokens = tokens
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class FlushAccess (access):
+    _fields = ('buffer', 'target')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, buffer, target, lineno=0, col_offset=0, **ARGS):
+        access.__init__(self, **ARGS)
+        self.buffer = buffer
+        self.target = target
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class SwapAccess (access):
+    _fields = ('buffer', 'target', 'tokens')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, buffer, target, tokens, lineno=0, col_offset=0, **ARGS):
+        access.__init__(self, **ARGS)
+        self.buffer = buffer
+        self.target = target
+        self.tokens = tokens
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Spawn (access):
+    _fields = ('net', 'pid', 'args')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, net, pid, args, lineno=0, col_offset=0, **ARGS):
+        access.__init__(self, **ARGS)
+        self.net = net
+        self.pid = pid
+        self.args = args
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Wait (access):
+    _fields = ('net', 'pid', 'args')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, net, pid, args, lineno=0, col_offset=0, **ARGS):
+        access.__init__(self, **ARGS)
+        self.net = net
+        self.pid = pid
+        self.args = args
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Suspend (access):
+    _fields = ('net', 'pid')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, net, pid, lineno=0, col_offset=0, **ARGS):
+        access.__init__(self, **ARGS)
+        self.net = net
+        self.pid = pid
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Resume (access):
+    _fields = ('net', 'pid')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, net, pid, lineno=0, col_offset=0, **ARGS):
+        access.__init__(self, **ARGS)
+        self.net = net
+        self.pid = pid
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class alias (_AST):
+    _fields = ('name', 'asname')
+    _attributes = ()
+    def __init__ (self, name, asname=None, **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.name = name
+        self.asname = asname
+
+class flowop (_AST):
+    pass
+
+class Sequence (flowop):
+    _fields = ()
+    _attributes = ()
+
+class Choice (flowop):
+    _fields = ()
+    _attributes = ()
+
+class Parallel (flowop):
+    _fields = ()
+    _attributes = ()
+
+class Loop (flowop):
+    _fields = ()
+    _attributes = ()
+
+class comprehension (_AST):
+    _fields = ('target', 'iter', 'ifs')
+    _attributes = ()
+    def __init__ (self, target, iter, ifs=[], **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.target = target
+        self.iter = iter
+        self.ifs = list(ifs)
+
+class arg (_AST):
+    _fields = ('arg', 'annotation')
+    _attributes = ()
+    def __init__ (self, arg, annotation=None, **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.arg = arg
+        self.annotation = annotation
+
+class operator (_AST):
+    pass
+
+class Add (operator):
+    _fields = ()
+    _attributes = ()
+
+class Sub (operator):
+    _fields = ()
+    _attributes = ()
+
+class Mult (operator):
+    _fields = ()
+    _attributes = ()
+
+class Div (operator):
+    _fields = ()
+    _attributes = ()
+
+class Mod (operator):
+    _fields = ()
+    _attributes = ()
+
+class Pow (operator):
+    _fields = ()
+    _attributes = ()
+
+class LShift (operator):
+    _fields = ()
+    _attributes = ()
+
+class RShift (operator):
+    _fields = ()
+    _attributes = ()
+
+class BitOr (operator):
+    _fields = ()
+    _attributes = ()
+
+class BitXor (operator):
+    _fields = ()
+    _attributes = ()
+
+class BitAnd (operator):
+    _fields = ()
+    _attributes = ()
+
+class FloorDiv (operator):
+    _fields = ()
+    _attributes = ()
+
+class abcdtype (_AST):
+    pass
+
+class UnionType (abcdtype):
+    _fields = ('types',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, types=[], lineno=0, col_offset=0, **ARGS):
+        abcdtype.__init__(self, **ARGS)
+        self.types = list(types)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class IntersectionType (abcdtype):
+    _fields = ('types',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, types=[], lineno=0, col_offset=0, **ARGS):
+        abcdtype.__init__(self, **ARGS)
+        self.types = list(types)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class CrossType (abcdtype):
+    _fields = ('types',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, types=[], lineno=0, col_offset=0, **ARGS):
+        abcdtype.__init__(self, **ARGS)
+        self.types = list(types)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class ListType (abcdtype):
+    _fields = ('items',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, items, lineno=0, col_offset=0, **ARGS):
+        abcdtype.__init__(self, **ARGS)
+        self.items = items
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class TupleType (abcdtype):
+    _fields = ('items',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, items, lineno=0, col_offset=0, **ARGS):
+        abcdtype.__init__(self, **ARGS)
+        self.items = items
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class SetType (abcdtype):
+    _fields = ('items',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, items, lineno=0, col_offset=0, **ARGS):
+        abcdtype.__init__(self, **ARGS)
+        self.items = items
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class DictType (abcdtype):
+    _fields = ('keys', 'values')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, keys, values, lineno=0, col_offset=0, **ARGS):
+        abcdtype.__init__(self, **ARGS)
+        self.keys = keys
+        self.values = values
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class EnumType (abcdtype):
+    _fields = ('items',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, items=[], lineno=0, col_offset=0, **ARGS):
+        abcdtype.__init__(self, **ARGS)
+        self.items = list(items)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class NamedType (abcdtype):
+    _fields = ('name',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, lineno=0, col_offset=0, **ARGS):
+        abcdtype.__init__(self, **ARGS)
+        self.name = name
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class excepthandler (_AST):
+    pass
+
+class ExceptHandler (excepthandler):
+    _fields = ('type', 'name', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, type=None, name=None, body=[], lineno=0, col_offset=0, **ARGS):
+        excepthandler.__init__(self, **ARGS)
+        self.type = type
+        self.name = name
+        self.body = list(body)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class arguments (_AST):
+    _fields = ('args', 'vararg', 'varargannotation', 'kwonlyargs', 'kwarg', 'kwargannotation', 'defaults', 'kw_defaults')
+    _attributes = ()
+    def __init__ (self, args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[], **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.args = list(args)
+        self.vararg = vararg
+        self.varargannotation = varargannotation
+        self.kwonlyargs = list(kwonlyargs)
+        self.kwarg = kwarg
+        self.kwargannotation = kwargannotation
+        self.defaults = list(defaults)
+        self.kw_defaults = list(kw_defaults)

+"""
+>>> testparser(Translator)
+"""
+
+import operator, sys
+import snakes
+from snakes.lang.python.parser import (ParseTree, ParseTestParser,
+                                       Translator as PyTranslator,
+                                       ParseTree as PyParseTree,
+                                       testparser)
+from snakes.lang.pgen import ParseError
+from snakes.lang.abcd.pgen import parser
+import snakes.lang.abcd.asdl as ast
+
+_symbols = parser.tokenizer.tok_name.copy()
+# next statement overrides 'NT_OFFSET' entry with 'single_input'
+# (this is desired)
+_symbols.update(parser.symbolMap)
+
+def skip (token) :
+    if token.kind == token.lexer.COMMENT :
+        words = token.strip().split()
+        if words[:2] == ["#", "coding="] :
+            coding = words[2]
+        elif words[:3] == ["#", "-*-", "coding:"] :
+            coding = words[3]
+        else :
+            return
+        snakes.defaultencoding = coding
+
+parser.tokenizer.skip_token = skip
+
+class ParseTree (PyParseTree) :
+    _symbols = _symbols
+
+class Translator (PyTranslator) :
+    ParseTree = ParseTree
+    parser = parser
+    ST = ast
+    def do_file_input (self, st, ctx) :
+        """file_input: abcd_main ENDMARKER
+        -> ast.AbcdSpec
+
+        <<< symbol FOO, BAR
+        ... [egg+(spam) if spam == ham] ; [spam-(FOO, BAR)]
+        "AbcdSpec(context=[AbcdSymbol(symbols=['FOO', 'BAR'])], body=AbcdFlowOp(left=AbcdAction(accesses=[SimpleAccess(buffer='egg', arc=Produce(), tokens=Name(id='spam', ctx=Load()))], guard=Compare(left=Name(id='spam', ctx=Load()), ops=[Eq()], comparators=[Name(id='ham', ctx=Load())])), op=Sequence(), right=AbcdAction(accesses=[SimpleAccess(buffer='spam', arc=Consume(), tokens=Tuple(elts=[Name(id='FOO', ctx=Load()), Name(id='BAR', ctx=Load())], ctx=Load()))], guard=Name(id='True', ctx=Load()))), asserts=[])"
+        """
+        return self.do(st[0])
+    def do_abcd_main (self, st, ctx) :
+        """abcd_main: (NEWLINE | abcd_global)* abcd_expr (abcd_prop)*
+        -> ast.AbcdSpec
+
+        <<< symbol FOO, BAR
+        ... [egg+(spam) if spam == ham] ; [spam-(FOO, BAR)]
+        "AbcdSpec(context=[AbcdSymbol(symbols=['FOO', 'BAR'])], body=AbcdFlowOp(left=AbcdAction(accesses=[SimpleAccess(buffer='egg', arc=Produce(), tokens=Name(id='spam', ctx=Load()))], guard=Compare(left=Name(id='spam', ctx=Load()), ops=[Eq()], comparators=[Name(id='ham', ctx=Load())])), op=Sequence(), right=AbcdAction(accesses=[SimpleAccess(buffer='spam', arc=Consume(), tokens=Tuple(elts=[Name(id='FOO', ctx=Load()), Name(id='BAR', ctx=Load())], ctx=Load()))], guard=Name(id='True', ctx=Load()))), asserts=[])"
+        """
+        expr = len(st)-1
+        for i, child in enumerate(st) :
+            if child.symbol == "abcd_expr" :
+                expr = i
+                break
+        return self.ST.AbcdSpec(lineno=st.srow, col_offset=st.scol,
+                                context=[self.do(child) for child in st[:expr]
+                                         if child.kind != self.NEWLINE],
+                                body=self.do(st[expr]),
+                                asserts=[self.do(child) for child in st[expr+1:]])
+    def do_abcd_prop (self, st, ctx) :
+        """abcd_prop: 'assert' test (NEWLINE)*
+        -> ast.test
+
+        <<< [True]
+        ... assert True
+        ... assert False
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[Name(id='True', ctx=Load()), Name(id='False', ctx=Load())])"
+        """
+        return self.do(st[1])
+    def do_abcd_global (self, st, ctx) :
+        """abcd_global: (import_stmt | abcd_symbol | abcd_typedef
+               | abcd_const | abcd_decl)
+        -> ast.AST
+
+        <<< import module
+        ... from module import content
+        ... symbol EGG, SPAM, HAM
+        ... typedef t : enum(EGG, SPAM, HAM)
+        ... net Foo() : [True]
+        ... buffer bar : t = ()
+        ... [True]
+        "AbcdSpec(context=[Import(names=[alias(name='module', asname=None)]), ImportFrom(module='module', names=[alias(name='content', asname=None)], level=0), AbcdSymbol(symbols=['EGG', 'SPAM', 'HAM']), AbcdTypedef(name='t', type=EnumType(items=[Name(id='EGG', ctx=Load()), Name(id='SPAM', ctx=Load()), Name(id='HAM', ctx=Load())])), AbcdNet(name='Foo', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[])), AbcdBuffer(name='bar', type=NamedType(name='t'), capacity=None, content=Tuple(elts=[], ctx=Load()))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        """
+        return self.do(st[0])
+    def do_abcd_spec (self, st, ctx) :
+        """abcd_spec: (NEWLINE | abcd_decl)* abcd_expr
+        -> ast.AbcdSpec
+
+        <<< net Foo () :
+        ...     buffer bar : spam = ()
+        ...     net Bar () : [False]
+        ...     [True]
+        ... Foo()
+        "AbcdSpec(context=[AbcdNet(name='Foo', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=AbcdSpec(context=[AbcdBuffer(name='bar', type=NamedType(name='spam'), capacity=None, content=Tuple(elts=[], ctx=Load())), AbcdNet(name='Bar', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=False), asserts=[]))], body=AbcdAction(accesses=[], guard=True), asserts=[]))], body=AbcdInstance(net='Foo', asname=None, args=[], keywords=[], starargs=None, kwargs=None), asserts=[])"
+        """
+        tree = self.do_abcd_main(st, ctx)
+        tree.st = st
+        return tree
+    def do_abcd_decl (self, st, ctx) :
+        """abcd_decl: abcd_net | abcd_task | abcd_buffer
+        -> ast.AST
+
+        <<< net Foo () :
+        ...     buffer bar : spam = ()
+        ...     net Bar () : [False]
+        ...     [True]
+        ... Foo()
+        "AbcdSpec(context=[AbcdNet(name='Foo', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=AbcdSpec(context=[AbcdBuffer(name='bar', type=NamedType(name='spam'), capacity=None, content=Tuple(elts=[], ctx=Load())), AbcdNet(name='Bar', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=False), asserts=[]))], body=AbcdAction(accesses=[], guard=True), asserts=[]))], body=AbcdInstance(net='Foo', asname=None, args=[], keywords=[], starargs=None, kwargs=None), asserts=[])"
+        """
+        tree = self.do_abcd_global(st, ctx)
+        tree.st = st
+        return tree
+    def do_abcd_const (self, st, ctx) :
+        """abcd_const: 'const' NAME '=' testlist
+        -> ast.AbcdConst
+
+        <<< const FOO = 5
+        ... [True]
+        "AbcdSpec(context=[AbcdConst(name='FOO', value=Num(n=5))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< const FOO = 1, 2, 3
+        ... [True]
+        "AbcdSpec(context=[AbcdConst(name='FOO', value=Tuple(elts=[Num(n=1), Num(n=2), Num(n=3)], ctx=Load()))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        """
+        return self.ST.AbcdConst(lineno=st.srow, col_offset=st.scol,
+                                 name=st[1].text, value=self.do(st[3], ctx))
+    def do_abcd_symbol (self, st, ctx) :
+        """abcd_symbol: 'symbol' abcd_namelist
+        -> ast.AbcdSymbol
+
+        <<< symbol FOO
+        ... [True]
+        "AbcdSpec(context=[AbcdSymbol(symbols=['FOO'])], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< symbol FOO, BAR
+        ... [True]
+        "AbcdSpec(context=[AbcdSymbol(symbols=['FOO', 'BAR'])], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        """
+        return self.ST.AbcdSymbol(lineno=st.srow, col_offset=st.scol,
+                                  symbols=self.do(st[1]))
+    def do_abcd_namelist (self, st, ctx) :
+        """abcd_namelist: NAME (',' NAME)*
+        -> str+
+
+        <<< symbol FOO
+        ... [True]
+        "AbcdSpec(context=[AbcdSymbol(symbols=['FOO'])], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< symbol FOO, BAR
+        ... [True]
+        "AbcdSpec(context=[AbcdSymbol(symbols=['FOO', 'BAR'])], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        """
+        return [child.text for child in st[::2]]
+    def _do_flowop (self, st, op) :
+        nodes = [self.do(child) for child in st[::2]]
+        while len(nodes) > 1 :
+            left = nodes.pop(0)
+            right = nodes.pop(0)
+            nodes.insert(0, self.ST.AbcdFlowOp(lineno=left.lineno,
+                                               col_offset=left.col_offset,
+                                               left=left, op=op(), right=right))
+        return nodes[0]
+    def do_abcd_expr (self, st, ctx) :
+        """abcd_expr: abcd_choice_expr ('|' abcd_choice_expr)*
+        -> ast.process
+
+        <<< [True]
+        'AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[])'
+        <<< [True] | [False]
+        'AbcdSpec(context=[], body=AbcdFlowOp(left=AbcdAction(accesses=[], guard=True), op=Parallel(), right=AbcdAction(accesses=[], guard=False)), asserts=[])'
+        <<< [True] | [False] | [True]
+        'AbcdSpec(context=[], body=AbcdFlowOp(left=AbcdFlowOp(left=AbcdAction(accesses=[], guard=True), op=Parallel(), right=AbcdAction(accesses=[], guard=False)), op=Parallel(), right=AbcdAction(accesses=[], guard=True)), asserts=[])'
+
+        """
+        return self._do_flowop(st, self.ST.Parallel)
+    def do_abcd_choice_expr (self, st, ctx) :
+        """abcd_choice_expr: abcd_iter_expr ('+' abcd_iter_expr)*
+        -> ast.process
+
+        <<< [True]
+        'AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[])'
+        <<< [True] + [False]
+        'AbcdSpec(context=[], body=AbcdFlowOp(left=AbcdAction(accesses=[], guard=True), op=Choice(), right=AbcdAction(accesses=[], guard=False)), asserts=[])'
+        <<< [True] + [False] + [True]
+        'AbcdSpec(context=[], body=AbcdFlowOp(left=AbcdFlowOp(left=AbcdAction(accesses=[], guard=True), op=Choice(), right=AbcdAction(accesses=[], guard=False)), op=Choice(), right=AbcdAction(accesses=[], guard=True)), asserts=[])'
+        """
+        return self._do_flowop(st, self.ST.Choice)
+    def do_abcd_iter_expr (self, st, ctx) :
+        """abcd_iter_expr: abcd_seq_expr ('*' abcd_seq_expr)*
+        -> ast.process
+
+        <<< [True]
+        'AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[])'
+        <<< [True] * [False]
+        'AbcdSpec(context=[], body=AbcdFlowOp(left=AbcdAction(accesses=[], guard=True), op=Loop(), right=AbcdAction(accesses=[], guard=False)), asserts=[])'
+        <<< [True] * [False] * [True]
+        'AbcdSpec(context=[], body=AbcdFlowOp(left=AbcdFlowOp(left=AbcdAction(accesses=[], guard=True), op=Loop(), right=AbcdAction(accesses=[], guard=False)), op=Loop(), right=AbcdAction(accesses=[], guard=True)), asserts=[])'
+        """
+        return self._do_flowop(st, self.ST.Loop)
+    def do_abcd_seq_expr (self, st, ctx) :
+        """abcd_seq_expr: abcd_base_expr (';' abcd_base_expr)*
+        -> ast.process
+
+        <<< [True]
+        'AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[])'
+        <<< [True] ; [False]
+        'AbcdSpec(context=[], body=AbcdFlowOp(left=AbcdAction(accesses=[], guard=True), op=Sequence(), right=AbcdAction(accesses=[], guard=False)), asserts=[])'
+        <<< [True] ; [False] ; [True]
+        'AbcdSpec(context=[], body=AbcdFlowOp(left=AbcdFlowOp(left=AbcdAction(accesses=[], guard=True), op=Sequence(), right=AbcdAction(accesses=[], guard=False)), op=Sequence(), right=AbcdAction(accesses=[], guard=True)), asserts=[])'
+        """
+        return self._do_flowop(st, self.ST.Sequence)
+    def do_abcd_base_expr (self, st, ctx) :
+        """abcd_base_expr: (abcd_action | '(' abcd_expr ')') (NEWLINE)*
+        -> ast.process
+
+        <<< [True]
+        'AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[])'
+        <<< ([True])
+        'AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[])'
+        """
+        if st[0].text == "(" :
+            return self.do(st[1])
+        else :
+            return self.do(st[0])
+    def do_abcd_action (self, st, ctx) :
+        """abcd_action: ('[' 'True' ']' | '[' 'False' ']' |
+                         '[' abcd_access_list ['if' test] ']' |
+                         abcd_instance)
+        -> ast.AbcdAction | ast.AbcdInstance
+
+        <<< [True]
+        'AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[])'
+        <<< [False]
+        'AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=False), asserts=[])'
+        <<< Foo(1, 2)
+        "AbcdSpec(context=[], body=AbcdInstance(net='Foo', asname=None, args=[Num(n=1), Num(n=2)], keywords=[], starargs=None, kwargs=None), asserts=[])"
+        """
+        if len(st) == 1 :
+            return self.do(st[0])
+        elif st[1].text == "True" :
+            return self.ST.AbcdAction(lineno=st.srow, col_offset=st.scol,
+                                      accesses=[], guard=True)
+        elif st[1].text == "False" :
+            return self.ST.AbcdAction(lineno=st.srow, col_offset=st.scol,
+                                      accesses=[], guard=False)
+        elif len(st) == 3 :
+            return self.ST.AbcdAction(lineno=st.srow, col_offset=st.scol,
+                                      accesses=self.do(st[1]),
+                                      guard=self.ST.Name(lineno=st[-1].srow,
+                                                         col_offset=st[-1].scol,
+                                                         id="True",
+                                                         ctx=self.ST.Load()))
+        else :
+            return self.ST.AbcdAction(lineno=st.srow, col_offset=st.scol,
+                                      accesses=self.do(st[1]),
+                                      guard=self.do(st[3]))
+    def do_abcd_access_list (self, st, ctx) :
+        """abcd_access_list: abcd_access (',' abcd_access)*
+        -> ast.access+
+
+        <<< [foo-(1)]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[SimpleAccess(buffer='foo', arc=Consume(), tokens=Num(n=1))], guard=Name(id='True', ctx=Load())), asserts=[])"
+        <<< [foo-(1), bar+(2)]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[SimpleAccess(buffer='foo', arc=Consume(), tokens=Num(n=1)), SimpleAccess(buffer='bar', arc=Produce(), tokens=Num(n=2))], guard=Name(id='True', ctx=Load())), asserts=[])"
+        """
+        return [self.do(child) for child in st[::2]]
+    _arc = {"+" : ast.Produce,
+            "-" : ast.Consume,
+            "?" : ast.Test,
+            "<<" : ast.Fill}
+    def do_abcd_access (self, st, ctx) :
+        """abcd_access: (NAME '+' '(' testlist ')' |
+              NAME '?' '(' testlist ')' |
+              NAME '-' '(' testlist ')' |
+              NAME '<>' '(' testlist '=' testlist ')' |
+              NAME '>>' '(' NAME ')' |
+              NAME '<<' '(' testlist_comp ')' |
+              NAME '.' NAME '(' test (',' test)* ')')
+        -> ast.access
+
+        <<< [egg+(x), spam-(y), ham?(z), foo<<(bar)]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[SimpleAccess(buffer='egg', arc=Produce(), tokens=Name(id='x', ctx=Load())), SimpleAccess(buffer='spam', arc=Consume(), tokens=Name(id='y', ctx=Load())), SimpleAccess(buffer='ham', arc=Test(), tokens=Name(id='z', ctx=Load())), SimpleAccess(buffer='foo', arc=Fill(), tokens=Name(id='bar', ctx=Load()))], guard=Name(id='True', ctx=Load())), asserts=[])"
+        <<< [foo<<(spam(egg) for egg in ham)]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[SimpleAccess(buffer='foo', arc=Fill(), tokens=ListComp(elt=Call(func=Name(id='spam', ctx=Load()), args=[Name(id='egg', ctx=Load())], keywords=[], starargs=None, kwargs=None), generators=[comprehension(target=Name(id='egg', ctx=Store()), iter=Name(id='ham', ctx=Load()), ifs=[])]))], guard=Name(id='True', ctx=Load())), asserts=[])"
+        <<< [bar-(l), foo<<(l)]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[SimpleAccess(buffer='bar', arc=Consume(), tokens=Name(id='l', ctx=Load())), SimpleAccess(buffer='foo', arc=Fill(), tokens=Name(id='l', ctx=Load()))], guard=Name(id='True', ctx=Load())), asserts=[])"
+        <<< [bar-(l), foo<<(l,)]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[SimpleAccess(buffer='bar', arc=Consume(), tokens=Name(id='l', ctx=Load())), SimpleAccess(buffer='foo', arc=Fill(), tokens=Tuple(elts=[Name(id='l', ctx=Load())], ctx=Load()))], guard=Name(id='True', ctx=Load())), asserts=[])"
+        <<< [spam>>(ham) if spam is egg]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[FlushAccess(buffer='spam', target='ham')], guard=Compare(left=Name(id='spam', ctx=Load()), ops=[Is()], comparators=[Name(id='egg', ctx=Load())])), asserts=[])"
+        <<< [count<>(n = n+1)]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[SwapAccess(buffer='count', target=Name(id='n', ctx=Load()), tokens=BinOp(left=Name(id='n', ctx=Load()), op=Add(), right=Num(n=1)))], guard=Name(id='True', ctx=Load())), asserts=[])"
+        <<< [foo.spawn(child, 1, 2, 3)]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[Spawn(net='foo', pid=Name(id='child', ctx=Load()), args=[Num(n=1), Num(n=2), Num(n=3)])], guard=Name(id='True', ctx=Load())), asserts=[])"
+        <<< [foo.wait(child, y, z)]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[Wait(net='foo', pid=Name(id='child', ctx=Load()), args=[Name(id='y', ctx=Load()), Name(id='z', ctx=Load())])], guard=Name(id='True', ctx=Load())), asserts=[])"
+        <<< [foo.suspend(pid)]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[Suspend(net='foo', pid=Name(id='pid', ctx=Load()))], guard=Name(id='True', ctx=Load())), asserts=[])"
+        <<< [foo.resume(pid)]
+        "AbcdSpec(context=[], body=AbcdAction(accesses=[Resume(net='foo', pid=Name(id='pid', ctx=Load()))], guard=Name(id='True', ctx=Load())), asserts=[])"
+        """
+        if st[1].text in ("+", "?", "-") :
+            return self.ST.SimpleAccess(lineno=st.srow, col_offset=st.scol,
+                                        buffer=st[0].text,
+                                        arc=self._arc[st[1].text](),
+                                        tokens=self.do(st[3]))
+        elif st[1].text == "<<" :
+            loop, elts, atom = self.do(st[3], ctx)
+            if atom is not None :
+                args = atom
+            elif loop is None :
+                args = self.ST.Tuple(lineno=st.srow, col_offset=st.scol,
+                                     elts=elts, ctx=ctx())
+            else :
+                args = self.ST.ListComp(lineno=st.srow, col_offset=st.scol,
+                                        elt=loop, generators=elts)
+            return self.ST.SimpleAccess(lineno=st.srow, col_offset=st.scol,
+                                        buffer=st[0].text,
+                                        arc=self._arc[st[1].text](),
+                                        tokens=args)
+        elif st[1].text == ">>" :
+            return self.ST.FlushAccess(lineno=st.srow, col_offset=st.scol,
+                                       buffer=st[0].text,
+                                       target=st[3].text)
+        elif st[1].text == "<>" :
+            return self.ST.SwapAccess(lineno=st.srow, col_offset=st.scol,
+                                      buffer=st[0].text,
+                                      target=self.do(st[3]),
+                                      tokens=self.do(st[5]))
+        elif st[2].text in ("suspend", "resume") : # st[1].text == "."
+            if len(st) > 6 :
+                raise ParseError(st.text, reason="too many arguments for %s"
+                                 % st[2].text)
+            if st[2].text == "suspend" :
+                tree = self.ST.Suspend
+            else :
+                tree = self.ST.Resume
+            return tree(lineno=st.srow, col_offset=st.scol,
+                        net=st[0].text,
+                        pid=self.do(st[4]))
+        elif st[2].text in ("spawn", "wait") : # st[1].text == "."
+            if len(st) > 6 :
+                args = [self.do(child) for child in st[6:-1:2]]
+            else :
+                args = []
+            if st[2].text == "spawn" :
+                tree = self.ST.Spawn
+            else :
+                tree = self.ST.Wait
+            return tree(lineno=st.srow, col_offset=st.scol,
+                        net=st[0].text,
+                        pid=self.do(st[4]),
+                        args=args)
+        else :
+            raise ParseError(st[2].text, reason=("expected 'spawn', 'wait', "
+                             "'suspend' or 'resume', but found '%s'")
+                             % st[2].text)
+    def do_abcd_instance (self, st, ctx) :
+        """abcd_instance: [NAME ':' ':'] NAME '(' [arglist] ')'
+        -> ast.AbcdInstance
+
+        <<< sub()
+        "AbcdSpec(context=[], body=AbcdInstance(net='sub', asname=None, args=[], keywords=[], starargs=None, kwargs=None), asserts=[])"
+        <<< sub(1, 2, 3)
+        "AbcdSpec(context=[], body=AbcdInstance(net='sub', asname=None, args=[Num(n=1), Num(n=2), Num(n=3)], keywords=[], starargs=None, kwargs=None), asserts=[])"
+        <<< sub(1, *l)
+        "AbcdSpec(context=[], body=AbcdInstance(net='sub', asname=None, args=[Num(n=1)], keywords=[], starargs=Name(id='l', ctx=Load()), kwargs=None), asserts=[])"
+        <<< sub(1, **d)
+        "AbcdSpec(context=[], body=AbcdInstance(net='sub', asname=None, args=[Num(n=1)], keywords=[], starargs=None, kwargs=Name(id='d', ctx=Load())), asserts=[])"
+        <<< sub(a=1, b=2)
+        "AbcdSpec(context=[], body=AbcdInstance(net='sub', asname=None, args=[], keywords=[keyword(arg='a', value=Num(n=1)), keyword(arg='b', value=Num(n=2))], starargs=None, kwargs=None), asserts=[])"
+        <<< foo::sub()
+        "AbcdSpec(context=[], body=AbcdInstance(net='sub', asname='foo', args=[], keywords=[], starargs=None, kwargs=None), asserts=[])"
+        <<< foo::sub(1, 2)
+        "AbcdSpec(context=[], body=AbcdInstance(net='sub', asname='foo', args=[Num(n=1), Num(n=2)], keywords=[], starargs=None, kwargs=None), asserts=[])"
+        """
+        if len(st) in (3, 6) :
+            args, keywords, starargs, kwargs = [], [], None, None
+        else :
+            args, keywords, starargs, kwargs = self.do(st[-2])
+        if st[1].text == ':' :
+            net = st[3].text
+            asname = st[0].text
+        else :
+            net = st[0].text
+            asname = None
+        return self.ST.AbcdInstance(lineno=st.srow, col_offset=st.scol,
+                                    net=net, asname=asname, args=args,
+                                    keywords=keywords, starargs=starargs,
+                                    kwargs=kwargs)
+    def do_abcd_net (self, st, ctx) :
+        """abcd_net: 'net' NAME parameters ':' abcd_suite
+        -> ast.AbcdNet
+
+        <<< net Foo () : [True]
+        ... [False]
+        "AbcdSpec(context=[AbcdNet(name='Foo', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[]))], body=AbcdAction(accesses=[], guard=False), asserts=[])"
+        <<< net Foo (x, y) : [True]
+        ... [False]
+        "AbcdSpec(context=[AbcdNet(name='Foo', args=arguments(args=[arg(arg='x', annotation=None), arg(arg='y', annotation=None)], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[]))], body=AbcdAction(accesses=[], guard=False), asserts=[])"
+        """
+        params = self.do(st[2])
+        return self.ST.AbcdNet(lineno=st.srow, col_offset=st.scol,
+                               name=st[1].text,
+                               args=params,
+                               body=self.do(st[4]))
+    def do_abcd_task (self, st, ctx) :
+        """abcd_task: 'task' NAME typelist '-' '>' typelist ':' abcd_suite
+        -> ast.AbcdTask
+
+        <<< task Foo (int) -> () : [True]
+        ... [False]
+        "AbcdSpec(context=[AbcdTask(name='Foo', body=AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[]), input=[NamedType(name='int')], output=[])], body=AbcdAction(accesses=[], guard=False), asserts=[])"
+        """
+        return self.ST.AbcdTask(lineno=st.srow, col_offset=st.scol,
+                                name=st[1].text,
+                                body=self.do(st[-1]),
+                                input=self.do(st[2]),
+                                output=self.do(st[5]))
+    def do_typelist (self, st, ctx) :
+        """typelist: '(' [abcd_type (',' abcd_type)*] ')'
+        -> ast.abcdtype*
+
+        <<< task Foo () -> (int, int, int|bool) : [True]
+        ... [False]
+        "AbcdSpec(context=[AbcdTask(name='Foo', body=AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[]), input=[], output=[NamedType(name='int'), NamedType(name='int'), UnionType(types=[NamedType(name='int'), NamedType(name='bool')])])], body=AbcdAction(accesses=[], guard=False), asserts=[])"
+        """
+        return [self.do(child) for child in st[1:-1:2]]
+    def do_abcd_suite (self, st, ctx) :
+        """abcd_suite: abcd_expr | NEWLINE INDENT abcd_spec DEDENT
+        -> ast.AbcdSpec
+
+        <<< net Foo () :
+        ...    [True]
+        ... [False]
+        "AbcdSpec(context=[AbcdNet(name='Foo', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[]))], body=AbcdAction(accesses=[], guard=False), asserts=[])"
+        <<< net Foo () : ([True]
+        ...     + [False])
+        ... [False]
+        "AbcdSpec(context=[AbcdNet(name='Foo', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=AbcdSpec(context=[], body=AbcdFlowOp(left=AbcdAction(accesses=[], guard=True), op=Choice(), right=AbcdAction(accesses=[], guard=False)), asserts=[]))], body=AbcdAction(accesses=[], guard=False), asserts=[])"
+        """
+        if len(st) == 1 :
+            return self.ST.AbcdSpec(lineno=st.srow, col_offset=st.scol,
+                                    context=[],
+                                    body=self.do(st[0]))
+        else :
+            return self.do(st[2])
+    def do_abcd_buffer (self, st, ctx) :
+        """[ decorators ] 'buffer' NAME ['[' test ']'] ':' abcd_type '=' testlist
+        -> ast.AbcdBuffer
+
+        <<< buffer foo : int = ()
+        ... [True]
+        "AbcdSpec(context=[AbcdBuffer(name='foo', type=NamedType(name='int'), capacity=None, content=Tuple(elts=[], ctx=Load()))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< buffer foo : int = 1, 2
+        ... [True]
+        "AbcdSpec(context=[AbcdBuffer(name='foo', type=NamedType(name='int'), capacity=None, content=Tuple(elts=[Num(n=1), Num(n=2)], ctx=Load()))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< buffer foo : int|bool = ()
+        ... [True]
+        "AbcdSpec(context=[AbcdBuffer(name='foo', type=UnionType(types=[NamedType(name='int'), NamedType(name='bool')]), capacity=None, content=Tuple(elts=[], ctx=Load()))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< @capacity(max=5)
+        ... buffer foo : int = ()
+        ... [True]
+        "AbcdSpec(context=[AbcdBuffer(name='foo', type=NamedType(name='int'), capacity=[None, Num(n=5)], content=Tuple(elts=[], ctx=Load()))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< @capacity(min=2)
+        ... buffer foo : int = ()
+        ... [True]
+        "AbcdSpec(context=[AbcdBuffer(name='foo', type=NamedType(name='int'), capacity=[Num(n=2), None], content=Tuple(elts=[], ctx=Load()))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< @capacity(min=2, max=5)
+        ... buffer foo : int = ()
+        ... [True]
+        "AbcdSpec(context=[AbcdBuffer(name='foo', type=NamedType(name='int'), capacity=[Num(n=2), Num(n=5)], content=Tuple(elts=[], ctx=Load()))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        """
+        if len(st) == 6 : # no decorator, no array
+            return self.ST.AbcdBuffer(lineno=st.srow, col_offset=st.scol,
+                                      name=st[1].text,
+                                      type=self.do(st[3]),
+                                      capacity=None,
+                                      content=self.do(st[-1]))
+        elif len(st) == 7 : # decorator, no array
+            deco = self.do_buffer_decorators(st[0], ctx)
+            return self.ST.AbcdBuffer(lineno=st.srow, col_offset=st.scol,
+                                      name=st[2].text,
+                                      type=self.do(st[4]),
+                                      capacity=deco["capacity"],
+                                      content=self.do(st[-1]))
+        else :
+            raise ParseError(st.text,
+                             reason="arrays not (yet) supported")
+    def do_buffer_decorators (self, st, ctx) :
+        deco = {}
+        for child in st :
+            tree = self.do(child)
+            if isinstance(tree, self.ST.Call) and tree.func.id == "capacity" :
+                if tree.args or tree.starargs or tree.kwargs :
+                    raise ParseError(child, reason="invalid parameters")
+                min, max = None, None
+                for kw in tree.keywords :
+                    if kw.arg == "min" :
+                        min = kw.value
+                    elif kw.arg == "max" :
+                        max = kw.value
+                    else :
+                        raise ParseError(child,
+                                         reason="invalid parameter %r" % kw.arg)
+                if min or max :
+                    deco["capacity"] = [min, max]
+                else :
+                    deco["capacity"] = None
+                continue
+            raise ParseError(child, reason="invalid buffer decorator")
+        return deco
+    def do_abcd_typedef (self, st, ctx) :
+        """abcd_typedef: 'typedef' NAME ':' abcd_type
+        -> ast.AbcdTypedef
+
+        <<< typedef foo : int
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=NamedType(name='int'))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        """
+        return self.ST.AbcdTypedef(lineno=st.srow, col_offset=st.scol,
+                                   name=st[1].text,
+                                   type=self.do(st[3]))
+    def do_abcd_type (self, st, ctx) :
+        """abcd_type: abcd_and_type ('|' abcd_and_type)*
+        -> snakes.typing.Type
+
+        <<< typedef foo : int
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=NamedType(name='int'))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< typedef foo : int | bool
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=UnionType(types=[NamedType(name='int'), NamedType(name='bool')]))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        """
+        if len(st) == 1 :
+            return self.do(st[0])
+        else :
+            return self.ST.UnionType(lineno=st.srow, col_offset=st.scol,
+                                     types=[self.do(child) for child in st[::2]])
+    def do_abcd_and_type (self, st, ctx) :
+        """abcd_and_type: abcd_cross_type ('&' abcd_cross_type)*
+        -> snakes.typing.Type
+
+        <<< typedef foo : int
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=NamedType(name='int'))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< typedef foo : int & bool
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=IntersectionType(types=[NamedType(name='int'), NamedType(name='bool')]))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        """
+        if len(st) == 1 :
+            return self.do(st[0])
+        else :
+            return self.ST.IntersectionType(lineno=st.srow, col_offset=st.scol,
+                                            types=[self.do(child) for child in st[::2]])
+    def do_abcd_cross_type (self, st, ctx) :
+        """abcd_cross_type: abcd_base_type ('*' abcd_base_type)*
+        -> snakes.typing.Type
+
+        <<< typedef foo : int
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=NamedType(name='int'))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< typedef foo : int * bool
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=CrossType(types=[NamedType(name='int'), NamedType(name='bool')]))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        """
+        if len(st) == 1 :
+            return self.do(st[0])
+        else :
+            return self.ST.CrossType(lineno=st.srow, col_offset=st.scol,
+                                     types=[self.do(child) for child in st[::2]])
+    def do_abcd_base_type (self, st, ctx) :
+        """abcd_base_type: (NAME ['(' abcd_type (',' abcd_type)* ')']
+                 | 'enum' '(' test (',' test)* ')' | '(' abcd_type ')')
+        -> snakes.typing.Type
+
+        <<< typedef foo : list(int)
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=ListType(items=NamedType(name='int')))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< typedef foo : set(int)
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=SetType(items=NamedType(name='int')))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< typedef foo : dict(int, bool)
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=DictType(keys=NamedType(name='int'), values=NamedType(name='bool')))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< typedef foo : enum(1, 2, 3)
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=EnumType(items=[Num(n=1), Num(n=2), Num(n=3)]))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        <<< typedef foo : int
+        ... [True]
+        "AbcdSpec(context=[AbcdTypedef(name='foo', type=NamedType(name='int'))], body=AbcdAction(accesses=[], guard=True), asserts=[])"
+        """
+        if len(st) == 1 :
+            return self.ST.NamedType(lineno=st.srow, col_offset=st.scol,
+                                     name=st[0].text)
+        elif len(st) == 3 :
+            return self.do(st[1])
+        elif st[0].text in ("list", "set", "tuple") :
+            if len(st) > 4 :
+                raise ParseError(st.text,
+                                 reason="too many arguments for %s type"
+                                 % st[0].text)
+            if st[0].text == "list" :
+                tree = self.ST.ListType
+            elif st[0].text == "tuple" :
+                tree = self.ST.TupleType
+            else :
+                tree = self.ST.SetType
+            return tree(lineno=st.srow, col_offset=st.scol,
+                        items=self.do(st[2]))
+        elif st[0].text == "dict" :
+            if len(st) > 6 :
+                raise ParseError(st.text,
+                                 reason="too many arguments for dict type")
+            return self.ST.DictType(lineno=st.srow, col_offset=st.scol,
+                                    keys=self.do(st[2]),
+                                    values=self.do(st[4]))
+        elif st[0].text == "enum" :
+            return self.ST.EnumType(lineno=st.srow, col_offset=st.scol,
+                                    items=[self.do(child) for child in st[2:-1:2]])
+        else :
+            raise ParseError(st[0].text,
+                             reason=("expected 'enum', 'list', 'set' or"
+                                     " 'dict' but found '%s'") % st[0].text)
+    def do_tfpdef (self, st, ctx) :
+        """tfpdef: NAME [':' ('net' | 'buffer' | 'task')]
+        -> str, ast.AST?
+
+        <<< net Foo (x, y, n:net, b:buffer, t:task) : [True]
+        ... [False]
+        "AbcdSpec(context=[AbcdNet(name='Foo', args=arguments(args=[arg(arg='x', annotation=None), arg(arg='y', annotation=None), arg(arg='n', annotation=Name(id='net', ctx=Load())), arg(arg='b', annotation=Name(id='buffer', ctx=Load())), arg(arg='t', annotation=Name(id='task', ctx=Load()))], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=AbcdSpec(context=[], body=AbcdAction(accesses=[], guard=True), asserts=[]))], body=AbcdAction(accesses=[], guard=False), asserts=[])"
+        """
+        if len(st) == 1 :
+            return st[0].text, None
+        else :
+            return st[0].text, self.ST.Name(lineno=st[2].srow,
+                                            col_offset=st[2].scol,
+                                            id=st[2].text,
+                                            ctx=ctx())
+
+parse = Translator.parse
+
+if __name__ == "__main__" :
+    testparser(Translator)

+import sys, datetime
+from snakes.lang.pylib import asdl
+from collections import defaultdict
+from functools import partial
+
+class memoize(object):
+    def __init__(self, function):
+        self.function = function
+        self.memoized = {}
+
+    def __call__(self, *args):
+        try:
+            return self.memoized[args]
+        except KeyError:
+            call = self.function(*args)
+            self.memoized[args] = call
+            return call
+
+    def __get__(self, obj, objtype):
+        """Support instance methods."""
+        return partial(self.__call__, obj)
+
+def component_has_cycle(node, graph, proceeding, visited):
+    if node in visited:
+        return False
+    if node in proceeding:
+        proceeding.append(node) # populate trace
+        return True
+    proceeding.append(node)
+    if node in graph:
+        for successor in graph[node]:
+            if component_has_cycle(successor, graph, proceeding, visited):
+                return True
+    proceeding.remove(node)
+    visited.add(node)
+    return False
+
+def has_cycle(graph):
+    visited = set()
+    proceeding = list()
+    todo = set(graph.keys())
+
+    while todo:
+        node = todo.pop()
+        if component_has_cycle(node, graph, proceeding, visited):
+            i = proceeding.index(proceeding[-1])
+            return proceeding[i:]
+        todo.difference_update(visited)
+    return []
+
+class CyclicDependencies(Exception):
+    def __init__(self, seq):
+        self.seq = seq
+
+    def __str__(self):
+        return "cyclic dependencies: {}".format(" -> ".join(self.seq))
+
+def remove_duplicates(l):
+    d = {}
+    nl = []
+    for e in l:
+        if not e in d:
+            d[e] = 1
+            nl.append(e)
+    return nl
+
+class CodeGen (asdl.VisitorBase) :
+
+    def __init__(self, node):
+        asdl.VisitorBase.__init__(self)
+
+        self.starting_node = None
+        self.current_node = None
+        self.hierarchy = defaultdict(list)
+        self.hierarchy['_AST'] = []
+        self.fields = defaultdict(list)
+        self.attributes = defaultdict(list)
+        self.code = defaultdict(list)
+
+        self.visit(node)
+        ret = has_cycle(self.hierarchy)
+        if ret:
+            raise CyclicDependencies(ret)
+        self._gen_code(node)
+
+    def visitModule(self, node):
+        for name, child in node.types.items():
+            if not self.starting_node:
+                self.starting_node = str(name)
+            self.current_node = str(name)
+            self.hierarchy[name]
+            self.visit(child)
+
+    def visitSum(self, node):
+        if hasattr(node, "fields"):
+            self.fields[self.current_node] = node.fields
+        else:
+            self.fields[self.current_node] = []
+        if hasattr(node, "attributes"):
+            self.attributes[self.current_node] = node.attributes
+        else:
+            self.attributes[self.current_node] = []
+
+        for child in node.types:
+            self.visit(child)
+
+    def visitConstructor (self, node):
+        if str(node.name) in self.fields:
+            #print >> sys.stderr, "constructor '{!s}' appears twice !".format(node.name)
+            #exit(0)
+            return
+        self.fields[str(node.name)].extend(node.fields)
+        self.hierarchy[str(node.name)].append(self.current_node)
+
+    def visitProduct(self, node):
+        self.fields[self.current_node].extend(node.fields)
+
+    @memoize
+    def _get_fields(self, name):
+        if self.fields.has_key(name):
+            fields = map(lambda f : f.name, self.fields[name])
+            for parent in self.hierarchy[name]:
+                fields.extend(self._get_fields(parent))
+            return fields
+        else:
+            return []
+
+    @memoize
+    def _get_attributes(self, name):
+        if name == '_AST':
+            return []
+        attributes = map(lambda a : a.name, self.attributes[name])
+        for parent in self.hierarchy[name]:
+            attributes.extend(self._get_attributes(parent))
+        return attributes
+
+    def _gen_code(self, node):
+        is_methods = []
+        for name in sorted(self.hierarchy):
+            if name != '_AST':
+                is_methods.extend(["",
+                                   "def is{!s}(self):".format(name),
+                                   ["return False"]
+                                  ])
+        cls = ["class _AST (ast.AST):",
+               ["_fields = ()",
+                "_attributes = ()",
+                "",
+                "def __init__ (self, **ARGS):",
+                ["ast.AST.__init__(self)",
+                 "for k, v in ARGS.items():",
+                 ["setattr(self, k, v)"]
+                ]
+               ] + is_methods
+              ]
+        self.code['_AST'] = cls
+
+        for name, parents in self.hierarchy.iteritems():
+            if name == '_AST':
+                continue
+            if not parents:
+                parents = ['_AST']
+            fields = self.fields[name]
+            args = []
+            assign = []
+            body = []
+            _fields = remove_duplicates(self._get_fields(name))
+            _attributes = remove_duplicates(self._get_attributes(name))
+
+            body = []
+            cls = ["class {!s} ({!s}):".format(name, ", ".join(parents)), body]
+
+            non_default_args = []
+            default_args = []
+            for f in fields:
+                if f.name.value == 'ctx':
+                    f.opt = True
+
+                if f.opt:
+                    default_args.append("{!s}=None".format(f.name))
+                    assign.append("self.{0!s} = {0!s}".format(f.name))
+                elif f.seq:
+                    default_args.append("{!s}=[]".format(f.name))
+                    assign.append("self.{0!s} = list({0!s})".format(f.name))
+                else:
+                    non_default_args.append("{!s}".format(f.name))
+                    assign.append("self.{0!s} = {0!s}".format(f.name))
+
+            args = non_default_args + default_args
+
+            body.append("_fields = {!r}".format( tuple(map(repr, _fields))))
+            body.append("_attributes = {!r}".format( tuple(map(repr, _attributes))))
+            body.append("")
+            # ctor
+            args_str = ", ".join(args)
+            if args_str != "":
+                args_str += ", "
+            body.append("def __init__ (self, {!s} **ARGS):".format(args_str))
+            ctor_body = []
+            body.append(ctor_body)
+            ctor_body.extend(map(lambda base : "{!s}.__init__(self, **ARGS)".format(base), parents))
+            ctor_body.extend(assign)
+
+            body.extend(["", "def is{}(self):".format(name), ["return True"]])
+
+            self.code[name] = cls
+
+    @memoize
+    def _cost(self, name):
+        # print "call cost {}".format(name)
+        if name == '_AST':
+            return 0
+        parents = self.hierarchy[name]
+        return reduce(lambda acc, x: acc + self._cost(x), parents, 1)
+
+    @property
+    def python(self):
+
+        classes = self.hierarchy.keys()
+        classes.sort(lambda a, b: self._cost(a) - self._cost(b))
+
+        code = ["from snakes.lang import ast",
+                "from ast import *",
+                ""]
+
+        for cls in classes:
+            code.extend(self.code[cls])
+            code.append("")
+
+        def python (code, indent) :
+            for line in code :
+                if isinstance(line, str) :
+                    yield (4*indent) * " " + line
+                else :
+                    for sub in python(line, indent+1) :
+                        yield sub
+        return "\n".join(python(code, 0))
+
+def compile_asdl(infilename, outfilename):
+    """ Helper function to compile asdl files. """
+
+    infile = open(infilename, 'r')
+    outfile = open(outfilename, 'w')
+
+    scanner = asdl.ASDLScanner()
+    parser = asdl.ASDLParser()
+    tokens = scanner.tokenize(infile.read())
+    node = parser.parse(tokens)
+
+    outfile.write(("# this file has been automatically generated running:\n"
+                   "# %s\n# timestamp: %s\n\n") % (" ".join(sys.argv),
+                                                   datetime.datetime.now()))
+    outfile.write(CodeGen(node).python)
+    outfile.close()
+    infile.close()
+
+if __name__ == "__main__":
+    # a simple CLI
+    import getopt
+    outfile = sys.stdout
+    try :
+        opts, args = getopt.getopt(sys.argv[1:], "ho:",
+                                   ["help", "output="])
+        if ("-h", "") in opts or ("--help", "") in opts :
+            opts = [("-h", "")]
+            args = [None]
+        elif not args :
+            raise getopt.GetoptError("no input file provided"
+                                     " (try -h to get help)")
+        elif len(args) > 1 :
+            raise getopt.GetoptError("more than one input file provided")
+    except getopt.GetoptError :
+        sys.stderr.write("%s: %s\n" % (__file__, sys.exc_info()[1]))
+        sys.exit(1)
+    for (flag, arg) in opts :
+        if flag in ("-h", "--help") :
+            print("""usage: %s [OPTIONS] INFILE
+    Options:
+        -h, --help         print this help and exit
+        --output=OUTPUT    set output file""" % __file__)
+            sys.exit(0)
+        elif flag in ("-o", "--output") :
+            outfile = open(arg, "w")
+    scanner = asdl.ASDLScanner()
+    parser = asdl.ASDLParser()
+    tokens = scanner.tokenize(open(args[0]).read())
+    node = parser.parse(tokens)
+    outfile.write(("# this file has been automatically generated running:\n"
+                   "# %s\n# timestamp: %s\n\n") % (" ".join(sys.argv),
+                                                   datetime.datetime.now()))
+    try:
+        outfile.write(CodeGen(node).python)
+    except CyclicDependencies as cycle:
+        msg = "[E] {!s}".format(cycle)
+        outfile.write(msg)
+        if outfile != sys.stdout:
+            print >> sys.stderr, msg
+    outfile.close()

+"""Backport of Python 2.6 'ast' module.
+"""
+
+from _ast import *
+
+def parse(expr, filename='<unknown>', mode='exec'):
+    """
+    Parse an expression into an AST node.
+    Equivalent to compile(expr, filename, mode, PyCF_ONLY_AST).
+    """
+    return compile(expr, filename, mode, PyCF_ONLY_AST)
+
+
+def literal_eval(node_or_string):
+    """
+    Safely evaluate an expression node or a string containing a Python
+    expression.  The string or node provided may only consist of the following
+    Python literal structures: strings, numbers, tuples, lists, dicts, booleans,
+    and None.
+    """
+    _safe_names = {'None': None, 'True': True, 'False': False}
+    if isinstance(node_or_string, basestring):
+        node_or_string = parse(node_or_string, mode='eval')
+    if isinstance(node_or_string, Expression):
+        node_or_string = node_or_string.body
+    def _convert(node):
+        if isinstance(node, Str):
+            return node.s
+        elif isinstance(node, Num):
+            return node.n
+        elif isinstance(node, Tuple):
+            return tuple(map(_convert, node.elts))
+        elif isinstance(node, List):
+            return list(map(_convert, node.elts))
+        elif isinstance(node, Dict):
+            return dict((_convert(k), _convert(v)) for k, v
+                        in zip(node.keys, node.values))
+        elif isinstance(node, Name):
+            if node.id in _safe_names:
+                return _safe_names[node.id]
+        raise ValueError('malformed string')
+    return _convert(node_or_string)
+
+
+def dump(node, annotate_fields=True, include_attributes=False):
+    """
+    Return a formatted dump of the tree in *node*.  This is mainly useful for
+    debugging purposes.  The returned string will show the names and the values
+    for fields.  This makes the code impossible to evaluate, so if evaluation is
+    wanted *annotate_fields* must be set to False.  Attributes such as line
+    numbers and column offsets are not dumped by default.  If this is wanted,
+    *include_attributes* can be set to True.
+    """
+    def _format(node):
+        if isinstance(node, AST):
+            fields = [(a, _format(b)) for a, b in iter_fields(node)]
+            rv = '%s(%s' % (node.__class__.__name__, ', '.join(
+                ('%s=%s' % field for field in fields)
+                if annotate_fields else
+                (b for a, b in fields)
+            ))
+            if include_attributes and node._attributes:
+                rv += fields and ', ' or ' '
+                rv += ', '.join('%s=%s' % (a, _format(getattr(node, a)))
+                                for a in node._attributes)
+            return rv + ')'
+        elif isinstance(node, list):
+            return '[%s]' % ', '.join(_format(x) for x in node)
+        return repr(node)
+    if not isinstance(node, AST):
+        raise TypeError('expected AST, got %r' % node.__class__.__name__)
+    return _format(node)
+
+
+def copy_location(new_node, old_node):
+    """
+    Copy source location (`lineno` and `col_offset` attributes) from
+    *old_node* to *new_node* if possible, and return *new_node*.
+    """
+    for attr in 'lineno', 'col_offset':
+        if attr in old_node._attributes and attr in new_node._attributes \
+           and hasattr(old_node, attr):
+            setattr(new_node, attr, getattr(old_node, attr))
+    return new_node
+
+
+def fix_missing_locations(node):
+    """
+    When you compile a node tree with compile(), the compiler expects lineno and
+    col_offset attributes for every node that supports them.  This is rather
+    tedious to fill in for generated nodes, so this helper adds these attributes
+    recursively where not already set, by setting them to the values of the
+    parent node.  It works recursively starting at *node*.
+    """
+    def _fix(node, lineno, col_offset):
+        if 'lineno' in node._attributes:
+            if not hasattr(node, 'lineno'):
+                node.lineno = lineno
+            else:
+                lineno = node.lineno
+        if 'col_offset' in node._attributes:
+            if not hasattr(node, 'col_offset'):
+                node.col_offset = col_offset
+            else:
+                col_offset = node.col_offset
+        for child in iter_child_nodes(node):
+            _fix(child, lineno, col_offset)
+    _fix(node, 1, 0)
+    return node
+
+
+def increment_lineno(node, n=1):
+    """
+    Increment the line number of each node in the tree starting at *node* by *n*.
+    This is useful to "move code" to a different location in a file.
+    """
+    if 'lineno' in node._attributes:
+        node.lineno = getattr(node, 'lineno', 0) + n
+    for child in walk(node):
+        if 'lineno' in child._attributes:
+            child.lineno = getattr(child, 'lineno', 0) + n
+    return node
+
+
+def iter_fields(node):
+    """
+    Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields``
+    that is present on *node*.
+    """
+    for field in node._fields:
+        try:
+            yield field, getattr(node, field)
+        except AttributeError:
+            pass
+
+
+def iter_child_nodes(node):
+    """
+    Yield all direct child nodes of *node*, that is, all fields that are nodes
+    and all items of fields that are lists of nodes.
+    """
+    for name, field in iter_fields(node):
+        if isinstance(field, AST):
+            yield field
+        elif isinstance(field, list):
+            for item in field:
+                if isinstance(item, AST):
+                    yield item
+
+
+def get_docstring(node, clean=True):
+    """
+    Return the docstring for the given node or None if no docstring can
+    be found.  If the node provided does not have docstrings a TypeError
+    will be raised.
+    """
+    if not isinstance(node, (FunctionDef, ClassDef, Module)):
+        raise TypeError("%r can't have docstrings" % node.__class__.__name__)
+    if node.body and isinstance(node.body[0], Expr) and \
+       isinstance(node.body[0].value, Str):
+        if clean:
+            import inspect
+            return inspect.cleandoc(node.body[0].value.s)
+        return node.body[0].value.s
+
+
+def walk(node):
+    """
+    Recursively yield all child nodes of *node*, in no specified order.  This is
+    useful if you only want to modify nodes in place and don't care about the
+    context.
+    """
+    from collections import deque
+    todo = deque([node])
+    while todo:
+        node = todo.popleft()
+        todo.extend(iter_child_nodes(node))
+        yield node
+
+
+class NodeVisitor(object):
+    """
+    A node visitor base class that walks the abstract syntax tree and calls a
+    visitor function for every node found.  This function may return a value
+    which is forwarded by the `visit` method.
+
+    This class is meant to be subclassed, with the subclass adding visitor
+    methods.
+
+    Per default the visitor functions for the nodes are ``'visit_'`` +
+    class name of the node.  So a `TryFinally` node visit function would
+    be `visit_TryFinally`.  This behavior can be changed by overriding
+    the `visit` method.  If no visitor function exists for a node
+    (return value `None`) the `generic_visit` visitor is used instead.
+
+    Don't use the `NodeVisitor` if you want to apply changes to nodes during
+    traversing.  For this a special visitor exists (`NodeTransformer`) that
+    allows modifications.
+    """
+
+    def visit(self, node):
+        """Visit a node."""
+        method = 'visit_' + node.__class__.__name__
+        visitor = getattr(self, method, self.generic_visit)
+        return visitor(node)
+
+    def generic_visit(self, node):
+        """Called if no explicit visitor function exists for a node."""
+        for field, value in iter_fields(node):
+            if isinstance(value, list):
+                for item in value:
+                    if isinstance(item, AST):
+                        self.visit(item)
+            elif isinstance(value, AST):
+                self.visit(value)
+
+
+class NodeTransformer(NodeVisitor):
+    """
+    A :class:`NodeVisitor` subclass that walks the abstract syntax tree and
+    allows modification of nodes.
+
+    The `NodeTransformer` will walk the AST and use the return value of the
+    visitor methods to replace or remove the old node.  If the return value of
+    the visitor method is ``None``, the node will be removed from its location,
+    otherwise it is replaced with the return value.  The return value may be the
+    original node in which case no replacement takes place.
+
+    Here is an example transformer that rewrites all occurrences of name lookups
+    (``foo``) to ``data['foo']``::
+
+       class RewriteName(NodeTransformer):
+
+           def visit_Name(self, node):
+               return copy_location(Subscript(
+                   value=Name(id='data', ctx=Load()),
+                   slice=Index(value=Str(s=node.id)),
+                   ctx=node.ctx
+               ), node)
+
+    Keep in mind that if the node you're operating on has child nodes you must
+    either transform the child nodes yourself or call the :meth:`generic_visit`
+    method for the node first.
+
+    For nodes that were part of a collection of statements (that applies to all
+    statement nodes), the visitor may also return a list of nodes rather than
+    just a single node.
+
+    Usually you use the transformer like this::
+
+       node = YourTransformer().visit(node)
+    """
+
+    def generic_visit(self, node):
+        for field, old_value in iter_fields(node):
+            old_value = getattr(node, field, None)
+            if isinstance(old_value, list):
+                new_values = []
+                for value in old_value:
+                    if isinstance(value, AST):
+                        value = self.visit(value)
+                        if value is None:
+                            continue
+                        elif not isinstance(value, AST):
+                            new_values.extend(value)
+                            continue
+                    new_values.append(value)
+                old_value[:] = new_values
+            elif isinstance(old_value, AST):
+                new_node = self.visit(old_value)
+                if new_node is None:
+                    delattr(node, field)
+                else:
+                    setattr(node, field, new_node)
+        return node

+"""Backport of Python 2.6 'ast' module.
+
+AST classes are wrappers around classes in Python 2.5 '_ast' module.
+The rest is copied from Python 2.6 'ast.py'.
+"""
+
+import inspect
+import _ast
+from _ast import PyCF_ONLY_AST
+from _ast import AST
+
+for name, cls in inspect.getmembers(_ast, inspect.isclass) :
+    if issubclass(cls, AST) :
+        if cls is AST :
+            continue
+        class _Ast (cls, AST) :
+            def __init__ (self, *larg, **karg) :
+                if len(larg) > 0 and len(larg) != len(self._fields) :
+                    raise TypeError, ("%s constructor takes either 0 or "
+                                      "%u positional arguments"
+                                      % (self.__class__.__name__,
+                                         len(self._fields)))
+                for name, arg in zip(self._fields, larg) + karg.items() :
+                    if name in self._fields :
+                        setattr(self, name, arg)
+        try :
+            _Ast._fields = tuple(cls._fields)
+        except :
+            _Ast._fields = ()
+        _Ast.__name__ = name
+        globals()[name] = _Ast
+
+del _Ast, cls, name
+
+def literal_eval(node_or_string):
+    """
+    Safely evaluate an expression node or a string containing a Python
+    expression.  The string or node provided may only consist of the following
+    Python literal structures: strings, numbers, tuples, lists, dicts, booleans,
+    and None.
+    """
+    _safe_names = {'None': None, 'True': True, 'False': False}
+    if isinstance(node_or_string, basestring):
+        node_or_string = parse(node_or_string, mode='eval')
+    if isinstance(node_or_string, Expression):
+        node_or_string = node_or_string.body
+    def _convert(node):
+        if isinstance(node, Str):
+            return node.s
+        elif isinstance(node, Num):
+            return node.n
+        elif isinstance(node, Tuple):
+            return tuple(map(_convert, node.elts))
+        elif isinstance(node, List):
+            return list(map(_convert, node.elts))
+        elif isinstance(node, Dict):
+            return dict((_convert(k), _convert(v)) for k, v
+                        in zip(node.keys, node.values))
+        elif isinstance(node, Name):
+            if node.id in _safe_names:
+                return _safe_names[node.id]
+        raise ValueError('malformed string')
+    return _convert(node_or_string)
+
+def dump(node, annotate_fields=True, include_attributes=False):
+    """
+    Return a formatted dump of the tree in *node*.  This is mainly useful for
+    debugging purposes.  The returned string will show the names and the values
+    for fields.  This makes the code impossible to evaluate, so if evaluation is
+    wanted *annotate_fields* must be set to False.  Attributes such as line
+    numbers and column offsets are not dumped by default.  If this is wanted,
+    *include_attributes* can be set to True.
+    """
+    def _format(node):
+        if isinstance(node, AST):
+            fields = [(a, _format(b)) for a, b in iter_fields(node)]
+            rv = '%s(%s' % (node.__class__.__name__, ', '.join(
+                ('%s=%s' % field for field in fields)
+                if annotate_fields else
+                (b for a, b in fields)
+            ))
+            if include_attributes and node._attributes:
+                rv += fields and ', ' or ' '
+                rv += ', '.join('%s=%s' % (a, _format(getattr(node, a)))
+                                for a in node._attributes)
+            return rv + ')'
+        elif isinstance(node, list):
+            return '[%s]' % ', '.join(_format(x) for x in node)
+        return repr(node)
+    if not isinstance(node, AST):
+        raise TypeError('expected AST, got %r' % node.__class__.__name__)
+    return _format(node)
+
+def copy_location(new_node, old_node):
+    """
+    Copy source location (`lineno` and `col_offset` attributes) from
+    *old_node* to *new_node* if possible, and return *new_node*.
+    """
+    for attr in 'lineno', 'col_offset':
+        if attr in old_node._attributes and attr in new_node._attributes \
+           and hasattr(old_node, attr):
+            setattr(new_node, attr, getattr(old_node, attr))
+    return new_node
+
+def fix_missing_locations(node):
+    """
+    When you compile a node tree with compile(), the compiler expects lineno and
+    col_offset attributes for every node that supports them.  This is rather
+    tedious to fill in for generated nodes, so this helper adds these attributes
+    recursively where not already set, by setting them to the values of the
+    parent node.  It works recursively starting at *node*.
+    """
+    def _fix(node, lineno, col_offset):
+        if 'lineno' in node._attributes:
+            if not hasattr(node, 'lineno'):
+                node.lineno = lineno
+            else:
+                lineno = node.lineno
+        if 'col_offset' in node._attributes:
+            if not hasattr(node, 'col_offset'):
+                node.col_offset = col_offset
+            else:
+                col_offset = node.col_offset
+        for child in iter_child_nodes(node):
+            _fix(child, lineno, col_offset)
+    _fix(node, 1, 0)
+    return node
+
+def increment_lineno(node, n=1):
+    """
+    Increment the line number of each node in the tree starting at *node* by *n*.
+    This is useful to "move code" to a different location in a file.
+    """
+    if 'lineno' in node._attributes:
+        node.lineno = getattr(node, 'lineno', 0) + n
+    for child in walk(node):
+        if 'lineno' in child._attributes:
+            child.lineno = getattr(child, 'lineno', 0) + n
+    return node
+
+def iter_fields(node):
+    """
+    Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields``
+    that is present on *node*.
+    """
+    for field in node._fields:
+        try:
+            yield field, getattr(node, field)
+        except AttributeError:
+            pass
+
+def iter_child_nodes(node):
+    """
+    Yield all direct child nodes of *node*, that is, all fields that are nodes
+    and all items of fields that are lists of nodes.
+    """
+    for name, field in iter_fields(node):
+        if isinstance(field, AST):
+            yield field
+        elif isinstance(field, list):
+            for item in field:
+                if isinstance(item, AST):
+                    yield item
+
+def get_docstring(node, clean=True):
+    """
+    Return the docstring for the given node or None if no docstring can
+    be found.  If the node provided does not have docstrings a TypeError
+    will be raised.
+    """
+    if not isinstance(node, (FunctionDef, ClassDef, Module)):
+        raise TypeError("%r can't have docstrings" % node.__class__.__name__)
+    if node.body and isinstance(node.body[0], Expr) and \
+       isinstance(node.body[0].value, Str):
+        if clean:
+            return inspect.cleandoc(node.body[0].value.s)
+        return node.body[0].value.s
+
+def walk(node):
+    """
+    Recursively yield all child nodes of *node*, in no specified order.  This is
+    useful if you only want to modify nodes in place and don't care about the
+    context.
+    """
+    from collections import deque
+    todo = deque([node])
+    while todo:
+        node = todo.popleft()
+        todo.extend(iter_child_nodes(node))
+        yield node
+
+class NodeVisitor(object):
+    """
+    A node visitor base class that walks the abstract syntax tree and calls a
+    visitor function for every node found.  This function may return a value
+    which is forwarded by the `visit` method.
+
+    This class is meant to be subclassed, with the subclass adding visitor
+    methods.
+
+    Per default the visitor functions for the nodes are ``'visit_'`` +
+    class name of the node.  So a `TryFinally` node visit function would
+    be `visit_TryFinally`.  This behavior can be changed by overriding
+    the `visit` method.  If no visitor function exists for a node
+    (return value `None`) the `generic_visit` visitor is used instead.
+
+    Don't use the `NodeVisitor` if you want to apply changes to nodes during
+    traversing.  For this a special visitor exists (`NodeTransformer`) that
+    allows modifications.
+    """
+    def visit(self, node):
+        """Visit a node."""
+        method = 'visit_' + node.__class__.__name__
+        visitor = getattr(self, method, self.generic_visit)
+        return visitor(node)
+    def generic_visit(self, node):
+        """Called if no explicit visitor function exists for a node."""
+        for field, value in iter_fields(node):
+            if isinstance(value, list):
+                for item in value:
+                    if isinstance(item, AST):
+                        self.visit(item)
+            elif isinstance(value, AST):
+                self.visit(value)
+
+class NodeTransformer(NodeVisitor):
+    """
+    A :class:`NodeVisitor` subclass that walks the abstract syntax tree and
+    allows modification of nodes.
+
+    The `NodeTransformer` will walk the AST and use the return value of the
+    visitor methods to replace or remove the old node.  If the return value of
+    the visitor method is ``None``, the node will be removed from its location,
+    otherwise it is replaced with the return value.  The return value may be the
+    original node in which case no replacement takes place.
+
+    Here is an example transformer that rewrites all occurrences of name lookups
+    (``foo``) to ``data['foo']``::
+
+       class RewriteName(NodeTransformer):
+
+           def visit_Name(self, node):
+               return copy_location(Subscript(
+                   value=Name(id='data', ctx=Load()),
+                   slice=Index(value=Str(s=node.id)),
+                   ctx=node.ctx
+               ), node)
+
+    Keep in mind that if the node you're operating on has child nodes you must
+    either transform the child nodes yourself or call the :meth:`generic_visit`
+    method for the node first.
+
+    For nodes that were part of a collection of statements (that applies to all
+    statement nodes), the visitor may also return a list of nodes rather than
+    just a single node.
+
+    Usually you use the transformer like this::
+
+       node = YourTransformer().visit(node)
+    """
+    def generic_visit(self, node):
+        for field, old_value in iter_fields(node):
+            old_value = getattr(node, field, None)
+            if isinstance(old_value, list):
+                new_values = []
+                for value in old_value:
+                    if isinstance(value, AST):
+                        value = self.visit(value)
+                        if value is None:
+                            continue
+                        elif not isinstance(value, AST):
+                            new_values.extend(value)
+                            continue
+                    new_values.append(value)
+                old_value[:] = new_values
+            elif isinstance(old_value, AST):
+                new_node = self.visit(old_value)
+                if new_node is None:
+                    delattr(node, field)
+                else:
+                    setattr(node, field, new_node)
+        return node
+
+def _ast2ast (node) :
+    new = globals()[node.__class__.__name__]()
+    if not hasattr(node, "_fields") or node._fields is None :
+        node._fields = ()
+    for name, field in iter_fields(node) :
+        new_field = field
+        if field is None :
+            new_field = None
+        elif isinstance(field, AST) :
+            new_field = _ast2ast(field)
+        elif isinstance(field, list) :
+            new_field = []
+            for value in field :
+                if isinstance(value, AST) :
+                    new_field.append(_ast2ast(value))
+                else :
+                    new_field.append(value)
+        setattr(new, name, new_field)
+    copy_location(new, node)
+    return new
+
+def parse(expr, filename='<unknown>', mode='exec'):
+    """
+    Parse an expression into an AST node.
+    Equivalent to compile(expr, filename, mode, PyCF_ONLY_AST).
+    """
+    return _ast2ast(compile(expr, filename, mode, PyCF_ONLY_AST))

+"""Backport of Python 2.6 'ast' module.
+"""
+
+import _ast
+from _ast import *
+
+try :
+    PyCF_ONLY_AST
+except NameError :
+    PyCF_ONLY_AST = PyCF_AST_ONLY
+
+def parse(expr, filename='<unknown>', mode='exec'):
+    """
+    Parse an expression into an AST node.
+    Equivalent to compile(expr, filename, mode, PyCF_ONLY_AST).
+    """
+    return compile(expr, filename, mode, PyCF_ONLY_AST)
+
+def literal_eval(node_or_string):
+    """
+    Safely evaluate an expression node or a string containing a Python
+    expression.  The string or node provided may only consist of the following
+    Python literal structures: strings, numbers, tuples, lists, dicts, booleans,
+    and None.
+    """
+    _safe_names = {'None': None, 'True': True, 'False': False}
+    if isinstance(node_or_string, basestring):
+        node_or_string = parse(node_or_string, mode='eval')
+    if isinstance(node_or_string, Expression):
+        node_or_string = node_or_string.body
+    def _convert(node):
+        if isinstance(node, Str):
+            return node.s
+        elif isinstance(node, Num):
+            return node.n
+        elif isinstance(node, Tuple):
+            return tuple(map(_convert, node.elts))
+        elif isinstance(node, List):
+            return list(map(_convert, node.elts))
+        elif isinstance(node, Dict):
+            return dict((_convert(k), _convert(v)) for k, v
+                        in zip(node.keys, node.values))
+        elif isinstance(node, Name):
+            if node.id in _safe_names:
+                return _safe_names[node.id]
+        raise ValueError('malformed string')
+    return _convert(node_or_string)
+
+
+def dump(node, annotate_fields=True, include_attributes=False):
+    """
+    Return a formatted dump of the tree in *node*.  This is mainly useful for
+    debugging purposes.  The returned string will show the names and the values
+    for fields.  This makes the code impossible to evaluate, so if evaluation is
+    wanted *annotate_fields* must be set to False.  Attributes such as line
+    numbers and column offsets are not dumped by default.  If this is wanted,
+    *include_attributes* can be set to True.
+    """
+    def _format(node):
+        if isinstance(node, AST):
+            fields = [(a, _format(b)) for a, b in iter_fields(node)]
+            rv = '%s(%s' % (node.__class__.__name__, ', '.join(
+                ('%s=%s' % field for field in fields)
+                if annotate_fields else
+                (b for a, b in fields)
+            ))
+            if include_attributes and node._attributes:
+                rv += fields and ', ' or ' '
+                rv += ', '.join('%s=%s' % (a, _format(getattr(node, a)))
+                                for a in node._attributes)
+            return rv + ')'
+        elif isinstance(node, list):
+            return '[%s]' % ', '.join(_format(x) for x in node)
+        return repr(node)
+    if not isinstance(node, AST):
+        raise TypeError('expected AST, got %r' % node.__class__.__name__)
+    return _format(node)
+
+
+def copy_location(new_node, old_node):
+    """
+    Copy source location (`lineno` and `col_offset` attributes) from
+    *old_node* to *new_node* if possible, and return *new_node*.
+    """
+    for attr in 'lineno', 'col_offset':
+        if attr in old_node._attributes and attr in new_node._attributes \
+           and hasattr(old_node, attr):
+            setattr(new_node, attr, getattr(old_node, attr))
+    return new_node
+
+
+def fix_missing_locations(node):
+    """
+    When you compile a node tree with compile(), the compiler expects lineno and
+    col_offset attributes for every node that supports them.  This is rather
+    tedious to fill in for generated nodes, so this helper adds these attributes
+    recursively where not already set, by setting them to the values of the
+    parent node.  It works recursively starting at *node*.
+    """
+    def _fix(node, lineno, col_offset):
+        if 'lineno' in node._attributes:
+            if not hasattr(node, 'lineno'):
+                node.lineno = lineno
+            else:
+                lineno = node.lineno
+        if 'col_offset' in node._attributes:
+            if not hasattr(node, 'col_offset'):
+                node.col_offset = col_offset
+            else:
+                col_offset = node.col_offset
+        for child in iter_child_nodes(node):
+            _fix(child, lineno, col_offset)
+    _fix(node, 1, 0)
+    return node
+
+
+def increment_lineno(node, n=1):
+    """
+    Increment the line number of each node in the tree starting at *node* by *n*.
+    This is useful to "move code" to a different location in a file.
+    """
+    if 'lineno' in node._attributes:
+        node.lineno = getattr(node, 'lineno', 0) + n
+    for child in walk(node):
+        if 'lineno' in child._attributes:
+            child.lineno = getattr(child, 'lineno', 0) + n
+    return node
+
+
+def iter_fields(node):
+    """
+    Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields``
+    that is present on *node*.
+    """
+    for field in node._fields:
+        try:
+            yield field, getattr(node, field)
+        except AttributeError:
+            pass
+
+
+def iter_child_nodes(node):
+    """
+    Yield all direct child nodes of *node*, that is, all fields that are nodes
+    and all items of fields that are lists of nodes.
+    """
+    for name, field in iter_fields(node):
+        if isinstance(field, AST):
+            yield field
+        elif isinstance(field, list):
+            for item in field:
+                if isinstance(item, AST):
+                    yield item
+
+
+def get_docstring(node, clean=True):
+    """
+    Return the docstring for the given node or None if no docstring can
+    be found.  If the node provided does not have docstrings a TypeError
+    will be raised.
+    """
+    if not isinstance(node, (FunctionDef, ClassDef, Module)):
+        raise TypeError("%r can't have docstrings" % node.__class__.__name__)
+    if node.body and isinstance(node.body[0], Expr) and \
+       isinstance(node.body[0].value, Str):
+        if clean:
+            import inspect
+            return inspect.cleandoc(node.body[0].value.s)
+        return node.body[0].value.s
+
+
+def walk(node):
+    """
+    Recursively yield all child nodes of *node*, in no specified order.  This is
+    useful if you only want to modify nodes in place and don't care about the
+    context.
+    """
+    from collections import deque
+    todo = deque([node])
+    while todo:
+        node = todo.popleft()
+        todo.extend(iter_child_nodes(node))
+        yield node
+
+
+class NodeVisitor(object):
+    """
+    A node visitor base class that walks the abstract syntax tree and calls a
+    visitor function for every node found.  This function may return a value
+    which is forwarded by the `visit` method.
+
+    This class is meant to be subclassed, with the subclass adding visitor
+    methods.
+
+    Per default the visitor functions for the nodes are ``'visit_'`` +
+    class name of the node.  So a `TryFinally` node visit function would
+    be `visit_TryFinally`.  This behavior can be changed by overriding
+    the `visit` method.  If no visitor function exists for a node
+    (return value `None`) the `generic_visit` visitor is used instead.
+
+    Don't use the `NodeVisitor` if you want to apply changes to nodes during
+    traversing.  For this a special visitor exists (`NodeTransformer`) that
+    allows modifications.
+    """
+
+    def visit(self, node):
+        """Visit a node."""
+        method = 'visit_' + node.__class__.__name__
+        visitor = getattr(self, method, self.generic_visit)
+        return visitor(node)
+
+    def generic_visit(self, node):
+        """Called if no explicit visitor function exists for a node."""
+        for field, value in iter_fields(node):
+            if isinstance(value, list):
+                for item in value:
+                    if isinstance(item, AST):
+                        self.visit(item)
+            elif isinstance(value, AST):
+                self.visit(value)
+
+
+class NodeTransformer(NodeVisitor):
+    """
+    A :class:`NodeVisitor` subclass that walks the abstract syntax tree and
+    allows modification of nodes.
+
+    The `NodeTransformer` will walk the AST and use the return value of the
+    visitor methods to replace or remove the old node.  If the return value of
+    the visitor method is ``None``, the node will be removed from its location,
+    otherwise it is replaced with the return value.  The return value may be the
+    original node in which case no replacement takes place.
+
+    Here is an example transformer that rewrites all occurrences of name lookups
+    (``foo``) to ``data['foo']``::
+
+       class RewriteName(NodeTransformer):
+
+           def visit_Name(self, node):
+               return copy_location(Subscript(
+                   value=Name(id='data', ctx=Load()),
+                   slice=Index(value=Str(s=node.id)),
+                   ctx=node.ctx
+               ), node)
+
+    Keep in mind that if the node you're operating on has child nodes you must
+    either transform the child nodes yourself or call the :meth:`generic_visit`
+    method for the node first.
+
+    For nodes that were part of a collection of statements (that applies to all
+    statement nodes), the visitor may also return a list of nodes rather than
+    just a single node.
+
+    Usually you use the transformer like this::
+
+       node = YourTransformer().visit(node)
+    """
+
+    def generic_visit(self, node):
+        for field, old_value in iter_fields(node):
+            old_value = getattr(node, field, None)
+            if isinstance(old_value, list):
+                new_values = []
+                for value in old_value:
+                    if isinstance(value, AST):
+                        value = self.visit(value)
+                        if value is None:
+                            continue
+                        elif not isinstance(value, AST):
+                            new_values.extend(value)
+                            continue
+                    new_values.append(value)
+                old_value[:] = new_values
+            elif isinstance(old_value, AST):
+                new_node = self.visit(old_value)
+                if new_node is None:
+                    delattr(node, field)
+                else:
+                    setattr(node, field, new_node)
+        return node

+# this file has been automatically generated running:
+# snakes/lang/asdl.py --output=snakes/lang/ctlstar/asdl.py snakes/lang/ctlstar/ctlstar.asdl
+# timestamp: 2011-11-16 13:30:34.219385
+
+from snakes.lang import ast
+from ast import *
+
+class _AST (ast.AST):
+    def __init__ (self, **ARGS):
+        ast.AST.__init__(self)
+        for k, v in ARGS.items():
+            setattr(self, k, v)
+
+class expr_context (_AST):
+    pass
+
+class Load (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class Store (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class Del (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class AugLoad (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class AugStore (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class Param (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class comprehension (_AST):
+    _fields = ('target', 'iter', 'ifs')
+    _attributes = ()
+    def __init__ (self, target, iter, ifs=[], **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.target = target
+        self.iter = iter
+        self.ifs = list(ifs)
+
+class arg (_AST):
+    _fields = ('arg', 'annotation')
+    _attributes = ()
+    def __init__ (self, arg, annotation=None, **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.arg = arg
+        self.annotation = annotation
+
+class operator (_AST):
+    pass
+
+class Add (operator):
+    _fields = ()
+    _attributes = ()
+
+class Sub (operator):
+    _fields = ()
+    _attributes = ()
+
+class Mult (operator):
+    _fields = ()
+    _attributes = ()
+
+class Div (operator):
+    _fields = ()
+    _attributes = ()
+
+class Mod (operator):
+    _fields = ()
+    _attributes = ()
+
+class Pow (operator):
+    _fields = ()
+    _attributes = ()
+
+class LShift (operator):
+    _fields = ()
+    _attributes = ()
+
+class RShift (operator):
+    _fields = ()
+    _attributes = ()
+
+class BitOr (operator):
+    _fields = ()
+    _attributes = ()
+
+class BitXor (operator):
+    _fields = ()
+    _attributes = ()
+
+class BitAnd (operator):
+    _fields = ()
+    _attributes = ()
+
+class FloorDiv (operator):
+    _fields = ()
+    _attributes = ()
+
+class slice (_AST):
+    pass
+
+class Slice (slice):
+    _fields = ('lower', 'upper', 'step')
+    _attributes = ()
+    def __init__ (self, lower=None, upper=None, step=None, **ARGS):
+        slice.__init__(self, **ARGS)
+        self.lower = lower
+        self.upper = upper
+        self.step = step
+
+class ExtSlice (slice):
+    _fields = ('dims',)
+    _attributes = ()
+    def __init__ (self, dims=[], **ARGS):
+        slice.__init__(self, **ARGS)
+        self.dims = list(dims)
+
+class Index (slice):
+    _fields = ('value',)
+    _attributes = ()
+    def __init__ (self, value, **ARGS):
+        slice.__init__(self, **ARGS)
+        self.value = value
+
+class excepthandler (_AST):
+    pass
+
+class ExceptHandler (excepthandler):
+    _fields = ('type', 'name', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, type=None, name=None, body=[], lineno=0, col_offset=0, **ARGS):
+        excepthandler.__init__(self, **ARGS)
+        self.type = type
+        self.name = name
+        self.body = list(body)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class arguments (_AST):
+    _fields = ('args', 'vararg', 'varargannotation', 'kwonlyargs', 'kwarg', 'kwargannotation', 'defaults', 'kw_defaults')
+    _attributes = ()
+    def __init__ (self, args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[], **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.args = list(args)
+        self.vararg = vararg
+        self.varargannotation = varargannotation
+        self.kwonlyargs = list(kwonlyargs)
+        self.kwarg = kwarg
+        self.kwargannotation = kwargannotation
+        self.defaults = list(defaults)
+        self.kw_defaults = list(kw_defaults)
+
+class ctlbinary (_AST):
+    pass
+
+class boolop (ctlbinary):
+    _fields = ()
+    _attributes = ()
+
+class Imply (ctlbinary):
+    _fields = ()
+    _attributes = ()
+
+class Iff (ctlbinary):
+    _fields = ()
+    _attributes = ()
+
+class Until (ctlbinary):
+    _fields = ()
+    _attributes = ()
+
+class WeakUntil (ctlbinary):
+    _fields = ()
+    _attributes = ()
+
+class Release (ctlbinary):
+    _fields = ()
+    _attributes = ()
+
+class ctlunary (_AST):
+    pass
+
+class notop (ctlunary):
+    _fields = ()
+    _attributes = ()
+
+class All (ctlunary):
+    _fields = ()
+    _attributes = ()
+
+class Exists (ctlunary):
+    _fields = ()
+    _attributes = ()
+
+class Next (ctlunary):
+    _fields = ()
+    _attributes = ()
+
+class Future (ctlunary):
+    _fields = ()
+    _attributes = ()
+
+class Globally (ctlunary):
+    _fields = ()
+    _attributes = ()
+
+class form (_AST):
+    pass
+
+class atom (form):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        form.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class CtlUnary (form):
+    _fields = ('op', 'child')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, op, child, lineno=0, col_offset=0, **ARGS):
+        form.__init__(self, **ARGS)
+        self.op = op
+        self.child = child
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class CtlBinary (form):
+    _fields = ('op', 'left', 'right')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, op, left, right, lineno=0, col_offset=0, **ARGS):
+        form.__init__(self, **ARGS)
+        self.op = op
+        self.left = left
+        self.right = right
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class unaryop (_AST):
+    pass
+
+class Invert (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class notop (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class UAdd (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class USub (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class boolop (_AST):
+    pass
+
+class And (boolop):
+    _fields = ()
+    _attributes = ()
+
+class Or (boolop):
+    _fields = ()
+    _attributes = ()
+
+class stmt (_AST):
+    pass
+
+class FunctionDef (stmt):
+    _fields = ('name', 'args', 'body', 'decorator_list', 'returns')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, args, body=[], decorator_list=[], returns=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.name = name
+        self.args = args
+        self.body = list(body)
+        self.decorator_list = list(decorator_list)
+        self.returns = returns
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class ClassDef (stmt):
+    _fields = ('name', 'bases', 'keywords', 'starargs', 'kwargs', 'body', 'decorator_list')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, bases=[], keywords=[], starargs=None, kwargs=None, body=[], decorator_list=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.name = name
+        self.bases = list(bases)
+        self.keywords = list(keywords)
+        self.starargs = starargs
+        self.kwargs = kwargs
+        self.body = list(body)
+        self.decorator_list = list(decorator_list)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Return (stmt):
+    _fields = ('value',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Delete (stmt):
+    _fields = ('targets',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, targets=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.targets = list(targets)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Assign (stmt):
+    _fields = ('targets', 'value')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, targets=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.targets = list(targets)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class AugAssign (stmt):
+    _fields = ('target', 'op', 'value')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, target, op, value, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.target = target
+        self.op = op
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class For (stmt):
+    _fields = ('target', 'iter', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, target, iter, body=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.target = target
+        self.iter = iter
+        self.body = list(body)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class While (stmt):
+    _fields = ('test', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, body=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.test = test
+        self.body = list(body)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class If (stmt):
+    _fields = ('test', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, body=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.test = test
+        self.body = list(body)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class With (stmt):
+    _fields = ('context_expr', 'optional_vars', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, context_expr, optional_vars=None, body=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.context_expr = context_expr
+        self.optional_vars = optional_vars
+        self.body = list(body)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Raise (stmt):
+    _fields = ('exc', 'cause')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, exc=None, cause=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.exc = exc
+        self.cause = cause
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class TryExcept (stmt):
+    _fields = ('body', 'handlers', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, body=[], handlers=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.body = list(body)
+        self.handlers = list(handlers)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class TryFinally (stmt):
+    _fields = ('body', 'finalbody')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, body=[], finalbody=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.body = list(body)
+        self.finalbody = list(finalbody)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Assert (stmt):
+    _fields = ('test', 'msg')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, msg=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.test = test
+        self.msg = msg
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Import (stmt):
+    _fields = ('names',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, names=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.names = list(names)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class ImportFrom (stmt):
+    _fields = ('module', 'names', 'level')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, module, names=[], level=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.module = module
+        self.names = list(names)
+        self.level = level
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Exec (stmt):
+    _fields = ('body', 'globals', 'locals')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, body, globals=None, locals=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.body = body
+        self.globals = globals
+        self.locals = locals
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Global (stmt):
+    _fields = ('names',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, names=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.names = list(names)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Nonlocal (stmt):
+    _fields = ('names',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, names=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.names = list(names)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Expr (stmt):
+    _fields = ('value',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Pass (stmt):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Break (stmt):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Continue (stmt):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class notop (_AST):
+    pass
+
+class Not (notop):
+    _fields = ()
+    _attributes = ()
+
+class ctlstar (_AST):
+    pass
+
+class Spec (ctlstar):
+    _fields = ('atoms', 'properties', 'main')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, atoms=[], properties=[], main=None, lineno=0, col_offset=0, **ARGS):
+        ctlstar.__init__(self, **ARGS)
+        self.atoms = list(atoms)
+        self.properties = list(properties)
+        self.main = main
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class atom (_AST):
+    pass
+
+class InPlace (atom):
+    _fields = ('data', 'place')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, place, data=[], lineno=0, col_offset=0, **ARGS):
+        atom.__init__(self, **ARGS)
+        self.data = list(data)
+        self.place = place
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class NotInPlace (atom):
+    _fields = ('data', 'place')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, place, data=[], lineno=0, col_offset=0, **ARGS):
+        atom.__init__(self, **ARGS)
+        self.data = list(data)
+        self.place = place
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class EmptyPlace (atom):
+    _fields = ('place',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, place, lineno=0, col_offset=0, **ARGS):
+        atom.__init__(self, **ARGS)
+        self.place = place
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class MarkedPlace (atom):
+    _fields = ('place',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, place, lineno=0, col_offset=0, **ARGS):
+        atom.__init__(self, **ARGS)
+        self.place = place
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Deadlock (atom):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        atom.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Boolean (atom):
+    _fields = ('val',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, val, lineno=0, col_offset=0, **ARGS):
+        atom.__init__(self, **ARGS)
+        self.val = val
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Instance (atom):
+    _fields = ('name', 'args')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, args=[], lineno=0, col_offset=0, **ARGS):
+        atom.__init__(self, **ARGS)
+        self.name = name
+        self.args = list(args)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Quantifier (atom):
+    _fields = ('op', 'vars', 'place', 'child', 'distinct')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, op, place, child, distinct, vars=[], lineno=0, col_offset=0, **ARGS):
+        atom.__init__(self, **ARGS)
+        self.op = op
+        self.vars = list(vars)
+        self.place = place
+        self.child = child
+        self.distinct = distinct
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class cmpop (_AST):
+    pass
+
+class Eq (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class NotEq (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class Lt (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class LtE (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class Gt (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class GtE (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class Is (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class IsNot (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class In (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class NotIn (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class keyword (_AST):
+    _fields = ('arg', 'value')
+    _attributes = ()
+    def __init__ (self, arg, value, **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.arg = arg
+        self.value = value
+
+class ctlarg (_AST):
+    pass
+
+class Place (ctlarg):
+    _fields = ('name', 'place')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, place, lineno=0, col_offset=0, **ARGS):
+        ctlarg.__init__(self, **ARGS)
+        self.name = name
+        self.place = place
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Token (ctlarg):
+    _fields = ('name', 'place')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, place, lineno=0, col_offset=0, **ARGS):
+        ctlarg.__init__(self, **ARGS)
+        self.name = name
+        self.place = place
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Argument (ctlarg):
+    _fields = ('name', 'value', 'type')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, value, type, lineno=0, col_offset=0, **ARGS):
+        ctlarg.__init__(self, **ARGS)
+        self.name = name
+        self.value = value
+        self.type = type
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class expr (_AST):
+    pass
+
+class BoolOp (expr):
+    _fields = ('op', 'values')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, op, values=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.op = op
+        self.values = list(values)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class BinOp (expr):
+    _fields = ('left', 'op', 'right')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, left, op, right, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.left = left
+        self.op = op
+        self.right = right
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class UnaryOp (expr):
+    _fields = ('op', 'operand')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, op, operand, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.op = op
+        self.operand = operand
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Lambda (expr):
+    _fields = ('args', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, args, body, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.args = args
+        self.body = body
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class IfExp (expr):
+    _fields = ('test', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, body, orelse, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.test = test
+        self.body = body
+        self.orelse = orelse
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Dict (expr):
+    _fields = ('keys', 'values')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, keys=[], values=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.keys = list(keys)
+        self.values = list(values)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Set (expr):
+    _fields = ('elts',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elts=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elts = list(elts)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class ListComp (expr):
+    _fields = ('elt', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elt, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elt = elt
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class SetComp (expr):
+    _fields = ('elt', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elt, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elt = elt
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class DictComp (expr):
+    _fields = ('key', 'value', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, key, value, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.key = key
+        self.value = value
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class GeneratorExp (expr):
+    _fields = ('elt', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elt, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elt = elt
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Yield (expr):
+    _fields = ('value',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Compare (expr):
+    _fields = ('left', 'ops', 'comparators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, left, ops=[], comparators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.left = left
+        self.ops = list(ops)
+        self.comparators = list(comparators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Call (expr):
+    _fields = ('func', 'args', 'keywords', 'starargs', 'kwargs')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, func, args=[], keywords=[], starargs=None, kwargs=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.func = func
+        self.args = list(args)
+        self.keywords = list(keywords)
+        self.starargs = starargs
+        self.kwargs = kwargs
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Num (expr):
+    _fields = ('n',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, n, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.n = n
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Str (expr):
+    _fields = ('s',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, s, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.s = s
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Ellipsis (expr):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Attribute (expr):
+    _fields = ('value', 'attr', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, attr, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.attr = attr
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Subscript (expr):
+    _fields = ('value', 'slice', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, slice, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.slice = slice
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Starred (expr):
+    _fields = ('value', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Name (expr):
+    _fields = ('id', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, id, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.id = id
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class List (expr):
+    _fields = ('elts', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elts=[], ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elts = list(elts)
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Tuple (expr):
+    _fields = ('elts', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elts=[], ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elts = list(elts)
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class ctldecl (_AST):
+    pass
+
+class Atom (ctldecl):
+    _fields = ('name', 'args', 'params', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, args=[], params=[], body=[], lineno=0, col_offset=0, **ARGS):
+        ctldecl.__init__(self, **ARGS)
+        self.name = name
+        self.args = list(args)
+        self.params = list(params)
+        self.body = list(body)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Property (ctldecl):
+    _fields = ('name', 'args', 'params', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, body, args=[], params=[], lineno=0, col_offset=0, **ARGS):
+        ctldecl.__init__(self, **ARGS)
+        self.name = name
+        self.args = list(args)
+        self.params = list(params)
+        self.body = body
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class alias (_AST):
+    _fields = ('name', 'asname')
+    _attributes = ()
+    def __init__ (self, name, asname=None, **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.name = name
+        self.asname = asname
+
+class ctlparam (_AST):
+    pass
+
+class Parameter (ctlparam):
+    _fields = ('name', 'type')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, type, lineno=0, col_offset=0, **ARGS):
+        ctlparam.__init__(self, **ARGS)
+        self.name = name
+        self.type = type
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)

+module CTLstar version "$Revision: 1 $"
+{
+        ctlstar = Spec(ctldecl* atoms, ctldecl* properties, form? main)
+	      attributes (int lineno, int col_offset)
+
+        ctldecl = Atom(identifier name, ctlarg* args, ctlparams* params,
+                       stmt* body)
+	         | Property(identifier name, ctlargs* args,
+                            ctlparams* params, form body)
+	      attributes (int lineno, int col_offset)
+
+	ctlarg = Place(identifier name, string place)
+	        | Token(identifier name, string place)
+		| Argument(identifier name, expr value, identifier type)
+	      attributes (int lineno, int col_offset)
+
+	ctlparam = Parameter(identifier name, identifier type)
+	      attributes (int lineno, int col_offset)
+
+	form = atom
+	      | CtlUnary(ctlunary op, form child)
+	      | CtlBinary(ctlbinary op, form left, form right)
+	      attributes (int lineno, int col_offset)
+
+	ctlunary = notop | All | Exists | Next | Future | Globally
+
+	notop = Not
+
+	ctlbinary = boolop | Imply | Iff | Until | WeakUntil | Release
+
+	atom = InPlace(expr* data, ctlarg place)
+	      | NotInPlace(expr* data, ctlarg place)
+	      | EmptyPlace(ctlarg place)
+	      | MarkedPlace(ctlarg place)
+	      | Deadlock
+	      | Boolean(bool val)
+	      | Instance(identifier name, arg* args)
+	      | Quantifier(ctlunary op,
+                           identifier* vars,
+                           ctlarg place,
+                           form child,
+                           bool distinct)
+	      attributes (int lineno, int col_offset)
+
+	--------------------------------------------------------------
+	-- the rest is copied from "snakes/lang/python/python.asdl" --
+	--------------------------------------------------------------
+
+	stmt = FunctionDef(identifier name, arguments args,
+                           stmt* body, expr* decorator_list, expr? returns)
+	      | ClassDef(identifier name,
+			 expr* bases,
+			 keyword* keywords,
+			 expr? starargs,
+			 expr? kwargs,
+			 stmt* body,
+			 expr *decorator_list)
+	      | Return(expr? value)
+
+	      | Delete(expr* targets)
+	      | Assign(expr* targets, expr value)
+	      | AugAssign(expr target, operator op, expr value)
+
+	      | For(expr target, expr iter, stmt* body, stmt* orelse)
+	      | While(expr test, stmt* body, stmt* orelse)
+	      | If(expr test, stmt* body, stmt* orelse)
+	      | With(expr context_expr, expr? optional_vars, stmt* body)
+
+	      | Raise(expr? exc, expr? cause)
+	      | TryExcept(stmt* body, excepthandler* handlers, stmt* orelse)
+	      | TryFinally(stmt* body, stmt* finalbody)
+	      | Assert(expr test, expr? msg)
+
+	      | Import(alias* names)
+	      | ImportFrom(identifier module, alias* names, int? level)
+
+	      | Exec(expr body, expr? globals, expr? locals)
+
+	      | Global(identifier* names)
+	      | Nonlocal(identifier* names)
+	      | Expr(expr value)
+	      | Pass | Break | Continue
+
+	      attributes (int lineno, int col_offset)
+
+	expr = BoolOp(boolop op, expr* values)
+	     | BinOp(expr left, operator op, expr right)
+	     | UnaryOp(unaryop op, expr operand)
+	     | Lambda(arguments args, expr body)
+	     | IfExp(expr test, expr body, expr orelse)
+	     | Dict(expr* keys, expr* values)
+	     | Set(expr* elts)
+	     | ListComp(expr elt, comprehension* generators)
+	     | SetComp(expr elt, comprehension* generators)
+	     | DictComp(expr key, expr value, comprehension* generators)
+	     | GeneratorExp(expr elt, comprehension* generators)
+	     | Yield(expr? value)
+	     | Compare(expr left, cmpop* ops, expr* comparators)
+	     | Call(expr func, expr* args, keyword* keywords,
+			 expr? starargs, expr? kwargs)
+	     | Num(object n)
+	     | Str(string s)
+	     | Ellipsis
+
+	     | Attribute(expr value, identifier attr, expr_context ctx)
+	     | Subscript(expr value, slice slice, expr_context ctx)
+	     | Starred(expr value, expr_context ctx)
+	     | Name(identifier id, expr_context ctx)
+	     | List(expr* elts, expr_context ctx)
+	     | Tuple(expr* elts, expr_context ctx)
+
+	      attributes (int lineno, int col_offset)
+
+	expr_context = Load | Store | Del | AugLoad | AugStore | Param
+
+	slice = Slice(expr? lower, expr? upper, expr? step)
+	      | ExtSlice(slice* dims)
+	      | Index(expr value)
+
+	boolop = And | Or
+
+	operator = Add | Sub | Mult | Div | Mod | Pow | LShift
+                 | RShift | BitOr | BitXor | BitAnd | FloorDiv
+
+	unaryop = Invert | notop | UAdd | USub
+
+	cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn
+
+	comprehension = (expr target, expr iter, expr* ifs)
+
+	excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)
+	                attributes (int lineno, int col_offset)
+
+	arguments = (arg* args, identifier? vararg, expr? varargannotation,
+                     arg* kwonlyargs, identifier? kwarg,
+                     expr? kwargannotation, expr* defaults,
+                     expr* kw_defaults)
+	arg = (identifier arg, expr? annotation)
+
+        keyword = (identifier arg, expr value)
+
+        alias = (identifier name, identifier? asname)
+}

+# Grammar for (permissive) CTL*
+
+# new tokens
+$ELLIPSIS '...'
+
+file_input: (NEWLINE | ctl_atomdef | ctl_propdef)* [ ctl_formula ] NEWLINE* ENDMARKER
+
+ctl_atomdef: 'atom' NAME '(' [ctl_parameters] ')' ':' suite
+ctl_propdef: 'prop' NAME '(' [ctl_parameters] ')' ':' ctl_suite
+ctl_suite: ( ctl_formula NEWLINE
+	    | NEWLINE INDENT ctl_formula NEWLINE+ DEDENT )
+ctl_parameters: (ctl_param ',')* ctl_param
+ctl_param: NAME ( '=' '@' STRING+ | ':' NAME )
+
+ctl_formula: ctl_or_formula [ ctl_connector ctl_or_formula ]
+ctl_connector: ( '=' '>' | '<=' '>' )
+ctl_or_formula: ctl_and_formula ('or' ctl_and_formula)*
+ctl_and_formula: ctl_not_formula ('and' ctl_not_formula)*
+ctl_not_formula: ('not' ctl_not_formula | ctl_binary_formula)
+ctl_binary_formula: ctl_unary_formula [ ctl_binary_op ctl_unary_formula ]
+ctl_unary_formula: [ ctl_unary_op ] (ctl_atom_formula | '(' ctl_formula ')')
+ctl_unary_op: ('A' | 'G' | 'F' | 'E' | 'X')
+ctl_binary_op: ('R' | 'U' | 'W')
+ctl_atom_formula: ( 'empty' '(' ctl_place ')'
+                   | 'marked' '(' ctl_place ')'
+		   | 'has' ['not'] '(' ctl_place ',' test (',' test)* ')'
+		   | 'deadlock' | 'True' | 'False'
+		   | NAME '(' ctl_arguments ')'
+		   | 'forall' [ 'distinct' ] NAME (',' NAME)*
+                     'in' ctl_place '(' ctl_atom_formula ')'
+		   | 'exists' [ 'distinct' ] NAME (',' NAME)*
+                     'in' ctl_place '(' ctl_atom_formula ')' )
+ctl_arguments: (NAME '=' ctl_place_or_test ',')* NAME '=' ctl_place_or_test
+ctl_place: '@' STRING+ | NAME
+ctl_place_or_test: test | '@' STRING+
+
+#
+# the rest is from SNAKES/Python grammar
+#
+
+decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
+decorators: decorator+
+decorated: decorators (classdef | funcdef)
+funcdef: 'def' NAME parameters ['-' '>' test] ':' suite
+parameters: '(' [typedargslist] ')'
+typedargslist: ((tfpdef ['=' test] ',')*
+                ('*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef]
+                 | '**' tfpdef)
+                | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
+tfpdef: NAME [':' test]
+varargslist: ((vfpdef ['=' test] ',')*
+              ('*' [vfpdef] (',' vfpdef ['=' test])*  [',' '**' vfpdef]
+               | '**' vfpdef)
+              | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
+vfpdef: NAME
+
+stmt: simple_stmt | compound_stmt
+simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
+small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt |
+             import_stmt | global_stmt | nonlocal_stmt | assert_stmt)
+expr_stmt: testlist (augassign (yield_expr|testlist) |
+                     ('=' (yield_expr|testlist))*)
+augassign: ('+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' |
+            '<<=' | '>>=' | '**=' | '//=')
+del_stmt: 'del' exprlist
+pass_stmt: 'pass'
+flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
+break_stmt: 'break'
+continue_stmt: 'continue'
+return_stmt: 'return' [testlist]
+yield_stmt: yield_expr
+raise_stmt: 'raise' [test ['from' test]]
+import_stmt: import_name | import_from
+import_name: 'import' dotted_as_names
+import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+)
+              'import' ('*' | '(' import_as_names ')' | import_as_names))
+import_as_name: NAME ['as' NAME]
+dotted_as_name: dotted_name ['as' NAME]
+import_as_names: import_as_name (',' import_as_name)* [',']
+dotted_as_names: dotted_as_name (',' dotted_as_name)*
+dotted_name: NAME ('.' NAME)*
+global_stmt: 'global' NAME (',' NAME)*
+nonlocal_stmt: 'nonlocal' NAME (',' NAME)*
+assert_stmt: 'assert' test [',' test]
+
+compound_stmt: (if_stmt | while_stmt | for_stmt | try_stmt | with_stmt
+                | funcdef | classdef | decorated)
+if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
+while_stmt: 'while' test ':' suite ['else' ':' suite]
+for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+try_stmt: ('try' ':' suite
+           ((except_clause ':' suite)+
+	    ['else' ':' suite]
+	    ['finally' ':' suite] |
+	   'finally' ':' suite))
+with_stmt: 'with' test [ with_var ] ':' suite
+with_var: 'as' expr
+except_clause: 'except' [test ['as' NAME]]
+suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
+
+test: or_test ['if' or_test 'else' test] | lambdef
+test_nocond: or_test | lambdef_nocond
+lambdef: 'lambda' [varargslist] ':' test
+lambdef_nocond: 'lambda' [varargslist] ':' test_nocond
+or_test: and_test ('or' and_test)*
+and_test: not_test ('and' not_test)*
+not_test: 'not' not_test | comparison
+comparison: star_expr (comp_op star_expr)*
+comp_op: '<'|'>'|'=='|'>='|'<='|'!='|'<>'|'in'|'not' 'in'|'is'|'is' 'not'
+star_expr: ['*'] expr
+expr: xor_expr ('|' xor_expr)*
+xor_expr: and_expr ('^' and_expr)*
+and_expr: shift_expr ('&' shift_expr)*
+shift_expr: arith_expr (('<<'|'>>') arith_expr)*
+arith_expr: term (('+'|'-') term)*
+term: factor (('*'|'/'|'%'|'//') factor)*
+factor: ('+'|'-'|'~') factor | power
+power: atom trailer* ['**' factor]
+atom: ('(' [yield_expr|testlist_comp] ')' |
+       '[' [testlist_comp] ']' |
+       '{' [dictorsetmaker] '}' |
+       NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False')
+testlist_comp: test ( comp_for | (',' test)* [','] )
+trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
+subscriptlist: subscript (',' subscript)* [',']
+subscript: test | [test] ':' [test] [sliceop]
+sliceop: ':' [test]
+exprlist: star_expr (',' star_expr)* [',']
+testlist: test (',' test)* [',']
+dictorsetmaker: ( (test ':' test (comp_for | (',' test ':' test)* [','])) |
+                  (test (comp_for | (',' test)* [','])) )
+
+classdef: 'class' NAME ['(' [arglist] ')'] ':' suite
+
+arglist: (argument ',')* (argument [',']
+                         |'*' test (',' argument)* [',' '**' test]
+                         |'**' test)
+argument: test [comp_for] | test '=' test
+
+comp_iter: comp_for | comp_if
+comp_for: 'for' exprlist 'in' or_test [comp_iter]
+comp_if: 'if' test_nocond [comp_iter]
+
+yield_expr: 'yield' [testlist]

+"""
+>>> testparser(Translator)
+"""
+
+import operator, sys
+import snakes
+from snakes.lang.python.parser import (ParseTree, ParseTestParser,
+                                       Translator as PyTranslator,
+                                       ParseTree as PyParseTree,
+                                       testparser)
+from snakes.lang.pgen import ParseError
+from snakes.lang.ctlstar.pgen import parser
+import snakes.lang.ctlstar.asdl as ast
+
+_symbols = parser.tokenizer.tok_name.copy()
+# next statement overrides 'NT_OFFSET' entry with 'single_input'
+# (this is desired)
+_symbols.update(parser.symbolMap)
+
+def skip (token) :
+    if token.kind == token.lexer.COMMENT :
+        words = token.strip().split()
+        if words[:2] == ["#", "coding="] :
+            snakes.defaultencoding = words[2]
+        elif words[:3] == ["#", "-*-", "coding:"] :
+            snakes.defaultencoding = words[3]
+
+parser.tokenizer.skip_token = skip
+
+class ParseTree (PyParseTree) :
+    _symbols = _symbols
+
+class Translator (PyTranslator) :
+    ParseTree = ParseTree
+    parser = parser
+    ST = ast
+    def do_file_input (self, st, ctx) :
+        """file_input: (NEWLINE | ctl_atomdef | ctl_propdef)* [ ctl_formula ] NEWLINE* ENDMARKER
+        -> ast.Spec
+
+        <<< atom foo () : return True
+        ... prop bar () : True
+        ... has(@'my place', x)
+        "Spec(atoms=[Atom(name='foo', args=[], params=[], body=[Return(value=Name(id='True', ctx=Load()))])], properties=[Property(name='bar', args=[], params=[], body=Boolean(val=True))], main=InPlace(data=[Name(id='x', ctx=Load())], place=Place(name=None, place='my place')))"
+        """
+        atoms, props, main = [], [], None
+        for i, child in enumerate(st) :
+            if child.symbol == "ctl_atomdef" :
+                atoms.append(self.do(child, ctx))
+            elif child.symbol == "ctl_propdef" :
+                props.append(self.do(child, ctx))
+            elif child.symbol == "ctl_formula" :
+                main = self.do(child, ctx)
+            elif child.symbol in ("NEWLINE", "ENDMARKER") :
+                pass
+            else :
+                raise ParseError(child.text, reason="unexpected token")
+        return self.ST.Spec(lineno=st.srow, col_offset=st.scol,
+                            atoms=atoms, properties=props, main=main)
+    def do_ctl_atomdef (self, st, ctx) :
+        """ctl_atomdef: 'atom' NAME '(' [ctl_parameters] ')' ':' suite
+        -> ast.Atom
+
+        <<< atom foo () : return True
+        "Spec(atoms=[Atom(name='foo', args=[], params=[], body=[Return(value=Name(id='True', ctx=Load()))])], properties=[], main=None)"
+        <<< atom bar () :
+        ...     return True
+        "Spec(atoms=[Atom(name='bar', args=[], params=[], body=[Return(value=Name(id='True', ctx=Load()))])], properties=[], main=None)"
+        <<< atom egg (p = @'my place', x : int, q : place) :
+        ...     return x in p and x in q
+        "Spec(atoms=[Atom(name='egg', args=[Place(name='p', place='my place')], params=[Parameter(name='x', type='int'), Parameter(name='q', type='place')], body=[Return(value=BoolOp(op=And(), values=[Compare(left=Name(id='x', ctx=Load()), ops=[In()], comparators=[Name(id='p', ctx=Load())]), Compare(left=Name(id='x', ctx=Load()), ops=[In()], comparators=[Name(id='q', ctx=Load())])]))])], properties=[], main=None)"
+        """
+        if len(st) == 7 :
+            args, params = self.do(st[3], ctx)
+            return self.ST.Atom(lineno=st.srow, col_offset=st.scol,
+                                name=st[1].text,
+                                args=args,
+                                params=params,
+                                body=self.do(st[-1], ctx))
+        else :
+            return self.ST.Atom(lineno=st.srow, col_offset=st.scol,
+                                name=st[1].text,
+                                args=[],
+                                params=[],
+                                body=self.do(st[-1], ctx))
+    def do_ctl_propdef (self, st, ctx) :
+        """ctl_propdef: 'prop' NAME '(' [ctl_parameters] ')' ':' ctl_suite
+        -> ast.Property
+
+        <<< prop foo () : True
+        "Spec(atoms=[], properties=[Property(name='foo', args=[], params=[], body=Boolean(val=True))], main=None)"
+        <<< prop bar (p = @'my place', x : int, q : place) : True
+        "Spec(atoms=[], properties=[Property(name='bar', args=[Place(name='p', place='my place')], params=[Parameter(name='x', type='int'), Parameter(name='q', type='place')], body=Boolean(val=True))], main=None)"
+        <<< prop egg (p = @'my place', x : int, q : place) : True
+        "Spec(atoms=[], properties=[Property(name='egg', args=[Place(name='p', place='my place')], params=[Parameter(name='x', type='int'), Parameter(name='q', type='place')], body=Boolean(val=True))], main=None)"
+        """
+        if len(st) == 7 :
+            args, params = self.do(st[3], ctx)
+            return self.ST.Property(lineno=st.srow, col_offset=st.scol,
+                                    name=st[1].text,
+                                    args=args,
+                                    params=params,
+                                    body=self.do(st[-1], ctx))
+        else :
+            return self.ST.Property(lineno=st.srow, col_offset=st.scol,
+                                    name=st[1].text,
+                                    args=[],
+                                    params=[],
+                                    body=self.do(st[-1], ctx))
+    def do_ctl_suite (self, st, ctx) :
+        """ctl_suite: ( ctl_formula NEWLINE | NEWLINE INDENT ctl_formula DEDENT )
+        -> ast.form
+
+        <<< prop foo () : True
+        "Spec(atoms=[], properties=[Property(name='foo', args=[], params=[], body=Boolean(val=True))], main=None)"
+        <<< prop bar () :
+        ...    True
+        "Spec(atoms=[], properties=[Property(name='bar', args=[], params=[], body=Boolean(val=True))], main=None)"
+        """
+        if len(st) == 2 :
+            return self.do(st[0], ctx)
+        else :
+            return self.do(st[2], ctx)
+    def do_ctl_parameters (self, st, ctx) :
+        """ctl_parameters: (ctl_param ',')* ctl_param
+        -> [ast.ctlarg], [ast.ctlparam]
+
+        <<< prop foo (p = @'my place', q : place, x : int, r : place) : True
+        "Spec(atoms=[], properties=[Property(name='foo', args=[Place(name='p', place='my place')], params=[Parameter(name='q', type='place'), Parameter(name='x', type='int'), Parameter(name='r', type='place')], body=Boolean(val=True))], main=None)"
+        <<< prop bar (x : int) : True
+        "Spec(atoms=[], properties=[Property(name='bar', args=[], params=[Parameter(name='x', type='int')], body=Boolean(val=True))], main=None)"
+        <<< prop egg (p = @'my place') : True
+        "Spec(atoms=[], properties=[Property(name='egg', args=[Place(name='p', place='my place')], params=[], body=Boolean(val=True))], main=None)"
+        <<< prop spam (p = @'my place', q : int, p : place) : True
+        Traceback (most recent call last):
+        ...
+        ParseError: ... duplicate parameter 'p'
+        """
+        args, params = [], []
+        seen = set()
+        for child in st[::2] :
+            node = self.do(child, ctx)
+            if node.name in seen :
+                raise ParseError(child, reason="duplicate parameter %r"
+                                 % node.name)
+            seen.add(node.name)
+            if isinstance(node, self.ST.Place) :
+                args.append(node)
+            else :
+                params.append(node)
+        return args, params
+    def do_ctl_param (self, st, ctx) :
+        """ctl_param: NAME ( '=' '@' STRING+ | ':' NAME )
+        -> ast.ctlarg|ast.ctlparam
+
+        <<< prop foo (p = @'my place', q : place, x : int, r : place) : True
+        "Spec(atoms=[], properties=[Property(name='foo', args=[Place(name='p', place='my place')], params=[Parameter(name='q', type='place'), Parameter(name='x', type='int'), Parameter(name='r', type='place')], body=Boolean(val=True))], main=None)"
+        <<< prop bar (x : int) : True
+        "Spec(atoms=[], properties=[Property(name='bar', args=[], params=[Parameter(name='x', type='int')], body=Boolean(val=True))], main=None)"
+        <<< prop egg (p = @'my place') : True
+        "Spec(atoms=[], properties=[Property(name='egg', args=[Place(name='p', place='my place')], params=[], body=Boolean(val=True))], main=None)"
+        """
+        if st[1].text == "=" :
+            return self.ST.Place(lineno=st.srow, col_offset=st.scol,
+                                 name=st[0].text,
+                                 place="".join(self.ST.literal_eval(c.text)
+                                               for c in st[3:]))
+        else :
+            return self.ST.Parameter(lineno=st.srow, col_offset=st.scol,
+                                     name=st[0].text,
+                                     type=st[2].text)
+    def do_ctl_arguments (self, st, ctx) :
+        """ctl_arguments: (NAME '=' ctl_place_or_test ',')* NAME '=' ctl_place_or_test
+        -> [(str, ast.expr)]
+
+        <<< foo(x=3, p='my place')
+        "Spec(atoms=[], properties=[], main=Instance(name='foo', args=[arg(arg='x', annotation=Num(n=3)), arg(arg='p', annotation=Str(s='my place'))]))"
+        <<< foo(x=3)
+        "Spec(atoms=[], properties=[], main=Instance(name='foo', args=[arg(arg='x', annotation=Num(n=3))]))"
+        <<< foo(p='my place')
+        "Spec(atoms=[], properties=[], main=Instance(name='foo', args=[arg(arg='p', annotation=Str(s='my place'))]))"
+        <<< foo(x=3, p=@'my place')
+        "Spec(atoms=[], properties=[], main=Instance(name='foo', args=[arg(arg='x', annotation=Num(n=3)), arg(arg='p', annotation=Place(name=None, place='my place'))]))"
+        <<< foo(x=3)
+        "Spec(atoms=[], properties=[], main=Instance(name='foo', args=[arg(arg='x', annotation=Num(n=3))]))"
+        <<< foo(p=@'my place')
+        "Spec(atoms=[], properties=[], main=Instance(name='foo', args=[arg(arg='p', annotation=Place(name=None, place='my place'))]))"
+        """
+        return [self.ST.arg(name.text, self.do(value, ctx))
+                for name, value in zip(st[::4], st[2::4])]
+    def do_ctl_place_or_test (self, st, ctx) :
+        """ctl_place_or_test: test | '@' STRING+
+        -> ast.expr | ast.Place
+
+        <<< Foo(s='string', p=@'place', q=place_also)
+        "Spec(atoms=[], properties=[], main=Instance(name='Foo', args=[arg(arg='s', annotation=Str(s='string')), arg(arg='p', annotation=Place(name=None, place='place')), arg(arg='q', annotation=Name(id='place_also', ctx=Load()))]))"
+        """
+        if st[0].symbol == "test" :
+            return self.do(st[0], ctx)
+        else :
+            return self.do_ctl_place(st, ctx)
+    def do_ctl_formula (self, st, ctx) :
+        """ctl_formula: ctl_or_formula [ ctl_connector ctl_or_formula ]
+        -> ast.form
+
+        <<< True
+        'Spec(atoms=[], properties=[], main=Boolean(val=True))'
+        <<< False => True
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Imply(), left=Boolean(val=False), right=Boolean(val=True)))'
+        <<< False <=> False
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Iff(), left=Boolean(val=False), right=Boolean(val=False)))'
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            return self.ST.CtlBinary(lineno=st.srow, col_offset=st.scol,
+                                     op=self.do_ctl_connector(st[1], ctx),
+                                     left=self.do(st[0], ctx),
+                                     right=self.do(st[2], ctx))
+    def do_ctl_connector (self, st, ctx) :
+        """ctl_connector: ( '=' '>' | '<=' '>' )
+        -> ast.ctlbinary
+
+        <<< False => True
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Imply(), left=Boolean(val=False), right=Boolean(val=True)))'
+        <<< False <=> False
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Iff(), left=Boolean(val=False), right=Boolean(val=False)))'
+        """
+        op = "".join(child.text for child in st)
+        return self._ctl_binary_op[op](lineno=st.srow,
+                                       col_offset=st.scol)
+
+    def do_ctl_or_formula (self, st, ctx) :
+        """ctl_or_formula: ctl_and_formula ('or' ctl_and_formula)*
+        -> ast.form
+
+        <<< True or False
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Or(), left=Boolean(val=True), right=Boolean(val=False)))'
+        <<< True or False or True
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Or(), left=CtlBinary(op=Or(), left=Boolean(val=True), right=Boolean(val=False)), right=Boolean(val=True)))'
+        <<< True or False or False and True and False
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Or(), left=CtlBinary(op=Or(), left=Boolean(val=True), right=Boolean(val=False)), right=CtlBinary(op=And(), left=CtlBinary(op=And(), left=Boolean(val=False), right=Boolean(val=True)), right=Boolean(val=False))))'
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            values = [self.do(child, ctx) for child in st[::2]]
+            ops = [self._ctl_binary_op[child.text](lineno=child.srow,
+                                                   col_offset=child.scol)
+                   for child in st[1::2]]
+            while len(values) > 1 :
+                left = values.pop(0)
+                right = values.pop(0)
+                operator = ops.pop(0)
+                values.insert(0, self.ST.CtlBinary(lineno=st.srow,
+                                                   col_offset=st.scol,
+                                                   left=left,
+                                                   op=operator,
+                                                   right=right))
+            return values[0]
+    def do_ctl_and_formula (self, st, ctx) :
+        """ctl_and_formula: ctl_not_formula ('and' ctl_not_formula)*
+        -> ast.form
+
+        <<< True and False
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=And(), left=Boolean(val=True), right=Boolean(val=False)))'
+        """
+        return self.do_ctl_or_formula(st, ctx)
+    def do_ctl_not_formula (self, st, ctx) :
+        """ctl_not_formula: ('not' ctl_not_formula | ctl_binary_formula)
+        -> ast.form
+
+        <<< True
+        'Spec(atoms=[], properties=[], main=Boolean(val=True))'
+        <<< not True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=Not(), child=Boolean(val=True)))'
+        <<< not not True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=Not(), child=CtlUnary(op=Not(), child=Boolean(val=True))))'
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            return self.ST.CtlUnary(lineno=st.srow, col_offset=st.scol,
+                                    op=self.ST.Not(lineno=st[0].srow,
+                                                   col_offset=st[0].scol),
+                                    child=self.do(st[1], ctx))
+    def do_ctl_binary_formula (self, st, ctx) :
+        """ctl_binary_formula: ctl_unary_formula [ ctl_binary_op ctl_unary_formula ]
+        -> ast.form
+
+        <<< True U False
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Until(), left=Boolean(val=True), right=Boolean(val=False)))'
+        <<< True W False
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=WeakUntil(), left=Boolean(val=True), right=Boolean(val=False)))'
+        <<< True R False
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Release(), left=Boolean(val=True), right=Boolean(val=False)))'
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            return self.ST.CtlBinary(lineno=st.srow, col_offset=st.scol,
+                                     op=self.do(st[1], ctx),
+                                     left=self.do(st[0], ctx),
+                                     right=self.do(st[2], ctx))
+    def do_ctl_unary_formula (self, st, ctx) :
+        """ctl_unary_formula: [ ctl_unary_op ] (ctl_atom_formula | '(' ctl_formula ')')
+        -> ast.form
+
+        <<< True
+        'Spec(atoms=[], properties=[], main=Boolean(val=True))'
+        <<< X True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=Next(), child=Boolean(val=True)))'
+        <<< A True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=All(), child=Boolean(val=True)))'
+        <<< G True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=Globally(), child=Boolean(val=True)))'
+        <<< F True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=Future(), child=Boolean(val=True)))'
+        <<< E True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=Exists(), child=Boolean(val=True)))'
+        <<< (True or False)
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Or(), left=Boolean(val=True), right=Boolean(val=False)))'
+        <<< X (True or False)
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=Next(), child=CtlBinary(op=Or(), left=Boolean(val=True), right=Boolean(val=False))))'
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        elif len(st) == 2 :
+            return self.ST.CtlUnary(lineno=st.srow, col_offset=st.scol,
+                                    op=self.do(st[0], ctx),
+                                    child=self.do(st[1], ctx))
+        elif len(st) == 3 :
+            return self.do(st[1], ctx)
+        else :
+            return self.ST.CtlUnary(lineno=st.srow, col_offset=st.scol,
+                                    op=self.do(st[0], ctx),
+                                    child=self.do(st[2], ctx))
+    _ctl_unary_op = {"A" : ast.All,
+                     "E" : ast.Exists,
+                     "X" : ast.Next,
+                     "F" : ast.Future,
+                     "G" : ast.Globally}
+    def do_ctl_unary_op (self, st, ctx) :
+        """ctl_unary_op: ('A' | 'G' | 'F' | 'E' | 'X')
+        -> ast.ctlunary
+
+        <<< X True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=Next(), child=Boolean(val=True)))'
+        <<< A True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=All(), child=Boolean(val=True)))'
+        <<< G True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=Globally(), child=Boolean(val=True)))'
+        <<< F True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=Future(), child=Boolean(val=True)))'
+        <<< E True
+        'Spec(atoms=[], properties=[], main=CtlUnary(op=Exists(), child=Boolean(val=True)))'
+        """
+        return self._ctl_unary_op[st[0].text](lineno=st.srow,
+                                              col_offset=st.scol)
+    _ctl_binary_op = {"=>"  : ast.Imply,
+                      "<=>" : ast.Iff,
+                      "and" : ast.And,
+                      "or"  : ast.Or,
+                      "U"   : ast.Until,
+                      "W"   : ast.WeakUntil,
+                      "R"   : ast.Release}
+    def do_ctl_binary_op (self, st, ctx) :
+        """ctl_binary_op: ('R' | 'U' | 'W')
+        -> ast.ctlbinary
+
+        <<< True R False
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Release(), left=Boolean(val=True), right=Boolean(val=False)))'
+        <<< True U False
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=Until(), left=Boolean(val=True), right=Boolean(val=False)))'
+        <<< True W False
+        'Spec(atoms=[], properties=[], main=CtlBinary(op=WeakUntil(), left=Boolean(val=True), right=Boolean(val=False)))'
+        """
+        return self._ctl_binary_op[st[0].text](lineno=st[0].srow,
+                                               col_offset=st[0].scol)
+    def do_ctl_atom_formula (self, st, ctx) :
+        """ctl_atom_formula: ( 'empty' '(' ctl_place ')'
+                   | 'marked' '(' ctl_place ')'
+		   | 'has' ['not'] '(' ctl_place ',' test (',' test)* ')'
+		   | 'deadlock' | 'True' | 'False'
+		   | NAME '(' ctl_arguments ')'
+		   | 'forall' [ 'distinct' ] NAME (',' NAME)*
+                     'in' ctl_place '(' ctl_atom_formula ')'
+		   | 'exists' [ 'distinct' ] NAME (',' NAME)*
+                     'in' ctl_place '(' ctl_atom_formula ')' )
+        -> ast.atom
+
+        <<< empty(p)
+        "Spec(atoms=[], properties=[], main=EmptyPlace(place=Parameter(name='p', type='place')))"
+        <<< empty(@'my' 'place')
+        "Spec(atoms=[], properties=[], main=EmptyPlace(place=Place(name=None, place='myplace')))"
+        <<< marked(p)
+        "Spec(atoms=[], properties=[], main=MarkedPlace(place=Parameter(name='p', type='place')))"
+        <<< marked(@'my place')
+        "Spec(atoms=[], properties=[], main=MarkedPlace(place=Place(name=None, place='my place')))"
+        <<< has(p, x)
+        "Spec(atoms=[], properties=[], main=InPlace(data=[Name(id='x', ctx=Load())], place=Parameter(name='p', type='place')))"
+        <<< has not(p, x, y)
+        "Spec(atoms=[], properties=[], main=NotInPlace(data=[Name(id='x', ctx=Load()), Name(id='y', ctx=Load())], place=Parameter(name='p', type='place')))"
+        <<< deadlock
+        'Spec(atoms=[], properties=[], main=Deadlock())'
+        <<< True
+        'Spec(atoms=[], properties=[], main=Boolean(val=True))'
+        <<< False
+        'Spec(atoms=[], properties=[], main=Boolean(val=False))'
+        <<< myprop(x=1, p='my place')
+        "Spec(atoms=[], properties=[], main=Instance(name='myprop', args=[arg(arg='x', annotation=Num(n=1)), arg(arg='p', annotation=Str(s='my place'))]))"
+        <<< forall x in p (has(q, y))
+        "Spec(atoms=[], properties=[], main=Quantifier(op=All(), vars=['x'], place=Parameter(name='p', type='place'), child=InPlace(data=[Name(id='y', ctx=Load())], place=Parameter(name='q', type='place')), distinct=False))"
+        <<< forall x, y in p (has(q, x+y, x-y))
+        "Spec(atoms=[], properties=[], main=Quantifier(op=All(), vars=['x', 'y'], place=Parameter(name='p', type='place'), child=InPlace(data=[BinOp(left=Name(id='x', ctx=Load()), op=Add(), right=Name(id='y', ctx=Load())), BinOp(left=Name(id='x', ctx=Load()), op=Sub(), right=Name(id='y', ctx=Load()))], place=Parameter(name='q', type='place')), distinct=False))"
+        <<< forall distinct x, y in p (has(q, x+y, x-y))
+        "Spec(atoms=[], properties=[], main=Quantifier(op=All(), vars=['x', 'y'], place=Parameter(name='p', type='place'), child=InPlace(data=[BinOp(left=Name(id='x', ctx=Load()), op=Add(), right=Name(id='y', ctx=Load())), BinOp(left=Name(id='x', ctx=Load()), op=Sub(), right=Name(id='y', ctx=Load()))], place=Parameter(name='q', type='place')), distinct=True))"
+        <<< exists x in p (has(q, y))
+        "Spec(atoms=[], properties=[], main=Quantifier(op=Exists(), vars=['x'], place=Parameter(name='p', type='place'), child=InPlace(data=[Name(id='y', ctx=Load())], place=Parameter(name='q', type='place')), distinct=False))"
+        <<< exists x, y in p (has(q, x+y, x-y))
+        "Spec(atoms=[], properties=[], main=Quantifier(op=Exists(), vars=['x', 'y'], place=Parameter(name='p', type='place'), child=InPlace(data=[BinOp(left=Name(id='x', ctx=Load()), op=Add(), right=Name(id='y', ctx=Load())), BinOp(left=Name(id='x', ctx=Load()), op=Sub(), right=Name(id='y', ctx=Load()))], place=Parameter(name='q', type='place')), distinct=False))"
+        <<< exists distinct x, y in p (has(q, x+y, x-y))
+        "Spec(atoms=[], properties=[], main=Quantifier(op=Exists(), vars=['x', 'y'], place=Parameter(name='p', type='place'), child=InPlace(data=[BinOp(left=Name(id='x', ctx=Load()), op=Add(), right=Name(id='y', ctx=Load())), BinOp(left=Name(id='x', ctx=Load()), op=Sub(), right=Name(id='y', ctx=Load()))], place=Parameter(name='q', type='place')), distinct=True))"
+        """
+        if st[0].text in ("True", "False") :
+            return self.ST.Boolean(lineno=st.srow, col_offset=st.scol,
+                                   val=(st[0].text  == "True"))
+        elif st[0].text == "deadlock" :
+            return self.ST.Deadlock(lineno=st.srow, col_offset=st.scol)
+        elif st[0].text in ("empty", "marked") :
+            node = (self.ST.EmptyPlace if st[0].text == "empty"
+                    else self.ST.MarkedPlace)
+            return node(lineno=st.srow, col_offset=st.scol,
+                        place=self.do(st[2], ctx))
+        elif st[0].text == "has" :
+            if st[1].text == "not" :
+                node = self.ST.NotInPlace
+                start = 3
+            else :
+                node = self.ST.InPlace
+                start = 2
+            place = self.do(st[start], ctx)
+            if (isinstance(place, self.ST.Parameter)
+                and place.type != "place") :
+                raise ParseError(st[-4], reason="'place' parameter expected")
+            return node(lineno=st.srow, col_offset=st.scol,
+                        data=[self.do(c, ctx) for c in st[start+2::2]],
+                        place=place)
+        elif st[0].text in ("forall", "exists") :
+            op = (self.ST.All if st[0].text == "forall"
+                  else self.ST.Exists)
+            distinct = st[1].text == "distinct"
+            start = 2 if distinct else 1
+            return self.ST.Quantifier(lineno=st.srow, col_offset=st.scol,
+                                      op=op(),
+                                      vars=[c.text for c in st[start:-5:2]],
+                                      place=self.do(st[-4], ctx),
+                                      child=self.do(st[-2], ctx),
+                                      distinct=distinct)
+        else :
+            return self.ST.Instance(lineno=st.srow, col_offset=st.scol,
+                                    name=st[0].text,
+                                    args=self.do(st[2], ctx))
+    def do_ctl_place (self, st, ctx) :
+        """ctl_place: '@' STRING+ | NAME
+        -> ast.ctlarg
+
+        <<< has(@'my place', x)
+        "Spec(atoms=[], properties=[], main=InPlace(data=[Name(id='x', ctx=Load())], place=Place(name=None, place='my place')))"
+        <<< has(@'another' 'place', y)
+        "Spec(atoms=[], properties=[], main=InPlace(data=[Name(id='y', ctx=Load())], place=Place(name=None, place='anotherplace')))"
+        <<< has(@'my place', x, y)
+        "Spec(atoms=[], properties=[], main=InPlace(data=[Name(id='x', ctx=Load()), Name(id='y', ctx=Load())], place=Place(name=None, place='my place')))"
+        <<< has not(@'my place', x)
+        "Spec(atoms=[], properties=[], main=NotInPlace(data=[Name(id='x', ctx=Load())], place=Place(name=None, place='my place')))"
+        <<< has not(@'my place', x, y)
+        "Spec(atoms=[], properties=[], main=NotInPlace(data=[Name(id='x', ctx=Load()), Name(id='y', ctx=Load())], place=Place(name=None, place='my place')))"
+        """
+        if st[0].symbol == "NAME" :
+            return self.ST.Parameter(lineno=st.srow, col_offset=st.scol,
+                                     name=st[0].text,
+                                     type="place")
+        else :
+            return self.ST.Place(lineno=st.srow, col_offset=st.scol,
+                                 name=None,
+                                 place="".join(self.ST.literal_eval(c.text)
+                                               for c in st[1:]))
+
+parse = Translator.parse
+
+if __name__ == "__main__" :
+    testparser(Translator)

+"""A Python implementation of CPython's parser
+
+This module is largely based on Jonathan Riehl's PyPgen included in
+the Basil framework (http://code.google.com/p/basil).
+"""
+
+from snakes import SnakesError
+from snakes.lang import ast
+import tokenize, string, pprint, warnings, inspect, os.path
+from snakes.compat import *
+
+def warn (message) :
+    """Issue a warning message.
+    """
+    warnings.warn(message, stacklevel=2)
+
+class Token (str) :
+    """A token from the lexer.
+
+    Behaves as a string that is either the token value (if not empty),
+    or the token name. Additional attributes allow to extract various
+    information:
+
+     - self.kind: token number (like tokenize.ENDMARKER)
+       also available as int(self)
+     - self.text: token text
+     - self.srow: start row
+     - self.scol: start column
+     - self.erow: end row
+     - self.ecol: end column
+     - self.line: full line of text from which the token comes
+     - self.name: token name (ie, tokenize.tok_name[self.kind])
+     - self.lexer: the Tokenizer instance than produced this token
+     - self.filename: input file from which the token comes (or
+       '<string>' if None available)
+    """
+    def __new__ (cls, token, lexer) :
+        """Create a new instance.
+
+        __new__ is used instead of __init__ because str is a
+        non-mutable object and this __init__ could not assign a str
+        content. For more information see:
+
+          http://docs.python.org/reference/datamodel.html#object.__new__
+        """
+        kind = token[0]
+        text = token[1]
+        name = lexer.tok_name[kind]
+        self = str.__new__(cls, text or name)
+        self.kind = kind
+        self.text = text
+        self.srow, self.scol = token[2]
+        self.erow, self.ecol = token[3]
+        self.line = token[4]
+        self.name = name
+        self.lexer = lexer
+        try :
+            self.filename = lexer.infile.name
+        except :
+            self.filename = "<string>"
+        return self
+    def __int__ (self) :
+        """Coercion to int (return self.kind).
+        """
+        return self.kind
+
+class Location (str) :
+    """A position in a parsed file
+
+    Used to aggregate the positions of all the tokens is a parse
+    (sub)tree. The following attributes are available:
+
+     - self.srow: start row
+     - self.scol: start column
+     - self.erow: end row
+     - self.ecol: end column
+     - self.filename: input file from which the token comes (or
+       '<string>' if None available)
+    """
+    def __new__ (cls, first, last) :
+        """Create a new instance
+
+        Expected arguments:
+         - first: the first Token or Location instance in the region
+         - last: the last one
+        """
+        self = str.__new__(cls, "%s[%s:%s-%s:%s]"
+                           % (first.filename, first.srow, first.scol,
+                              last.erow, last.ecol))
+        self.srow, self.scol = first.srow, first.scol
+        self.erow, self.ecol = last.erow, last.ecol
+        self.filename = first.filename
+        self.lexer = first.lexer
+        return self
+
+class ParseError (SnakesError) :
+    """Exception raised when parsing fails.
+
+    It's better not to use SyntaxError because this soes not allows to
+    distinguish when the text being parser has a syntax error from
+    when because the parser itself has a syntax error.
+    """
+    def __init__ (self, token, expected=None, reason=None) :
+        """Initialize a new instance.
+
+        Expected arguments are:
+         - token: the erroneous token (a Token instance)
+         - expected: either a Token instance or a token kind (like
+           tokenize.NAME) to indicated what was expected instead
+        """
+        self.token = token
+        if expected is not None :
+            expected = int(expected)
+        self.expected = expected
+        if token is None :
+            pos = ""
+        else :
+            pos = "%s[%s:%s]: " % (token.filename, token.srow, token.scol)
+        if reason is not None :
+            msg = reason
+        elif self.expected is not None :
+            msg = ("expected %s but found %r" %
+                   (token.lexer.tok_name[expected], token))
+        else :
+            msg = "unexpected token %r" % token
+        SnakesError.__init__(self, pos + msg)
+
+class Tokenizer (object) :
+    """A simple lexical analyser based on Python's tokenize module.
+
+    The differences with tokenize module are:
+     - new simple tokens may be added (just strings, no regexps)
+     - Python's token may be not included
+     - tokens may be automatically skipped (removed from the output)
+     - tokenize.OP kind is refined (eg, ':' gets kind tokenize.COLON)
+
+    This class replaces two PyPgen elements:
+     - module basil.lang.python.TokenUtils
+     - module basil.lang.python.StdTokenizer
+    """
+    _pyopmap = {
+        '(' : tokenize.LPAR,
+        ')' : tokenize.RPAR,
+        '[' : tokenize.LSQB,
+        ']' : tokenize.RSQB,
+        ':' : tokenize.COLON,
+        ',' : tokenize.COMMA,
+        ';' : tokenize.SEMI,
+        '+' : tokenize.PLUS,
+        '+=' : tokenize.PLUSEQUAL,
+        '-' : tokenize.MINUS,
+        '-=' : tokenize.MINEQUAL,
+        '*' : tokenize.STAR,
+        '**' : tokenize.DOUBLESTAR,
+        '**=' : tokenize.DOUBLESTAREQUAL,
+        '*=' : tokenize.STAREQUAL,
+        '/' : tokenize.SLASH,
+        '//' : tokenize.DOUBLESLASH,
+        '//=' : tokenize.DOUBLESLASHEQUAL,
+        '/=' : tokenize.SLASHEQUAL,
+        '|' : tokenize.VBAR,
+        '|=' : tokenize.VBAREQUAL,
+        '&' : tokenize.AMPER,
+        '&=' : tokenize.AMPEREQUAL,
+        '<' : tokenize.LESS,
+        '<=' : tokenize.LESSEQUAL,
+        '<<' : tokenize.LEFTSHIFT,
+        '<<=' : tokenize.LEFTSHIFTEQUAL,
+        '>' : tokenize.GREATER,
+        '>=' : tokenize.GREATEREQUAL,
+        '>>' : tokenize.RIGHTSHIFT,
+        '>>=' : tokenize.RIGHTSHIFTEQUAL,
+        '=' : tokenize.EQUAL,
+        '==' : tokenize.EQEQUAL,
+        '.' : tokenize.DOT,
+        '%' : tokenize.PERCENT,
+        '%=' : tokenize.PERCENTEQUAL,
+        '{' : tokenize.LBRACE,
+        '}' : tokenize.RBRACE,
+        '^' : tokenize.CIRCUMFLEX,
+        '^=' : tokenize.CIRCUMFLEXEQUAL,
+        '~' : tokenize.TILDE,
+        '!=' : tokenize.NOTEQUAL,
+        '<>' : tokenize.NOTEQUAL,
+        '@' : tokenize.AT
+        }
+    def __init__ (self, python=True, opmap={}, skip=None, **extra) :
+        """Initialize a new instance.
+
+        Expected arguments are:
+         - python: a bool to indicate whether to include or not
+           Python's tokens (default to True)
+         - opmap: a dict to map litteral tokens (given as '...' in the
+           grammar) to token kinds (default to {}). This parameter is
+           useful only to redefine Python's mapping
+         - skip: a collection of tokens that the tokenizer will
+           automatically skip (default to [COMMENT, NL])
+         - additional keywords arguments allow to define new tokens,
+           for instance, providing
+              DOLLAR='$'
+           defines a new token called 'DOLLAR' (its kind will be
+           automatically computed)
+
+        An instance of Tokenizer has the following attributes:
+         - self.opmap: a dict mapping operators token literals to the
+           corresponding kind, for instance, ':' is mapped to
+           tokenize.COLON (this can be overridden using argument
+           opmap)
+         - self.tok_name: a replacement of tokenize.tok_name that also
+           include the user-defined tokens
+         - for each token called FOO (including user-defined ones), an
+           attribute self.FOO hols the corresponding kind
+        """
+        self._python = python
+        self._opmap = opmap.copy()
+        if python :
+            self.opmap = self._pyopmap.copy()
+            self.opmap.update(opmap)
+        else :
+            self.opmap = opmap.copy()
+        self.tok_name = {}
+        self._extra = {}
+        if python :
+            for kind, name in tokenize.tok_name.items() :
+                self.tok_name[kind] = name
+                setattr(self, name, kind)
+        if not hasattr(self, "NT_OFFSET") :
+            self.NT_OFFSET = 256
+        last = max(n for n in self.tok_name if n != self.NT_OFFSET)
+        for shift, (name, txt) in enumerate(sorted(extra.items())) :
+            #WARNING: sorted above is required to guaranty that extra
+            # tokens will always get the same number (dict order is
+            # not guaranteed)
+            kind = last + shift
+            if kind >= self.NT_OFFSET :
+                raise TypeError("too many new tokens")
+            self.tok_name[kind] = name
+            setattr(self, name, kind)
+            self._extra[txt] = kind
+        self.opmap.update(self._extra)
+        if skip is None :
+            skip = [self.COMMENT, self.NL]
+        self._skip = set(skip)
+    def __repr__ (self) :
+        """Encodes an instance as Python source code.
+
+        Non-default arguments provided to the constructor are included
+        so that exactly the same Tokenizer instance can be recovered
+        from the returned source code.
+
+        >>> print repr(Tokenizer())
+        Tokenizer()
+        >>> print repr(Tokenizer(DOLLAR='$'))
+        Tokenizer(DOLLAR='$')
+        >>> print repr(Tokenizer(skip=[], DOLLAR='$'))
+        Tokenizer(skip=[], DOLLAR='$')
+        """
+        args = []
+        if not self._python :
+            args.append("python=%s" % self._python)
+        if self._opmap :
+            args.append("opmap=%r" % self._opmap)
+        if self._skip != set([self.COMMENT, self.NL]) :
+            args.append("skip=%r" % list(self._skip))
+        args.extend("%s=%r" % (self.tok_name[kind], txt) for txt, kind
+                    in self._extra.items())
+        return "%s(%s)" % (self.__class__.__name__, ", ".join(args))
+    def tokenize (self, stream) :
+        """Break an input stream into tokens.
+
+        Expected argument is:
+         - stream: a file-like object (with a method readline)
+
+        Return a generator of Token instances, ParseError is raised
+        whenever an erroneous token is encountered.
+
+        This is basically the same as tokenize.generate_tokens but:
+         - the appropriate tokens are skipped
+         - OP kind is converted according to self.opmap
+         - user-defined tokens are handled
+
+        During the iteration, two more attributes can be used:
+         - self.last: last recognized token (ie, last yielded)
+         - self.infile: the input stream passed to method tokenize
+        """
+        self.infile = stream
+        self.last = None
+        self.lines = []
+        def readline () :
+            self.lines.append(stream.readline())
+            return self.lines[-1]
+        err = self.ERRORTOKEN
+        for token in tokenize.generate_tokens(readline) :
+            if token[0] == err :
+                try :
+                    token = (self._extra[token[1]],) + token[1:]
+                except :
+                    raise ParseError(Token(token, self))
+            elif token[0] in self._skip :
+                try:
+                    self.skip_token(Token(token, self))
+                except :
+                    pass
+                continue
+            elif token[0] == self.OP :
+                token = (self.opmap[token[1]],) + token[1:]
+            self.last = Token(token, self)
+            yield self.last
+    def skip_token (self, token) :
+        pass
+
+try :
+    Tokenizer._pyopmap['`'] = tokenize.BACKQUOTE
+except AttributeError :
+    pass
+
+class PgenParser (object) :
+    """A parser for pgen files.
+
+    The following grammar is used:
+
+        mstart : ( rule | NEWLINE | newtok )* ENDMARKER
+        newtok : '$' NAME STRING NEWLINE
+        rule : NAME COLON rhs NEWLINE
+        rhs := alt ( VBAR alt )*
+        alt : item+
+        item : LSQB rhs RSQB | atom ( STAR | PLUS )?
+        atom : LPAR rhs RPAR | NAME | STRING
+
+    With respect to PyPgen, an additional rule 'newtok' has been added
+    to allow for user-defined tokens.
+
+    This class is adapted from module basil.parsing.PgenParser, it has
+    attributes MSTART, ..., provinding to the symbol numbers for the
+    corresponding rules.
+    """
+    MSTART = 256
+    RULE = 257
+    RHS = 258
+    ALT = 259
+    ITEM = 260
+    ATOM = 261
+    NEWTOK = 262
+    def __init__ (self) :
+        self.lexer = Tokenizer(NEWTOK='$')
+    def expect (self, expected, found) :
+        if expected != found.kind :
+            raise ParseError(found, expected=expected)
+    @classmethod
+    def parse (cls, filename) :
+        """Parse a pgen file.
+
+        Expected argument is:
+         - filename: path of pgen file to be parsed
+
+        Return a 2-tuple (G, T) where:
+         - G is the grammar's syntax tree
+         - T is a Tokenizer instance to be used with the parser
+           generated from this grammar (ie, including all the required
+           user-defined tokens)
+
+        This is basically the only method that is needed:
+
+        >>> mygrammar = PgenParser.parse('myfile.pgen')
+        """
+        return cls().parse_file(filename)
+    def parse_file (self, filename) :
+        """Parse a pgen file.
+
+        Expected argument is:
+         - filename: path of pgen file to be parsed
+
+        Return a 2-tuple (g, t):
+         - g: is the grammar's syntax tree
+         - t: is a Tokenizer instance to be used with the parser
+           generated from this grammar (ie, including all the required
+           user-defined tokens)
+
+        Recognize mstart : ( rule | NEWLINE )* ENDMARKER
+
+        Like in PyPgen, the parser is recursive descendent, each rule
+        'X' being recognized by a dedicated method 'handleX' (except
+        for 'mstart'). Each such method expects a current token (or
+        None if it has to be fetched from the tokenizer) and returns a
+        2-tuple (R, T) where:
+         - R is the resulting syntax tree
+         - T is the new current token (or None)
+        """
+        self.infile = open(filename)
+        self.tokens = self.lexer.tokenize(self.infile)
+        extra = {}
+        children = []
+        current = next(self.tokens)
+        while current.kind != self.lexer.ENDMARKER :
+            if current.kind == self.lexer.NEWLINE :
+                children.append((current, []))
+                current = None
+            elif current.kind == self.lexer.NEWTOK :
+                name, text = self.handleNewtok(current)
+                current = None
+                extra[name] = text
+            else :
+                ruleResult, current = self.handleRule(current)
+                children.append(ruleResult)
+            if current is None :
+                current = next(self.tokens)
+        children.append((current, []))
+        return (self.MSTART, children), Tokenizer(**extra)
+    def handleNewtok (self, current=None) :
+        """Recognize newtok : '$' NAME STRING NEWLINE
+
+        Unlike the other 'handleX' methods, this one does not return a
+        syntax tree because it implements a parsing directive.
+        Instead, it returns a 2-tuple (N, S) where:
+         - N is the user-defined token name
+         - S is the token string value
+        """
+        if current is None :
+            current = next(self.tokens)
+        self.expect(self.lexer.NEWTOK, current)
+        name = next(self.tokens)
+        self.expect(self.lexer.NAME, name)
+        text = next(self.tokens)
+        self.expect(self.lexer.STRING, text)
+        nl = next(self.tokens)
+        self.expect(self.lexer.NEWLINE, nl)
+        return name, compile(text, "<string>", "eval",
+                             ast.PyCF_ONLY_AST).body.s
+    def handleRule (self, current=None) :
+        """Recognize rule : NAME COLON rhs NEWLINE
+        """
+        children = []
+        if current is None :
+            current = next(self.tokens)
+        self.expect(self.lexer.NAME, current)
+        children.append((current, []))
+        current = next(self.tokens)
+        self.expect(self.lexer.COLON, current)
+        children.append((current, []))
+        rhsResult, current = self.handleRhs()
+        children.append(rhsResult)
+        if current is None :
+            current = next(self.tokens)
+        self.expect(self.lexer.NEWLINE, current)
+        children.append((current, []))
+        result = (self.RULE, children)
+        return result, None
+    def handleRhs (self, current=None) :
+        """Recognize rhs : alt ( VBAR alt )*
+        """
+        children = []
+        altResult, current = self.handleAlt(current)
+        children.append(altResult)
+        if current is None :
+            current = next(self.tokens)
+        while current.kind == self.lexer.VBAR :
+            children.append((current, []))
+            altResult, current = self.handleAlt()
+            children.append(altResult)
+            if current is None :
+                current = next(self.tokens)
+        result = (self.RHS, children)
+        return result, current
+    def handleAlt (self, current=None) :
+        """ Recognize alt : item+
+        """
+        children = []
+        itemResult, current = self.handleItem(current)
+        children.append(itemResult)
+        if current is None :
+            current = next(self.tokens)
+        while current.kind in (self.lexer.LSQB, self.lexer.LPAR,
+                               self.lexer.NAME, self.lexer.STRING) :
+            itemResult, current = self.handleItem(current)
+            children.append(itemResult)
+            if current is None :
+                current = next(self.tokens)
+        return (self.ALT, children), current
+    def handleItem (self, current=None) :
+        """Recognize item : LSQB rhs RSQB | atom ( STAR | PLUS )?
+        """
+        children = []
+        if current is None :
+            current = next(self.tokens)
+        if current.kind == self.lexer.LSQB :
+            children.append((current, []))
+            rhsResult, current = self.handleRhs()
+            children.append(rhsResult)
+            if current is None :
+                current = next(self.tokens)
+            self.expect(self.lexer.RSQB, current)
+            children.append((current, []))
+            current = None
+        else :
+            atomResult, current = self.handleAtom(current)
+            children.append(atomResult)
+            if current is None :
+                current = next(self.tokens)
+            if current.kind in (self.lexer.STAR, self.lexer.PLUS) :
+                children.append((current, []))
+                current = None
+        return (self.ITEM, children), current
+    def handleAtom (self, current=None) :
+        """Recognize atom : LPAR rhs RPAR | NAME | STRING
+        """
+        children = []
+        if current is None :
+            current = next(self.tokens)
+        tokType = current.kind
+        if tokType == self.lexer.LPAR :
+            children.append((current, []))
+            rhsResult, current = self.handleRhs()
+            children.append(rhsResult)
+            if current is None :
+                current = next(self.tokens)
+            self.expect(self.lexer.RPAR, current)
+            children.append((current, []))
+        elif tokType == self.lexer.STRING :
+            children.append((current, []))
+        else :
+            self.expect(self.lexer.NAME, current)
+            children.append((current, []))
+        return (self.ATOM, children), None
+
+class Parser (object) :
+    """A LL1 parser for a generated grammar.
+
+    This class aggregates two elements from PyPgen:
+     - module basil.lang.python.DFAParser
+     - class basil.parsing.PyPgen.PyPgenParser
+
+    The main differences are:
+     - simplified interface
+     - adapt to handle Token instances instead of 3-tuples (kind,
+       text, lineno)
+     - remove functions arguments that can now be retreived as
+       instance attributes
+     - use Python warnings instead of print statements
+     - many minor code edits (for my own understanding)
+
+    Docstrings are provided only for methods that did not have an
+    equivalent in PyPgen or that have been changed in a significant
+    way.
+    """
+    def __init__ (self, grammar, tokenizer) :
+        """Initialize a new instance.
+
+        Expected arguments are:
+         - grammar: the gramar object as returned by PyPgen.grammar()
+         - tokenizer: a Tokenizer instance suitable for this grammar
+           (eg, that passed to PyPgen's constructor)
+        """
+        self.grammar = grammar
+        self.start = grammar[2]
+        self.stringMap = {}
+        for dfa in self.grammar[0] :
+            dfaType, dfaName = dfa[:2]
+            self.stringMap[dfaName] = dfaType
+        self.symbolMap = {}
+        for dfa in self.grammar[0] :
+            dfaType, dfaName = dfa[:2]
+            self.symbolMap[dfaType] = dfaName
+        self.tokenizer = tokenizer
+        self.addAccelerators()
+    def parseTokens (self, tokens, start=None) :
+        """Parse a series of tokens.
+
+        Expected arguments:
+         - tokens: a generator of Token instances
+         - start: the start symbol to be recognized (or None to use
+           the default one)
+
+        The token generator should provide only tokens that are
+        compatible with the tokenizer passed to the Parser's
+        constructor. Otherwise, ParseError will be raised as unknown
+        tokens will be issued.
+        """
+        self.tokens = tokens
+        return self._parse(start)
+    def parseFile (self, filename, start=None) :
+        """Parse a text file provided by its path.
+
+        Expected arguments:
+         - filename: a file name
+         - start: the start symbol to be recognized (or None to use
+           the default one)
+
+        The start symbol may be provided by its number (int) or its
+        name (str) as specified in the grammar.
+        """
+        self.tokens = self.tokenizer.tokenize(open(filename))
+        return self._parse(start)
+    def parseStream (self, stream, start=None) :
+        """Parse text from an opened file.
+
+        Expected arguments:
+         - stream: a file-like object (with a method readline)
+         - start: the start symbol to be recognized (or None to use
+           the default one)
+
+        The start symbol may be provided by its number (int) or its
+        name (str) as specified in the grammar.
+        """
+        self.tokens = self.tokenizer.tokenize(stream)
+        return self._parse(start)
+    def parseString (self, text, start=None, filename="<string>") :
+        """Parse text given as a string.
+
+        Expected arguments:
+         - text: a string-like object
+         - start: the start symbol to be recognized (or None to use
+           the default one)
+
+        The start symbol may be provided by its number (int) or its
+        name (str) as specified in the grammar.
+        """
+        data = io.StringIO(text)
+        data.name = filename
+        self.tokens = self.tokenizer.tokenize(data)
+        return self._parse(start)
+    def _parse (self, start=None) :
+        """Main parsing method.
+
+        Expected argument:
+         - start: the start symbol to be recognized (or None to use
+           the default one)
+
+        The start symbol may be provided by its number (int) or its
+        name (str) as specified in the grammar.
+        """
+        if start is None :
+            start = self.start
+        elif start in self.stringMap :
+            start = self.stringMap[start]
+        elif start not in self.symbolMap :
+            raise ValueError("unknown start symbol %r" % start)
+        tokens = self.tokens
+        # initialize the parsing stack
+        rootNode = ((start, None, 0), [])
+        dfa = self.findDFA(start)
+        self.stack = [(dfa[3][dfa[2]], dfa, rootNode)]
+        # parse all of it
+        result = self._LL1_OK
+        while result == self._LL1_OK :
+            result, expected = self.addToken(next(tokens))
+        if result == self._LL1_DONE :
+            return self._fix_locations(rootNode)
+        elif result == self._LL1_SYNTAX :
+            raise ParseError(self.tokenizer.last, expected=expected)
+    def _tostrings (self, st) :
+        """Substitute symbol numbers by strings in a syntax tree.
+
+        Expected argument:
+         - st: a syntax tree as returned by the parser
+        """
+        (kind, token, lineno), children = st
+        if kind >= self.tokenizer.NT_OFFSET :
+            name = self.symbolMap
+        else :
+            name = self.tokenizer.tok_name
+        return ((name[kind], token, lineno),
+                [self._tostrings(c) for c in children])
+    def _fix_locations (self, st) :
+        """Replaces None in non-terminal nodes by a Location instance.
+
+        Expected argument:
+         - st: a syntax tree as returned by the parser
+        """
+        (kind, token, lineno), children = st
+        children = [self._fix_locations(c) for c in children]
+        if kind >= self.tokenizer.NT_OFFSET :
+            token = Location(children[0][0][1], children[-1][0][1])
+        return ((kind, token, lineno), children)
+    def pprint (self, st) :
+        """Return a human-readable representation of a syntax tree.
+
+        Expected argument:
+         - st: a syntax tree as returned by the parser
+
+        All symbol numbers are substituted by the corresponding names
+        and the text is indented appropriately.
+        """
+        return pprint.pformat(self._tostrings(st))
+    # the rest of the class has not changed too much
+    def addAccelerators (self) :
+        if self.grammar[-1] : # already has accelerators
+            return
+        dfas, labels, start, accel = self.grammar
+        def handleState (state) :
+            arcs, accel, accept = state
+            accept = 0
+            labelCount = len(labels)
+            accelArray = [-1] * labelCount
+            for arc in arcs :
+                labelIndex, arrow = arc
+                kind = labels[labelIndex][0]
+                if arrow >= 128 :
+                    warn("too many states (%d >= 128)!" % arrow)
+                    continue
+                if kind >= self.tokenizer.NT_OFFSET :
+                    targetFirstSet = self.findDFA(kind)[4]
+                    if kind - self.tokenizer.NT_OFFSET >= 128 :
+                        warn("nonterminal too high (%d >= %d)!" %
+                             (kind, 128 + self.tokenizer.NT_OFFSET))
+                        continue
+                    for ibit in range(labelCount) :
+                        if self.testbit(targetFirstSet, ibit) :
+                            accelVal = (arrow | 128 |
+                                        ((kind - self.tokenizer.NT_OFFSET) << 8))
+                            oldVal = accelArray[ibit]
+                            if oldVal != -1 :
+                                # XXX Make this error reporting more better.
+                                oldType = oldVal >> 8
+                                # FIXME: bug in the original source
+                                #warn("ambiguity at bit %d (for %d: was to %x,"
+                                #     " now to %x)."
+                                #     % (ibit, states.index(state),
+                                #        oldVal, accelVal))
+                                warn("ambiguity at bit %d" % ibit)
+                            accelArray[ibit] = (arrow | 128 |
+                                                ((kind - self.tokenizer.NT_OFFSET) << 8))
+                elif labelIndex == 0 :
+                    accept = 1
+                elif labelIndex >= 0 and labelIndex < labelCount :
+                    accelArray[labelIndex] = arrow
+            # Now compute the upper and lower bounds.
+            accelUpper = labelCount
+            while accelUpper > 0 and accelArray[accelUpper-1] == -1 :
+                accelUpper -= 1
+            accelLower = 0
+            while accelLower < accelUpper and accelArray[accelLower] == -1 :
+                accelLower += 1
+            accelArray = accelArray[accelLower:accelUpper]
+            return (arcs, (accelUpper, accelLower, accelArray), accept)
+        def handleDFA (dfa) :
+            kind, name, initial, states, first = dfa
+            return (kind, name, initial, list(map(handleState, states)))
+        self.grammar = (list(map(handleDFA, dfas)), labels, start, 1)
+    _LL1_OK = 0   # replaced E_ prefix with _LL1_ to prevent potential
+    _LL1_DONE = 1 # conflicts with grammar symbols
+    _LL1_SYNTAX = 2
+    def testbit (self, bitstr, ibit) :
+        return (ord(bitstr[ibit >> 3]) & (1 << (ibit & 0x7))) != 0
+    def classify (self, token) :
+        labels = self.grammar[1]
+        if token.kind == self.tokenizer.NAME :
+            for i, label in enumerate(labels) :
+                if (token.kind, token) == label :
+                    return i
+        for i, label in enumerate(labels) :
+            if (token.kind == label[0]) and (label[1] is None) :
+                return i
+        return -1
+    def findDFA (self, start) :
+        return self.grammar[0][start - self.tokenizer.NT_OFFSET]
+    def addToken (self, token) :
+        stack = self.stack
+        ilabel = self.classify(token)
+        while True :
+            state, dfa, parent = stack[-1]
+            # Perform accelerator
+            arcs, (accelUpper, accelLower, accelTable), accept = state
+            if accelLower <= ilabel < accelUpper :
+                accelResult = accelTable[ilabel - accelLower]
+                if accelResult != -1 :
+                    # Handle accelerator result
+                    if accelResult & 128 :
+                        # Push non-terminal
+                        nt = (accelResult >> 8) + self.tokenizer.NT_OFFSET
+                        arrow = accelResult & 127
+                        nextDFA = self.findDFA(nt)
+                        # INLINE PUSH
+                        newAstNode = ((nt, None, token.srow), [])
+                        parent[1].append(newAstNode)
+                        stack[-1] = (dfa[3][arrow], dfa, parent)
+                        stack.append((nextDFA[3][nextDFA[2]], nextDFA,
+                                      newAstNode))
+                        continue
+                    # INLINE SHIFT
+                    parent[1].append(((token.kind, token, token.srow), []))
+                    nextState = dfa[3][accelResult]
+                    stack[-1] = (nextState, dfa, parent)
+                    state = nextState
+                    while state[2] and len(state[0]) == 1 :
+                        # INLINE POP
+                        stack.pop(-1)
+                        if not stack :
+                            return self._LL1_DONE, None
+                        else :
+                            state, dfa, parent = stack[-1]
+                    return self._LL1_OK, None
+            if accept :
+                stack.pop(-1)
+                if not stack :
+                    return self._LL1_SYNTAX, self.tokenizer.ENDMARKER
+                continue
+            if ((accelUpper < accelLower) and
+                (self.grammar[1][accelLower][1] is not None)) :
+                expected = self.grammar[1][accelLower][1]
+            else :
+                expected = None
+            return self._LL1_SYNTAX, expected
+
+class PyPgen (object) :
+    """A grammar generator.
+
+    This class aggregates two elements from PyPgen:
+     - class basil.parsing.PyPgen.PyPgen
+     - function basil.parsing.PyPgen.buildParser
+     - parts of function basil.parsing.PyPgen.parserMain
+
+    The main differences are:
+     - simplified interface
+     - adapt to handle Token instances instead of 3-tuples (kind,
+       text, lineno)
+     - remove functions arguments that can now be retreived as
+       instance attributes
+     - use Python warnings instead of print statements
+     - many minor code edits (for my own understanding)
+
+    Docstrings are provided only for methods that did not have an
+    equivalent in PyPgen or that have been changed in a significant
+    way.
+    """
+    def __init__ (self, gst, tokenizer) :
+        """Initialize a new instance.
+
+        Expected arguments are:
+         - gst: the grammar's syntax tree as returned by
+           PgenParser.parse()
+         - tokenizer: a Tokenizer instance suitable for this grammar,
+           also returned by PgenParser.parse()
+        """
+        self.tokenizer = tokenizer
+        self.EMPTY = self.tokenizer.ENDMARKER
+        self.gst = gst
+        self.nfaGrammar = self.dfaGrammar = None
+        self.nfa = None
+        self.crntKind = self.tokenizer.NT_OFFSET
+        self.operatorMap = tokenizer.opmap
+    def grammar (self) :
+        """Generate and return the grammar object.
+        """
+        nfaGrammar = self.handleStart(self.gst)
+        grammar = self.generateDfaGrammar(nfaGrammar)
+        self.translateLabels(grammar)
+        self.generateFirstSets(grammar)
+        grammar[0] = list(map(tuple, grammar[0]))
+        # Trick to add accelerators at generation time: it's easier to
+        # do it this way than to extract the required elements from
+        # class Parser.
+        return Parser(tuple(grammar), self.tokenizer).grammar
+    def python (self, pgen="pgen", inline=False) :
+        """Build and return Python code for parsing module.
+
+        Expected arguments are:
+         - pgen: the name of module pgen in the generated source
+           (default to 'pgen')
+         - inline: a bool value to indicate whether to import or
+           inline pgen module in the generated code
+
+        If inline=True, the generated code is much bigger but does not
+        depend on any non-standard module.
+        """
+        pysrc = ("%(pgen)s"
+                 "tokenizer = %(prefix)s%(tokenizer)r\n"
+                 "grammar = %(grammar)s\n"
+                 "parser = %(prefix)sParser(grammar, tokenizer)\n\n"
+                 "if __name__ == '__main__' :\n"
+                 "    # just for test purpose\n"
+                 "    import sys, pprint\n"
+                 "    st = parser.parseStream(sys.stdin)\n"
+                 "    print(parser.pprint(st))\n")
+        format = {"grammar" : pprint.pformat(self.grammar()),
+                  "prefix" : pgen + ".",
+                  "tokenizer" : self.tokenizer,
+                  "pgen" : "import tokenize, %s\n\n" % pgen,
+                  "inline" : "",
+                  }
+        if inline :
+            format["prefix"] = ""
+            source = inspect.getsource(inspect.getmodule(self))
+            source = source.rsplit("if __name__ == '__main__' :", 1)[0]
+            format["pgen"] = ("### module '%s.py' inlined\n"
+                              "%s\n### end of '%s.py'\n\n"
+                              % (pgen, source.rstrip(), pgen))
+        return pysrc % format
+    @classmethod
+    def translate (cls, src, tgt=None, pgen="pgen", inline=False) :
+        """Translate a pgen file to a Python file that implements the
+        corresponding parser.
+
+        Expected arguments are:
+         - src: path of the pgen file
+         - tgt: path of target Python file, if None, its name is
+           derived from src (replacing its extension by .py)
+         - pgen, inline: like in PyPgen.python()
+
+        Warning: the output file is silently overwritten if it already
+        exist.
+        """
+        if tgt is None :
+            tgt = os.path.splitext(src)[0] + ".py"
+        gst, tokenizer = PgenParser.parse(src)
+        self = PyPgen(gst, tokenizer)
+        outfile = open(tgt, "w")
+        outfile.write(("# this file has been automatically generated running:\n"
+                       "# %s\n\n") % " ".join(sys.argv))
+        outfile.write(self.python(pgen, inline))
+        outfile.close()
+    # the rest of the class has not changed too much
+    def addLabel (self, labelList, tokKind, tokName) :
+        labelTup = (tokKind, tokName)
+        if labelTup in labelList :
+            return labelList.index(labelTup)
+        labelIndex = len(labelList)
+        labelList.append(labelTup)
+        return labelIndex
+    def handleStart (self, gst) :
+        self.nfaGrammar = [[],[(self.tokenizer.ENDMARKER, "EMPTY")]]
+        self.crntKind = self.tokenizer.NT_OFFSET
+        kind, children = gst
+        for child in children :
+            if int(child[0]) == PgenParser.RULE :
+                self.handleRule(child)
+        return self.nfaGrammar
+    def handleRule (self, gst) :
+        # NFA := [ type : Int, name : String, [ STATE ], start : Int,
+        #         finish : Int ]
+        # STATE := [ ARC ]
+        # ARC := ( labelIndex : Int, stateIndex : Int )
+        ####
+        # build the NFA shell
+        self.nfa = [self.crntKind, None, [], -1, -1]
+        self.crntKind += 1
+        # work on the AST node
+        kind, children = gst
+        name, colon, rhs, newline = children
+        self.nfa[1] = name[0]
+        if (self.tokenizer.NAME, name[0]) not in self.nfaGrammar[1] :
+            self.nfaGrammar[1].append((self.tokenizer.NAME, name[0]))
+        start, finish = self.handleRhs(rhs)
+        self.nfa[3] = start
+        self.nfa[4] = finish
+        # append the NFA to the grammar
+        self.nfaGrammar[0].append(self.nfa)
+    def handleRhs (self, gst) :
+        kind, children = gst
+        start, finish = self.handleAlt(children[0])
+        if len(children) > 1 :
+            cStart = start
+            cFinish = finish
+            start = len(self.nfa[2])
+            self.nfa[2].append([(self.EMPTY, cStart)])
+            finish = len(self.nfa[2])
+            self.nfa[2].append([])
+            self.nfa[2][cFinish].append((self.EMPTY, finish))
+            for child in children[2:] :
+                if int(child[0]) == PgenParser.ALT :
+                    cStart, cFinish = self.handleAlt(child)
+                    self.nfa[2][start].append((self.EMPTY, cStart))
+                    self.nfa[2][cFinish].append((self.EMPTY, finish))
+        return start, finish
+    def handleAlt (self, gst) :
+        kind, children = gst
+        start, finish = self.handleItem(children[0])
+        if len(children) > 1 :
+            for child in children[1:] :
+                cStart, cFinish = self.handleItem(child)
+                self.nfa[2][finish].append((self.EMPTY, cStart))
+                finish = cFinish
+        return start, finish
+    def handleItem (self, gst) :
+        nodeKind, children = gst
+        if int(children[0][0]) == PgenParser.ATOM :
+            start, finish = self.handleAtom(children[0])
+            if len(children) > 1 :
+                # Short out the child NFA
+                self.nfa[2][finish].append((self.EMPTY, start))
+                if children[1][0].kind == self.tokenizer.STAR :
+                    finish = start
+        else :
+            start = len(self.nfa[2])
+            finish = start + 1
+            self.nfa[2].append([(self.EMPTY, finish)])
+            self.nfa[2].append([])
+            cStart, cFinish = self.handleRhs(children[1])
+            self.nfa[2][start].append((self.EMPTY, cStart))
+            self.nfa[2][cFinish].append((self.EMPTY, finish))
+        return start, finish
+    def handleAtom (self, gst) :
+        nodeKind, children = gst
+        tok = children[0][0]
+        if tok.kind == self.tokenizer.LPAR :
+            start, finish = self.handleRhs(children[1])
+        elif tok.kind in (self.tokenizer.STRING, self.tokenizer.NAME) :
+            start = len(self.nfa[2])
+            finish = start + 1
+            labelIndex = self.addLabel(self.nfaGrammar[1], tok.kind, tok)
+            self.nfa[2].append([(labelIndex, finish)])
+            self.nfa[2].append([])
+        return start, finish
+    def generateDfaGrammar (self, nfaGrammar, start=None) :
+        # See notes in pgen.lang.python.DFAParser for output schema.
+        dfas = []
+        for nfa in nfaGrammar[0] :
+            dfas.append(self.nfaToDfa(nfa))
+        kind = dfas[0][0]
+        if start is not None :
+            found = False
+            for dfa in dfas :
+                if dfa[1] == start :
+                    kind = dfa[0]
+                    found = True
+                    break
+            if not found :
+                warn("couldn't find nonterminal %r, "
+                     "using %r instead." % (start, dfas[0][1]))
+        return [dfas, nfaGrammar[1][:], kind, 0]
+    def addClosure (self, stateList, nfa, istate) :
+        stateList[istate] = True
+        arcs = nfa[2][istate]
+        for label, arrow in arcs :
+            if label == self.EMPTY :
+                self.addClosure(stateList, nfa, arrow)
+    def nfaToDfa (self, nfa) :
+        tempStates = []
+        crntTempState = [[False] * len(nfa[2]), [], False]
+        self.addClosure(crntTempState[0], nfa, nfa[3])
+        crntTempState[2] = crntTempState[0][nfa[4]]
+        if crntTempState[2] :
+            warn("nonterminal %r may produce empty." % nfa[1])
+        tempStates.append(crntTempState)
+        index = 0
+        while index < len(tempStates) :
+            crntTempState = tempStates[index]
+            for componentState in range(len(nfa[2])) :
+                if not crntTempState[0][componentState] :
+                    continue
+                nfaArcs = nfa[2][componentState]
+                for label, nfaArrow in nfaArcs :
+                    if label == self.EMPTY :
+                        continue
+                    foundTempArc = False
+                    for tempArc in crntTempState[1] :
+                        if tempArc[0] == label :
+                            foundTempArc = True
+                            break
+                    if not foundTempArc :
+                        tempArc = [label, -1, [False] * len(nfa[2])]
+                        crntTempState[1].append(tempArc)
+                    self.addClosure(tempArc[2], nfa, nfaArrow)
+            for arcIndex in range(len(crntTempState[1])) :
+                label, arrow, targetStateList = crntTempState[1][arcIndex]
+                targetFound = False
+                arrow = 0
+                for destTempState in tempStates :
+                    if targetStateList == destTempState[0] :
+                        targetFound = True
+                        break
+                    arrow += 1
+                if not targetFound :
+                    assert arrow == len(tempStates)
+                    tempState = [targetStateList[:], [],
+                                 targetStateList[nfa[4]]]
+                    tempStates.append(tempState)
+                # Write arrow value back to the arc
+                crntTempState[1][arcIndex][1] = arrow
+            index += 1
+        tempStates = self.simplifyTempDfa(nfa, tempStates)
+        return self.tempDfaToDfa(nfa, tempStates)
+    def sameState (self, s1, s2) :
+        if len(s1[1]) != len(s2[1]) or s1[2] != s2[2] :
+            return False
+        for arcIndex in range(len(s1[1])) :
+            arc1 = s1[1][arcIndex]
+            arc2 = s2[1][arcIndex]
+            if arc1[:-1] != arc2[:-1] :
+                return False
+        return True
+    def simplifyTempDfa (self, nfa, tempStates) :
+        changes = True
+        deletedStates = []
+        while changes :
+            changes = False
+            for i in range(1, len(tempStates)) :
+                if i in deletedStates :
+                    continue
+                for j in range(i) :
+                    if j in deletedStates :
+                        continue
+                    if self.sameState(tempStates[i], tempStates[j]) :
+                        deletedStates.append(i)
+                        for k in range(len(tempStates)) :
+                            if k in deletedStates :
+                                continue
+                            for arc in tempStates[k][1] :
+                                if arc[1] == i :
+                                    arc[1] = j
+                        changes = True
+                        break
+        for stateIndex in deletedStates :
+            tempStates[stateIndex] = None
+        return tempStates
+    def tempDfaToDfa (self, nfa, tempStates) :
+        dfaStates = []
+        dfa = [nfa[0], nfa[1], 0, dfaStates, None]
+        stateMap = {}
+        tempIndex = 0
+        for tempState in tempStates :
+            if tempState is not None :
+                stateMap[tempIndex] = len(dfaStates)
+                dfaStates.append(([], (0,0,()), 0))
+            tempIndex += 1
+        for tempIndex in stateMap.keys() :
+            stateList, tempArcs, accepting = tempStates[tempIndex]
+            dfaStateIndex = stateMap[tempIndex]
+            dfaState = dfaStates[dfaStateIndex]
+            for tempArc in tempArcs :
+                dfaState[0].append((tempArc[0], stateMap[tempArc[1]]))
+            if accepting :
+                dfaState[0].append((self.EMPTY, dfaStateIndex))
+        return dfa
+    def translateLabels (self, grammar) :
+        tokenNames = list(self.tokenizer.tok_name.values())
+        # Recipe 252143 (remixed for laziness)
+        tokenValues = dict(([v, k] for k, v in
+                            self.tokenizer.tok_name.items()))
+        labelList = grammar[1]
+        for labelIndex, (kind, name) in enumerate(labelList) :
+            if kind == self.tokenizer.NAME :
+                isNonTerminal = False
+                for dfa in grammar[0] :
+                    if dfa[1] == name :
+                        labelList[labelIndex] = (dfa[0], None)
+                        isNonTerminal = True
+                        break
+                if not isNonTerminal :
+                    if name in tokenNames :
+                        labelList[labelIndex] = (tokenValues[name], None)
+                    else :
+                        warn("can't translate NAME label '%s'" % name)
+            elif kind == self.tokenizer.STRING :
+                assert name[0] == name[-1]
+                sname = name[1:-1]
+                if (sname[0] in string.letters) or (sname[0] == "_") :
+                    labelList[labelIndex] = (self.tokenizer.NAME, sname)
+                elif sname in self.operatorMap :
+                    labelList[labelIndex] = (self.operatorMap[sname],
+                                             None)
+                else :
+                    warn("can't translate STRING label %s" % name)
+        return grammar
+    def calcFirstSet (self, grammar, dfa) :
+        if dfa[4] == -1 :
+            warn("left-recursion for %r" % dfa[1])
+            return
+        if dfa[4] != None :
+            warn("re-calculating FIRST set for %r" % dfa[1])
+        dfa[4] = -1
+        symbols = []
+        result = 0
+        state = dfa[3][dfa[2]]
+        for arc in state[0] :
+            sym = arc[0]
+            if sym not in symbols :
+                symbols.append(sym)
+                kind = grammar[1][sym][0]
+                if kind >= self.tokenizer.NT_OFFSET :
+                    # Nonterminal
+                    ddfa = grammar[0][kind - self.tokenizer.NT_OFFSET]
+                    if ddfa[4] == -1 :
+                        warn("left recursion below %r" % dfa[1])
+                    else :
+                        if ddfa[4] == None :
+                            self.calcFirstSet(grammar, ddfa)
+                        result |= ddfa[4]
+                else :
+                    result |= 1 << sym
+        dfa[4] = result
+    def generateFirstSets (self, grammar) :
+        dfas = grammar[0]
+        index = 0
+        while index < len(dfas) :
+            dfa = dfas[index]
+            if None == dfa[4] :
+                self.calcFirstSet(grammar, dfa)
+            index += 1
+        for dfa in dfas :
+            set = dfa[4]
+            result = []
+            while set > 0 :
+                crntBits = set & 0xff
+                result.append(chr(crntBits))
+                set >>= 8
+            properSize = (len(grammar[1]) / 8) + 1
+            if len(result) < properSize :
+                result.append('\x00' * (properSize - len(result)))
+            dfa[4] = "".join(result)
+        return grammar
+
+if __name__ == '__main__' :
+    # a simple CLI
+    import sys, getopt
+    tgt, pgen, inline = None, "snakes.lang.pgen", False
+    try :
+        opts, args = getopt.getopt(sys.argv[1:], "h",
+                                   ["help", "inline", "output=",
+                                    "pgen=", "start="])
+        if ("-h", "") in opts or ("--help", "") in opts :
+            opts = [("-h", "")]
+            args = [None]
+        elif not args :
+            raise getopt.GetoptError("no input file provided"
+                                     " (try -h to get help)")
+        elif len(args) > 1 :
+            raise getopt.GetoptError("more than one input file provided")
+    except getopt.GetoptError :
+        sys.stderr.write("%s: %s\n" % (__file__, sys.exc_info()[1]))
+        sys.exit(1)
+    for (flag, arg) in opts :
+        if flag in ("-h", "--help") :
+            print("""usage: %s [OPTIONS] INFILE
+    Options:
+        -h, --help         print this help and exit
+        --inline           inline 'pgen.py' in the generated file
+        --output=OUTPUT    set output file
+        --pgen=PGEN        name of 'pgen' module in output file""" % __file__)
+            sys.exit(0)
+        elif flag == "--inline" :
+            inline = True
+        elif flag == "--output" :
+            tgt = arg
+        elif flag == "--pgen" :
+            pgen = arg
+    PyPgen.translate(args[0], tgt=tgt, pgen=pgen, inline=inline)

+"""An implementation of the Zephyr Abstract Syntax Definition Language.
+
+See http://asdl.sourceforge.net/ and
+http://www.cs.princeton.edu/~danwang/Papers/dsl97/dsl97-abstract.html.
+
+Only supports top level module decl, not view.  I'm guessing that view
+is intended to support the browser and I'm not interested in the
+browser.
+
+Changes for Python: Add support for module versions
+"""
+
+#__metaclass__ = type
+
+import os, sys
+import traceback
+
+from . import spark
+
+class Token:
+    # spark seems to dispatch in the parser based on a token's
+    # type attribute
+    def __init__(self, type, lineno):
+        self.type = type
+        self.lineno = lineno
+
+    def __str__(self):
+        return self.type
+
+    def __repr__(self):
+        return str(self)
+
+class Id(Token):
+    def __init__(self, value, lineno):
+        self.type = 'Id'
+        self.value = value
+        self.lineno = lineno
+
+    def __str__(self):
+        return self.value
+
+class String(Token):
+    def __init__(self, value, lineno):
+        self.type = 'String'
+        self.value = value
+        self.lineno = lineno
+
+class ASDLSyntaxError:
+
+    def __init__(self, lineno, token=None, msg=None):
+        self.lineno = lineno
+        self.token = token
+        self.msg = msg
+
+    def __str__(self):
+        if self.msg is None:
+            return "Error at '%s', line %d" % (self.token, self.lineno)
+        else:
+            return "%s, line %d" % (self.msg, self.lineno)
+
+class ASDLScanner(spark.GenericScanner, object):
+
+    def tokenize(self, input):
+        self.rv = []
+        self.lineno = 1
+        super(ASDLScanner, self).tokenize(input)
+        return self.rv
+
+    def t_id(self, s):
+        r"[\w\.]+"
+        # XXX doesn't distinguish upper vs. lower, which is
+        # significant for ASDL.
+        self.rv.append(Id(s, self.lineno))
+
+    def t_string(self, s):
+        r'"[^"]*"'
+        self.rv.append(String(s, self.lineno))
+
+    def t_xxx(self, s): # not sure what this production means
+        r"<="
+        self.rv.append(Token(s, self.lineno))
+
+    def t_punctuation(self, s):
+        r"[\{\}\*\=\|\(\)\,\?\:]"
+        self.rv.append(Token(s, self.lineno))
+
+    def t_comment(self, s):
+        r"\-\-[^\n]*"
+        pass
+
+    def t_newline(self, s):
+        r"\n"
+        self.lineno += 1
+
+    def t_whitespace(self, s):
+        r"[ \t]+"
+        pass
+
+    def t_default(self, s):
+        r" . +"
+        raise ValueError("unmatched input: %r" % s)
+
+class ASDLParser(spark.GenericParser, object):
+    def __init__(self):
+        super(ASDLParser, self).__init__("module")
+
+    def typestring(self, tok):
+        return tok.type
+
+    def error(self, tok):
+        raise ASDLSyntaxError(tok.lineno, tok)
+
+    def p_module_0(self, arg):
+        " module ::= Id Id version { } "
+        (module, name, version, _0, _1) = arg
+        if module.value != "module":
+            raise ASDLSyntaxError(module.lineno,
+                                  msg="expected 'module', found %s" % module)
+        return Module(name, None, version)
+
+    def p_module(self, arg):
+        " module ::= Id Id version { definitions } "
+        (module, name, version, _0, definitions, _1) = arg
+        if module.value != "module":
+            raise ASDLSyntaxError(module.lineno,
+                                  msg="expected 'module', found %s" % module)
+        return Module(name, definitions, version)
+
+    def p_version(self, arg):
+        "version ::= Id String"
+        (version, V) = arg
+        if version.value != "version":
+            raise ASDLSyntaxError(version.lineno,
+                                  msg="expected 'version', found %" % version)
+        return V
+
+    def p_definition_0(self, arg):
+        " definitions ::= definition "
+        (definition,) = arg
+        return definition
+
+    def p_definition_1(self, arg):
+        " definitions ::= definition definitions "
+        (definitions, definition) = arg
+        return definitions + definition
+
+    def p_definition(self, arg):
+        " definition ::= Id = type "
+        (id, _, type) = arg
+        return [Type(id, type)]
+
+    def p_type_0(self, arg):
+        " type ::= product "
+        (product,) = arg
+        return product
+
+    def p_type_1(self, arg):
+        " type ::= sum "
+        (sum,) = arg
+        return Sum(sum)
+
+    def p_type_2(self, arg):
+        " type ::= sum Id ( fields ) "
+        (sum, id, _0, attributes, _1) = arg
+        if id.value != "attributes":
+            raise ASDLSyntaxError(id.lineno,
+                                  msg="expected attributes, found %s" % id)
+        if attributes:
+            attributes.reverse()
+        return Sum(sum, attributes)
+
+    def p_product(self, arg):
+        " product ::= ( fields ) "
+        (_0, fields, _1) = arg
+        fields.reverse()
+        return Product(fields)
+
+    def p_sum_0(self, arg):
+        " sum ::= constructor """
+        (constructor,) = arg
+        return [constructor]
+
+    def p_sum_1(self, arg):
+        " sum ::= constructor | sum "
+        (constructor, _, sum) = arg
+        return [constructor] + sum
+
+    def p_sum_2(self, arg):
+        " sum ::= constructor | sum "
+        (constructor, _, sum) = arg
+        return [constructor] + sum
+
+    def p_constructor_0(self, arg):
+        " constructor ::= Id "
+        (id,) = arg
+        return Constructor(id)
+
+    def p_constructor_1(self, arg):
+        " constructor ::= Id ( fields ) "
+        (id, _0, fields, _1) = arg
+        fields.reverse()
+        return Constructor(id, fields)
+
+    def p_fields_0(self, arg):
+        " fields ::= field "
+        (field,) = arg
+        return [field]
+
+    def p_fields_1(self, arg):
+        " fields ::= field , fields "
+        (field, _, fields) = arg
+        return fields + [field]
+
+    def p_field_0(self, arg):
+        " field ::= Id "
+        (type,) = arg
+        return Field(type)
+
+    def p_field_1(self, arg):
+        " field ::= Id Id "
+        (type, name) = arg
+        return Field(type, name)
+
+    def p_field_2(self, arg):
+        " field ::= Id * Id "
+        (type, _, name) = arg
+        return Field(type, name, seq=1)
+
+    def p_field_3(self, arg):
+        " field ::= Id ? Id "
+        (type, _, name) = arg
+        return Field(type, name, opt=1)
+
+    def p_field_4(self, arg):
+        " field ::= Id * "
+        (type, _) = arg
+        return Field(type, seq=1)
+
+    def p_field_5(self, arg):
+        " field ::= Id ? "
+        (type, _) = arg
+        return Field(type, opt=1)
+
+builtin_types = ("identifier", "string", "int", "bool", "object")
+
+# below is a collection of classes to capture the AST of an AST :-)
+# not sure if any of the methods are useful yet, but I'm adding them
+# piecemeal as they seem helpful
+
+class AST:
+    pass # a marker class
+
+class Module(AST):
+    def __init__(self, name, dfns, version):
+        self.name = name
+        self.dfns = dfns
+        self.version = version
+        self.types = {} # maps type name to value (from dfns)
+        for type in dfns:
+            self.types[type.name.value] = type.value
+
+    def __repr__(self):
+        return "Module(%s, %s)" % (self.name, self.dfns)
+
+class Type(AST):
+    def __init__(self, name, value):
+        self.name = name
+        self.value = value
+
+    def __repr__(self):
+        return "Type(%s, %s)" % (self.name, self.value)
+
+class Constructor(AST):
+    def __init__(self, name, fields=None):
+        self.name = name
+        self.fields = fields or []
+
+    def __repr__(self):
+        return "Constructor(%s, %s)" % (self.name, self.fields)
+
+class Field(AST):
+    def __init__(self, type, name=None, seq=0, opt=0):
+        self.type = type
+        self.name = name
+        self.seq = seq
+        self.opt = opt
+
+    def __repr__(self):
+        if self.seq:
+            extra = ", seq=1"
+        elif self.opt:
+            extra = ", opt=1"
+        else:
+            extra = ""
+        if self.name is None:
+            return "Field(%s%s)" % (self.type, extra)
+        else:
+            return "Field(%s, %s%s)" % (self.type, self.name, extra)
+
+class Sum(AST):
+    def __init__(self, types, attributes=None):
+        self.types = types
+        self.attributes = attributes or []
+
+    def __repr__(self):
+        if self.attributes is None:
+            return "Sum(%s)" % self.types
+        else:
+            return "Sum(%s, %s)" % (self.types, self.attributes)
+
+class Product(AST):
+    def __init__(self, fields):
+        self.fields = fields
+
+    def __repr__(self):
+        return "Product(%s)" % self.fields
+
+class VisitorBase(object):
+
+    def __init__(self, skip=0):
+        self.cache = {}
+        self.skip = skip
+
+    def visit(self, object, *args):
+        meth = self._dispatch(object)
+        if meth is None:
+            return
+        try:
+            meth(object, *args)
+        except Exception:
+            err = sys.exc_info()[1]
+            print("Error visiting %r" % object)
+            print(err)
+            traceback.print_exc()
+            # XXX hack
+            if hasattr(self, 'file'):
+                self.file.flush()
+            os._exit(1)
+
+    def _dispatch(self, object):
+        assert isinstance(object, AST), repr(object)
+        klass = object.__class__
+        meth = self.cache.get(klass)
+        if meth is None:
+            methname = "visit" + klass.__name__
+            if self.skip:
+                meth = getattr(self, methname, None)
+            else:
+                meth = getattr(self, methname)
+            self.cache[klass] = meth
+        return meth
+
+class Check(VisitorBase):
+
+    def __init__(self):
+        super(Check, self).__init__(skip=1)
+        self.cons = {}
+        self.errors = 0
+        self.types = {}
+
+    def visitModule(self, mod):
+        for dfn in mod.dfns:
+            self.visit(dfn)
+
+    def visitType(self, type):
+        self.visit(type.value, str(type.name))
+
+    def visitSum(self, sum, name):
+        for t in sum.types:
+            self.visit(t, name)
+
+    def visitConstructor(self, cons, name):
+        key = str(cons.name)
+        conflict = self.cons.get(key)
+        if conflict is None:
+            self.cons[key] = name
+        else:
+            print("Redefinition of constructor %s" % key)
+            print("Defined in %s and %s" % (conflict, name))
+            self.errors += 1
+        for f in cons.fields:
+            self.visit(f, key)
+
+    def visitField(self, field, name):
+        key = str(field.type)
+        l = self.types.setdefault(key, [])
+        l.append(name)
+
+    def visitProduct(self, prod, name):
+        for f in prod.fields:
+            self.visit(f, name)
+
+def check(mod):
+    v = Check()
+    v.visit(mod)
+
+    for t in v.types:
+        if t not in mod.types and not t in builtin_types:
+            v.errors += 1
+            uses = ", ".join(v.types[t])
+            print("Undefined type %s, used in %s" % (t, uses))
+
+    return not v.errors
+
+def parse(file):
+    scanner = ASDLScanner()
+    parser = ASDLParser()
+
+    buf = open(file).read()
+    tokens = scanner.tokenize(buf)
+    try:
+        return parser.parse(tokens)
+    except ASDLSyntaxError:
+        err = sys.exc_info()[1]
+        print(err)
+        lines = buf.split("\n")
+        print(lines[err.lineno - 1]) # lines starts at 0, files at 1
+
+if __name__ == "__main__":
+    import glob
+    import sys
+
+    if len(sys.argv) > 1:
+        files = sys.argv[1:]
+    else:
+        testdir = "tests"
+        files = glob.glob(testdir + "/*.asdl")
+
+    for file in files:
+        print(file)
+        mod = parse(file)
+        print("module %s" % mod.name)
+        print("%s definitions" % len(mod.dfns))
+        if not check(mod):
+            print("Check failed")
+        else:
+            for dfn in mod.dfns:
+                print(dfn.type)

+#  Copyright (c) 1998-2002 John Aycock
+#
+#  Permission is hereby granted, free of charge, to any person obtaining
+#  a copy of this software and associated documentation files (the
+#  "Software"), to deal in the Software without restriction, including
+#  without limitation the rights to use, copy, modify, merge, publish,
+#  distribute, sublicense, and/or sell copies of the Software, and to
+#  permit persons to whom the Software is furnished to do so, subject to
+#  the following conditions:
+#
+#  The above copyright notice and this permission notice shall be
+#  included in all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+#  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+#  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+#  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+#  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+__version__ = 'SPARK-0.7 (pre-alpha-5)'
+
+import re
+import string
+
+def _namelist(instance):
+    namelist, namedict, classlist = [], {}, [instance.__class__]
+    for c in classlist:
+        for b in c.__bases__:
+            classlist.append(b)
+        for name in c.__dict__:
+            if name not in namedict:
+                namelist.append(name)
+                namedict[name] = 1
+    return namelist
+
+class GenericScanner:
+    def __init__(self, flags=0):
+        pattern = self.reflect()
+        self.re = re.compile(pattern, re.VERBOSE|flags)
+
+        self.index2func = {}
+        for name, number in self.re.groupindex.items():
+            self.index2func[number-1] = getattr(self, 't_' + name)
+
+    def makeRE(self, name):
+        doc = getattr(self, name).__doc__
+        rv = '(?P<%s>%s)' % (name[2:], doc)
+        return rv
+
+    def reflect(self):
+        rv = []
+        for name in _namelist(self):
+            if name[:2] == 't_' and name != 't_default':
+                rv.append(self.makeRE(name))
+
+        rv.append(self.makeRE('t_default'))
+        return string.join(rv, '|')
+
+    def error(self, s, pos):
+        print("Lexical error at position %s" % pos)
+        raise SystemExit
+
+    def tokenize(self, s):
+        pos = 0
+        n = len(s)
+        while pos < n:
+            m = self.re.match(s, pos)
+            if m is None:
+                self.error(s, pos)
+
+            groups = m.groups()
+            for i in range(len(groups)):
+                if groups[i] and i in self.index2func:
+                    self.index2func[i](groups[i])
+            pos = m.end()
+
+    def t_default(self, s):
+        r'( . | \n )+'
+        print("Specification error: unmatched input")
+        raise SystemExit
+
+#
+#  Extracted from GenericParser and made global so that [un]picking works.
+#
+class _State:
+    def __init__(self, stateno, items):
+        self.T, self.complete, self.items = [], [], items
+        self.stateno = stateno
+
+class GenericParser:
+    #
+    #  An Earley parser, as per J. Earley, "An Efficient Context-Free
+    #  Parsing Algorithm", CACM 13(2), pp. 94-102.  Also J. C. Earley,
+    #  "An Efficient Context-Free Parsing Algorithm", Ph.D. thesis,
+    #  Carnegie-Mellon University, August 1968.  New formulation of
+    #  the parser according to J. Aycock, "Practical Earley Parsing
+    #  and the SPARK Toolkit", Ph.D. thesis, University of Victoria,
+    #  2001, and J. Aycock and R. N. Horspool, "Practical Earley
+    #  Parsing", unpublished paper, 2001.
+    #
+
+    def __init__(self, start):
+        self.rules = {}
+        self.rule2func = {}
+        self.rule2name = {}
+        self.collectRules()
+        self.augment(start)
+        self.ruleschanged = 1
+
+    _NULLABLE = '\e_'
+    _START = 'START'
+    _BOF = '|-'
+
+    #
+    #  When pickling, take the time to generate the full state machine;
+    #  some information is then extraneous, too.  Unfortunately we
+    #  can't save the rule2func map.
+    #
+    def __getstate__(self):
+        if self.ruleschanged:
+            #
+            #  XXX - duplicated from parse()
+            #
+            self.computeNull()
+            self.newrules = {}
+            self.new2old = {}
+            self.makeNewRules()
+            self.ruleschanged = 0
+            self.edges, self.cores = {}, {}
+            self.states = { 0: self.makeState0() }
+            self.makeState(0, self._BOF)
+        #
+        #  XXX - should find a better way to do this..
+        #
+        changes = 1
+        while changes:
+            changes = 0
+            for k, v in self.edges.items():
+                if v is None:
+                    state, sym = k
+                    if state in self.states:
+                        self.goto(state, sym)
+                        changes = 1
+        rv = self.__dict__.copy()
+        for s in self.states.values():
+            del s.items
+        del rv['rule2func']
+        del rv['nullable']
+        del rv['cores']
+        return rv
+
+    def __setstate__(self, D):
+        self.rules = {}
+        self.rule2func = {}
+        self.rule2name = {}
+        self.collectRules()
+        start = D['rules'][self._START][0][1][1]        # Blech.
+        self.augment(start)
+        D['rule2func'] = self.rule2func
+        D['makeSet'] = self.makeSet_fast
+        self.__dict__ = D
+
+    #
+    #  A hook for GenericASTBuilder and GenericASTMatcher.  Mess
+    #  thee not with this; nor shall thee toucheth the _preprocess
+    #  argument to addRule.
+    #
+    def preprocess(self, rule, func):       return rule, func
+
+    def addRule(self, doc, func, _preprocess=1):
+        fn = func
+        rules = string.split(doc)
+
+        index = []
+        for i in range(len(rules)):
+            if rules[i] == '::=':
+                index.append(i-1)
+        index.append(len(rules))
+
+        for i in range(len(index)-1):
+            lhs = rules[index[i]]
+            rhs = rules[index[i]+2:index[i+1]]
+            rule = (lhs, tuple(rhs))
+
+            if _preprocess:
+                rule, fn = self.preprocess(rule, func)
+
+            if lhs in self.rules:
+                self.rules[lhs].append(rule)
+            else:
+                self.rules[lhs] = [ rule ]
+            self.rule2func[rule] = fn
+            self.rule2name[rule] = func.__name__[2:]
+        self.ruleschanged = 1
+
+    def collectRules(self):
+        for name in _namelist(self):
+            if name[:2] == 'p_':
+                func = getattr(self, name)
+                doc = func.__doc__
+                self.addRule(doc, func)
+
+    def augment(self, start):
+        rule = '%s ::= %s %s' % (self._START, self._BOF, start)
+        self.addRule(rule, lambda args: args[1], 0)
+
+    def computeNull(self):
+        self.nullable = {}
+        tbd = []
+
+        for rulelist in self.rules.values():
+            lhs = rulelist[0][0]
+            self.nullable[lhs] = 0
+            for rule in rulelist:
+                rhs = rule[1]
+                if len(rhs) == 0:
+                    self.nullable[lhs] = 1
+                    continue
+                #
+                #  We only need to consider rules which
+                #  consist entirely of nonterminal symbols.
+                #  This should be a savings on typical
+                #  grammars.
+                #
+                for sym in rhs:
+                    if sym not in self.rules:
+                        break
+                else:
+                    tbd.append(rule)
+        changes = 1
+        while changes:
+            changes = 0
+            for lhs, rhs in tbd:
+                if self.nullable[lhs]:
+                    continue
+                for sym in rhs:
+                    if not self.nullable[sym]:
+                        break
+                else:
+                    self.nullable[lhs] = 1
+                    changes = 1
+
+    def makeState0(self):
+        s0 = _State(0, [])
+        for rule in self.newrules[self._START]:
+            s0.items.append((rule, 0))
+        return s0
+
+    def finalState(self, tokens):
+        #
+        #  Yuck.
+        #
+        if len(self.newrules[self._START]) == 2 and len(tokens) == 0:
+            return 1
+        start = self.rules[self._START][0][1][1]
+        return self.goto(1, start)
+
+    def makeNewRules(self):
+        worklist = []
+        for rulelist in self.rules.values():
+            for rule in rulelist:
+                worklist.append((rule, 0, 1, rule))
+
+        for rule, i, candidate, oldrule in worklist:
+            lhs, rhs = rule
+            n = len(rhs)
+            while i < n:
+                sym = rhs[i]
+                if sym not in self.rules or \
+                   not self.nullable[sym]:
+                    candidate = 0
+                    i = i + 1
+                    continue
+
+                newrhs = list(rhs)
+                newrhs[i] = self._NULLABLE+sym
+                newrule = (lhs, tuple(newrhs))
+                worklist.append((newrule, i+1,
+                                 candidate, oldrule))
+                candidate = 0
+                i = i + 1
+            else:
+                if candidate:
+                    lhs = self._NULLABLE+lhs
+                    rule = (lhs, rhs)
+                if lhs in self.newrules:
+                    self.newrules[lhs].append(rule)
+                else:
+                    self.newrules[lhs] = [ rule ]
+                self.new2old[rule] = oldrule
+
+    def typestring(self, token):
+        return None
+
+    def error(self, token):
+        print("Syntax error at or near `%s' token" % token)
+        raise SystemExit
+
+    def parse(self, tokens):
+        sets = [ [(1,0), (2,0)] ]
+        self.links = {}
+
+        if self.ruleschanged:
+            self.computeNull()
+            self.newrules = {}
+            self.new2old = {}
+            self.makeNewRules()
+            self.ruleschanged = 0
+            self.edges, self.cores = {}, {}
+            self.states = { 0: self.makeState0() }
+            self.makeState(0, self._BOF)
+
+        for i in range(len(tokens)):
+            sets.append([])
+
+            if sets[i] == []:
+                break
+            self.makeSet(tokens[i], sets, i)
+        else:
+            sets.append([])
+            self.makeSet(None, sets, len(tokens))
+
+        #_dump(tokens, sets, self.states)
+
+        finalitem = (self.finalState(tokens), 0)
+        if finalitem not in sets[-2]:
+            if len(tokens) > 0:
+                self.error(tokens[i-1])
+            else:
+                self.error(None)
+
+        return self.buildTree(self._START, finalitem,
+                              tokens, len(sets)-2)
+
+    def isnullable(self, sym):
+        #
+        #  For symbols in G_e only.  If we weren't supporting 1.5,
+        #  could just use sym.startswith().
+        #
+        return self._NULLABLE == sym[0:len(self._NULLABLE)]
+
+    def skip(self, lrhs, pos=0):
+        (lhs, rhs) = lrhs
+        n = len(rhs)
+        while pos < n:
+            if not self.isnullable(rhs[pos]):
+                break
+            pos = pos + 1
+        return pos
+
+    def makeState(self, state, sym):
+        assert sym is not None
+        #
+        #  Compute \epsilon-kernel state's core and see if
+        #  it exists already.
+        #
+        kitems = []
+        for rule, pos in self.states[state].items:
+            lhs, rhs = rule
+            if rhs[pos:pos+1] == (sym,):
+                kitems.append((rule, self.skip(rule, pos+1)))
+        core = kitems
+
+        core.sort()
+        tcore = tuple(core)
+        if tcore in self.cores:
+            return self.cores[tcore]
+        #
+        #  Nope, doesn't exist.  Compute it and the associated
+        #  \epsilon-nonkernel state together; we'll need it right away.
+        #
+        k = self.cores[tcore] = len(self.states)
+        K, NK = _State(k, kitems), _State(k+1, [])
+        self.states[k] = K
+        predicted = {}
+
+        edges = self.edges
+        rules = self.newrules
+        for X in K, NK:
+            worklist = X.items
+            for item in worklist:
+                rule, pos = item
+                lhs, rhs = rule
+                if pos == len(rhs):
+                    X.complete.append(rule)
+                    continue
+
+                nextSym = rhs[pos]
+                key = (X.stateno, nextSym)
+                if nextSym not in rules:
+                    if key not in edges:
+                        edges[key] = None
+                        X.T.append(nextSym)
+                else:
+                    edges[key] = None
+                    if nextSym not in predicted:
+                        predicted[nextSym] = 1
+                        for prule in rules[nextSym]:
+                            ppos = self.skip(prule)
+                            new = (prule, ppos)
+                            NK.items.append(new)
+            #
+            #  Problem: we know K needs generating, but we
+            #  don't yet know about NK.  Can't commit anything
+            #  regarding NK to self.edges until we're sure.  Should
+            #  we delay committing on both K and NK to avoid this
+            #  hacky code?  This creates other problems..
+            #
+            if X is K:
+                edges = {}
+
+        if NK.items == []:
+            return k
+
+        #
+        #  Check for \epsilon-nonkernel's core.  Unfortunately we
+        #  need to know the entire set of predicted nonterminals
+        #  to do this without accidentally duplicating states.
+        #
+        core = list(predicted.keys())
+        core.sort()
+        tcore = tuple(core)
+        if tcore in self.cores:
+            self.edges[(k, None)] = self.cores[tcore]
+            return k
+
+        nk = self.cores[tcore] = self.edges[(k, None)] = NK.stateno
+        self.edges.update(edges)
+        self.states[nk] = NK
+        return k
+
+    def goto(self, state, sym):
+        key = (state, sym)
+        if key not in self.edges:
+            #
+            #  No transitions from state on sym.
+            #
+            return None
+
+        rv = self.edges[key]
+        if rv is None:
+            #
+            #  Target state isn't generated yet.  Remedy this.
+            #
+            rv = self.makeState(state, sym)
+            self.edges[key] = rv
+        return rv
+
+    def gotoT(self, state, t):
+        return [self.goto(state, t)]
+
+    def gotoST(self, state, st):
+        rv = []
+        for t in self.states[state].T:
+            if st == t:
+                rv.append(self.goto(state, t))
+        return rv
+
+    def add(self, set, item, i=None, predecessor=None, causal=None):
+        if predecessor is None:
+            if item not in set:
+                set.append(item)
+        else:
+            key = (item, i)
+            if item not in set:
+                self.links[key] = []
+                set.append(item)
+            self.links[key].append((predecessor, causal))
+
+    def makeSet(self, token, sets, i):
+        cur, next = sets[i], sets[i+1]
+
+        ttype = token is not None and self.typestring(token) or None
+        if ttype is not None:
+            fn, arg = self.gotoT, ttype
+        else:
+            fn, arg = self.gotoST, token
+
+        for item in cur:
+            ptr = (item, i)
+            state, parent = item
+            add = fn(state, arg)
+            for k in add:
+                if k is not None:
+                    self.add(next, (k, parent), i+1, ptr)
+                    nk = self.goto(k, None)
+                    if nk is not None:
+                        self.add(next, (nk, i+1))
+
+            if parent == i:
+                continue
+
+            for rule in self.states[state].complete:
+                lhs, rhs = rule
+                for pitem in sets[parent]:
+                    pstate, pparent = pitem
+                    k = self.goto(pstate, lhs)
+                    if k is not None:
+                        why = (item, i, rule)
+                        pptr = (pitem, parent)
+                        self.add(cur, (k, pparent),
+                                 i, pptr, why)
+                        nk = self.goto(k, None)
+                        if nk is not None:
+                            self.add(cur, (nk, i))
+
+    def makeSet_fast(self, token, sets, i):
+        #
+        #  Call *only* when the entire state machine has been built!
+        #  It relies on self.edges being filled in completely, and
+        #  then duplicates and inlines code to boost speed at the
+        #  cost of extreme ugliness.
+        #
+        cur, next = sets[i], sets[i+1]
+        ttype = token is not None and self.typestring(token) or None
+
+        for item in cur:
+            ptr = (item, i)
+            state, parent = item
+            if ttype is not None:
+                k = self.edges.get((state, ttype), None)
+                if k is not None:
+                    #self.add(next, (k, parent), i+1, ptr)
+                    #INLINED --v
+                    new = (k, parent)
+                    key = (new, i+1)
+                    if new not in next:
+                        self.links[key] = []
+                        next.append(new)
+                    self.links[key].append((ptr, None))
+                    #INLINED --^
+                    #nk = self.goto(k, None)
+                    nk = self.edges.get((k, None), None)
+                    if nk is not None:
+                        #self.add(next, (nk, i+1))
+                        #INLINED --v
+                        new = (nk, i+1)
+                        if new not in next:
+                            next.append(new)
+                        #INLINED --^
+            else:
+                add = self.gotoST(state, token)
+                for k in add:
+                    if k is not None:
+                        self.add(next, (k, parent), i+1, ptr)
+                        #nk = self.goto(k, None)
+                        nk = self.edges.get((k, None), None)
+                        if nk is not None:
+                            self.add(next, (nk, i+1))
+
+            if parent == i:
+                continue
+
+            for rule in self.states[state].complete:
+                lhs, rhs = rule
+                for pitem in sets[parent]:
+                    pstate, pparent = pitem
+                    #k = self.goto(pstate, lhs)
+                    k = self.edges.get((pstate, lhs), None)
+                    if k is not None:
+                        why = (item, i, rule)
+                        pptr = (pitem, parent)
+                        #self.add(cur, (k, pparent),
+                        #        i, pptr, why)
+                        #INLINED --v
+                        new = (k, pparent)
+                        key = (new, i)
+                        if new not in cur:
+                            self.links[key] = []
+                            cur.append(new)
+                        self.links[key].append((pptr, why))
+                        #INLINED --^
+                        #nk = self.goto(k, None)
+                        nk = self.edges.get((k, None), None)
+                        if nk is not None:
+                            #self.add(cur, (nk, i))
+                            #INLINED --v
+                            new = (nk, i)
+                            if new not in cur:
+                                cur.append(new)
+                            #INLINED --^
+
+    def predecessor(self, key, causal):
+        for p, c in self.links[key]:
+            if c == causal:
+                return p
+        assert 0
+
+    def causal(self, key):
+        links = self.links[key]
+        if len(links) == 1:
+            return links[0][1]
+        choices = []
+        rule2cause = {}
+        for p, c in links:
+            rule = c[2]
+            choices.append(rule)
+            rule2cause[rule] = c
+        return rule2cause[self.ambiguity(choices)]
+
+    def deriveEpsilon(self, nt):
+        if len(self.newrules[nt]) > 1:
+            rule = self.ambiguity(self.newrules[nt])
+        else:
+            rule = self.newrules[nt][0]
+        #print rule
+
+        rhs = rule[1]
+        attr = [None] * len(rhs)
+
+        for i in range(len(rhs)-1, -1, -1):
+            attr[i] = self.deriveEpsilon(rhs[i])
+        return self.rule2func[self.new2old[rule]](attr)
+
+    def buildTree(self, nt, item, tokens, k):
+        state, parent = item
+
+        choices = []
+        for rule in self.states[state].complete:
+            if rule[0] == nt:
+                choices.append(rule)
+        rule = choices[0]
+        if len(choices) > 1:
+            rule = self.ambiguity(choices)
+        #print rule
+
+        rhs = rule[1]
+        attr = [None] * len(rhs)
+
+        for i in range(len(rhs)-1, -1, -1):
+            sym = rhs[i]
+            if sym not in self.newrules:
+                if sym != self._BOF:
+                    attr[i] = tokens[k-1]
+                    key = (item, k)
+                    item, k = self.predecessor(key, None)
+            #elif self.isnullable(sym):
+            elif self._NULLABLE == sym[0:len(self._NULLABLE)]:
+                attr[i] = self.deriveEpsilon(sym)
+            else:
+                key = (item, k)
+                why = self.causal(key)
+                attr[i] = self.buildTree(sym, why[0],
+                                         tokens, why[1])
+                item, k = self.predecessor(key, why)
+        return self.rule2func[self.new2old[rule]](attr)
+
+    def ambiguity(self, rules):
+        #
+        #  XXX - problem here and in collectRules() if the same rule
+        #        appears in >1 method.  Also undefined results if rules
+        #        causing the ambiguity appear in the same method.
+        #
+        sortlist = []
+        name2index = {}
+        for i in range(len(rules)):
+            lhs, rhs = rule = rules[i]
+            name = self.rule2name[self.new2old[rule]]
+            sortlist.append((len(rhs), name))
+            name2index[name] = i
+        sortlist.sort()
+        list = [a_b[1] for a_b in sortlist]
+        return rules[name2index[self.resolve(list)]]
+
+    def resolve(self, list):
+        #
+        #  Resolve ambiguity in favor of the shortest RHS.
+        #  Since we walk the tree from the top down, this
+        #  should effectively resolve in favor of a "shift".
+        #
+        return list[0]
+
+#
+#  GenericASTBuilder automagically constructs a concrete/abstract syntax tree
+#  for a given input.  The extra argument is a class (not an instance!)
+#  which supports the "__setslice__" and "__len__" methods.
+#
+#  XXX - silently overrides any user code in methods.
+#
+
+class GenericASTBuilder(GenericParser):
+    def __init__(self, AST, start):
+        GenericParser.__init__(self, start)
+        self.AST = AST
+
+    def preprocess(self, rule, func):
+        rebind = lambda lhs, self=self: \
+                        lambda args, lhs=lhs, self=self: \
+                                self.buildASTNode(args, lhs)
+        lhs, rhs = rule
+        return rule, rebind(lhs)
+
+    def buildASTNode(self, args, lhs):
+        children = []
+        for arg in args:
+            if isinstance(arg, self.AST):
+                children.append(arg)
+            else:
+                children.append(self.terminal(arg))
+        return self.nonterminal(lhs, children)
+
+    def terminal(self, token):      return token
+
+    def nonterminal(self, type, args):
+        rv = self.AST(type)
+        rv[:len(args)] = args
+        return rv
+
+#
+#  GenericASTTraversal is a Visitor pattern according to Design Patterns.  For
+#  each node it attempts to invoke the method n_<node type>, falling
+#  back onto the default() method if the n_* can't be found.  The preorder
+#  traversal also looks for an exit hook named n_<node type>_exit (no default
+#  routine is called if it's not found).  To prematurely halt traversal
+#  of a subtree, call the prune() method -- this only makes sense for a
+#  preorder traversal.  Node type is determined via the typestring() method.
+#
+
+class GenericASTTraversalPruningException:
+    pass
+
+class GenericASTTraversal:
+    def __init__(self, ast):
+        self.ast = ast
+
+    def typestring(self, node):
+        return node.type
+
+    def prune(self):
+        raise GenericASTTraversalPruningException
+
+    def preorder(self, node=None):
+        if node is None:
+            node = self.ast
+
+        try:
+            name = 'n_' + self.typestring(node)
+            if hasattr(self, name):
+                func = getattr(self, name)
+                func(node)
+            else:
+                self.default(node)
+        except GenericASTTraversalPruningException:
+            return
+
+        for kid in node:
+            self.preorder(kid)
+
+        name = name + '_exit'
+        if hasattr(self, name):
+            func = getattr(self, name)
+            func(node)
+
+    def postorder(self, node=None):
+        if node is None:
+            node = self.ast
+
+        for kid in node:
+            self.postorder(kid)
+
+        name = 'n_' + self.typestring(node)
+        if hasattr(self, name):
+            func = getattr(self, name)
+            func(node)
+        else:
+            self.default(node)
+
+
+    def default(self, node):
+        pass
+
+#
+#  GenericASTMatcher.  AST nodes must have "__getitem__" and "__cmp__"
+#  implemented.
+#
+#  XXX - makes assumptions about how GenericParser walks the parse tree.
+#
+
+class GenericASTMatcher(GenericParser):
+    def __init__(self, start, ast):
+        GenericParser.__init__(self, start)
+        self.ast = ast
+
+    def preprocess(self, rule, func):
+        rebind = lambda func, self=self: \
+                        lambda args, func=func, self=self: \
+                                self.foundMatch(args, func)
+        lhs, rhs = rule
+        rhslist = list(rhs)
+        rhslist.reverse()
+
+        return (lhs, tuple(rhslist)), rebind(func)
+
+    def foundMatch(self, args, func):
+        func(args[-1])
+        return args[-1]
+
+    def match_r(self, node):
+        self.input.insert(0, node)
+        children = 0
+
+        for child in node:
+            if children == 0:
+                self.input.insert(0, '(')
+            children = children + 1
+            self.match_r(child)
+
+        if children > 0:
+            self.input.insert(0, ')')
+
+    def match(self, ast=None):
+        if ast is None:
+            ast = self.ast
+        self.input = []
+
+        self.match_r(ast)
+        self.parse(self.input)
+
+    def resolve(self, list):
+        #
+        #  Resolve ambiguity in favor of the longest RHS.
+        #
+        return list[-1]
+
+def _dump(tokens, sets, states):
+    for i in range(len(sets)):
+        print('set %s' % i)
+        for item in sets[i]:
+            print('\t%s' % item)
+            for (lhs, rhs), pos in states[item[0]].items:
+                print('\t\t %s ::= %s . %s'
+                      % (lhs, string.join(rhs[:pos]),string.join(rhs[pos:])))
+        if i < len(tokens):
+            print('\ntoken %s\n' % str(tokens[i]))

+"Usage: unparse.py <path to source file>"
+import sys
+#import _ast
+from snakes.lang import ast as _ast
+try :
+    import io
+except ImportError :
+    import cStringIO as io
+import os
+
+def interleave(inter, f, seq):
+    """Call f on each item in seq, calling inter() in between.
+    """
+    seq = iter(seq)
+    try:
+        f(next(seq))
+    except StopIteration:
+        pass
+    else:
+        for x in seq:
+            inter()
+            f(x)
+
+class Unparser:
+    """Methods in this class recursively traverse an AST and
+    output source code for the abstract syntax; original formatting
+    is disregarged. """
+
+    def __init__(self, tree, file = sys.stdout):
+        """Unparser(tree, file=sys.stdout) -> None.
+         Print the source for tree to file."""
+        self.f = file
+        self._indent = 0
+        self.dispatch(tree)
+        self.f.write("\n")
+        self.f.flush()
+
+    def fill(self, text = ""):
+        "Indent a piece of text, according to the current indentation level"
+        self.f.write("\n"+"    "*self._indent + text)
+
+    def write(self, text):
+        "Append a piece of text to the current line."
+        self.f.write(text)
+
+    def enter(self):
+        "Print ':', and increase the indentation."
+        self.write(":")
+        self._indent += 1
+
+    def leave(self):
+        "Decrease the indentation level."
+        self._indent -= 1
+
+    def dispatch(self, tree):
+        "Dispatcher function, dispatching tree type T to method _T."
+        if isinstance(tree, list):
+            for t in tree:
+                self.dispatch(t)
+            return
+        meth = getattr(self, "_"+tree.__class__.__name__)
+        meth(tree)
+
+
+    ############### Unparsing methods ######################
+    # There should be one method per concrete grammar type #
+    # Constructors should be grouped by sum type. Ideally, #
+    # this would follow the order in the grammar, but      #
+    # currently doesn't.                                   #
+    ########################################################
+
+    def _Module(self, tree):
+        for stmt in tree.body:
+            self.dispatch(stmt)
+
+    # stmt
+    def _Expr(self, tree):
+        self.fill()
+        self.dispatch(tree.value)
+
+    def _Import(self, t):
+        self.fill("import ")
+        interleave(lambda: self.write(", "), self.dispatch, t.names)
+
+    def _ImportFrom(self, t):
+        self.fill("from ")
+        self.write(t.module)
+        self.write(" import ")
+        interleave(lambda: self.write(", "), self.dispatch, t.names)
+        # XXX(jpe) what is level for?
+
+    def _Assign(self, t):
+        self.fill()
+        for target in t.targets:
+            self.dispatch(target)
+            self.write(" = ")
+        self.dispatch(t.value)
+
+    def _AugAssign(self, t):
+        self.fill()
+        self.dispatch(t.target)
+        self.write(" "+self.binop[t.op.__class__.__name__]+"= ")
+        self.dispatch(t.value)
+
+    def _Return(self, t):
+        self.fill("return")
+        if t.value:
+            self.write(" ")
+            self.dispatch(t.value)
+
+    def _Pass(self, t):
+        self.fill("pass")
+
+    def _Break(self, t):
+        self.fill("break")
+
+    def _Continue(self, t):
+        self.fill("continue")
+
+    def _Delete(self, t):
+        self.fill("del ")
+        self.dispatch(t.targets)
+
+    def _Assert(self, t):
+        self.fill("assert ")
+        self.dispatch(t.test)
+        if t.msg:
+            self.write(", ")
+            self.dispatch(t.msg)
+
+    def _Exec(self, t):
+        self.fill("exec ")
+        self.dispatch(t.body)
+        if t.globals:
+            self.write(" in ")
+            self.dispatch(t.globals)
+        if t.locals:
+            self.write(", ")
+            self.dispatch(t.locals)
+
+    def _Print(self, t):
+        self.fill("print ")
+        do_comma = False
+        if t.dest:
+            self.write(">>")
+            self.dispatch(t.dest)
+            do_comma = True
+        for e in t.values:
+            if do_comma:self.write(", ")
+            else:do_comma=True
+            self.dispatch(e)
+        if not t.nl:
+            self.write(",")
+
+    def _Global(self, t):
+        self.fill("global ")
+        interleave(lambda: self.write(", "), self.write, t.names)
+
+    def _Yield(self, t):
+        self.write("(")
+        self.write("yield")
+        if t.value:
+            self.write(" ")
+            self.dispatch(t.value)
+        self.write(")")
+
+    def _Raise(self, t):
+        self.fill('raise ')
+        if t.type:
+            self.dispatch(t.type)
+        if t.inst:
+            self.write(", ")
+            self.dispatch(t.inst)
+        if t.tback:
+            self.write(", ")
+            self.dispatch(t.tback)
+
+    def _TryExcept(self, t):
+        self.fill("try")
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+        for ex in t.handlers:
+            self.dispatch(ex)
+        if t.orelse:
+            self.fill("else")
+            self.enter()
+            self.dispatch(t.orelse)
+            self.leave()
+
+    def _TryFinally(self, t):
+        self.fill("try")
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+        self.fill("finally")
+        self.enter()
+        self.dispatch(t.finalbody)
+        self.leave()
+
+    def _ExceptHandler(self, t):
+        self.fill("except")
+        if t.type:
+            self.write(" ")
+            self.dispatch(t.type)
+        if t.name:
+            self.write(", ")
+            self.dispatch(t.name)
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+    def _ClassDef(self, t):
+        self.write("\n")
+        self.fill("class "+t.name)
+        if t.bases:
+            self.write("(")
+            for a in t.bases:
+                self.dispatch(a)
+                self.write(", ")
+            self.write(")")
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+    def _FunctionDef(self, t):
+        self.write("\n")
+        for deco in t.decorator_list:
+            self.fill("@")
+            self.dispatch(deco)
+        self.fill("def "+t.name + "(")
+        self.dispatch(t.args)
+        self.write(")")
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+    def _For(self, t):
+        self.fill("for ")
+        self.dispatch(t.target)
+        self.write(" in ")
+        self.dispatch(t.iter)
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+        if t.orelse:
+            self.fill("else")
+            self.enter()
+            self.dispatch(t.orelse)
+            self.leave
+
+    def _If(self, t):
+        self.fill("if ")
+        self.dispatch(t.test)
+        self.enter()
+        # XXX elif?
+        self.dispatch(t.body)
+        self.leave()
+        if t.orelse:
+            self.fill("else")
+            self.enter()
+            self.dispatch(t.orelse)
+            self.leave()
+
+    def _While(self, t):
+        self.fill("while ")
+        self.dispatch(t.test)
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+        if t.orelse:
+            self.fill("else")
+            self.enter()
+            self.dispatch(t.orelse)
+            self.leave
+
+    def _With(self, t):
+        self.fill("with ")
+        self.dispatch(t.context_expr)
+        if t.optional_vars:
+            self.write(" as ")
+            self.dispatch(t.optional_vars)
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+    # expr
+    def _Str(self, tree):
+        self.write(repr(tree.s))
+
+    def _Name(self, t):
+        self.write(t.id)
+
+    def _Repr(self, t):
+        self.write("`")
+        self.dispatch(t.value)
+        self.write("`")
+
+    def _Num(self, t):
+        self.write(repr(t.n))
+
+    def _List(self, t):
+        self.write("[")
+        interleave(lambda: self.write(", "), self.dispatch, t.elts)
+        self.write("]")
+
+    def _ListComp(self, t):
+        self.write("[")
+        self.dispatch(t.elt)
+        for gen in t.generators:
+            self.dispatch(gen)
+        self.write("]")
+
+    def _GeneratorExp(self, t):
+        self.write("(")
+        self.dispatch(t.elt)
+        for gen in t.generators:
+            self.dispatch(gen)
+        self.write(")")
+
+    def _comprehension(self, t):
+        self.write(" for ")
+        self.dispatch(t.target)
+        self.write(" in ")
+        self.dispatch(t.iter)
+        for if_clause in t.ifs:
+            self.write(" if ")
+            self.dispatch(if_clause)
+
+    def _IfExp(self, t):
+        self.write("(")
+        self.dispatch(t.body)
+        self.write(" if ")
+        self.dispatch(t.test)
+        self.write(" else ")
+        self.dispatch(t.orelse)
+        self.write(")")
+
+    def _Dict(self, t):
+        self.write("{")
+        def writem(arg):
+            (k, v) = arg
+            self.dispatch(k)
+            self.write(": ")
+            self.dispatch(v)
+        interleave(lambda: self.write(", "), writem, zip(t.keys, t.values))
+        self.write("}")
+
+    def _Tuple(self, t):
+        self.write("(")
+        if len(t.elts) == 1:
+            (elt,) = t.elts
+            self.dispatch(elt)
+            self.write(",")
+        else:
+            interleave(lambda: self.write(", "), self.dispatch, t.elts)
+        self.write(")")
+
+    unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"}
+    def _UnaryOp(self, t):
+        self.write(self.unop[t.op.__class__.__name__])
+        self.write("(")
+        self.dispatch(t.operand)
+        self.write(")")
+
+    binop = { "Add":"+", "Sub":"-", "Mult":"*", "Div":"/", "Mod":"%",
+                    "LShift":">>", "RShift":"<<", "BitOr":"|", "BitXor":"^", "BitAnd":"&",
+                    "FloorDiv":"//", "Pow": "**"}
+    def _BinOp(self, t):
+        self.write("(")
+        self.dispatch(t.left)
+        self.write(" " + self.binop[t.op.__class__.__name__] + " ")
+        self.dispatch(t.right)
+        self.write(")")
+
+    cmpops = {"Eq":"==", "NotEq":"!=", "Lt":"<", "LtE":"<=", "Gt":">", "GtE":">=",
+                        "Is":"is", "IsNot":"is not", "In":"in", "NotIn":"not in"}
+    def _Compare(self, t):
+        self.write("(")
+        self.dispatch(t.left)
+        for o, e in zip(t.ops, t.comparators):
+            self.write(" " + self.cmpops[o.__class__.__name__] + " ")
+            self.dispatch(e)
+            self.write(")")
+
+    boolops = {_ast.And: 'and', _ast.Or: 'or'}
+    def _BoolOp(self, t):
+        self.write("(")
+        s = " %s " % self.boolops[t.op.__class__]
+        interleave(lambda: self.write(s), self.dispatch, t.values)
+        self.write(")")
+
+    def _Attribute(self,t):
+        self.dispatch(t.value)
+        self.write(".")
+        self.write(t.attr)
+
+    def _Call(self, t):
+        self.dispatch(t.func)
+        self.write("(")
+        comma = False
+        for e in t.args:
+            if comma: self.write(", ")
+            else: comma = True
+            self.dispatch(e)
+        for e in t.keywords:
+            if comma: self.write(", ")
+            else: comma = True
+            self.dispatch(e)
+        if t.starargs:
+            if comma: self.write(", ")
+            else: comma = True
+            self.write("*")
+            self.dispatch(t.starargs)
+        if t.kwargs:
+            if comma: self.write(", ")
+            else: comma = True
+            self.write("**")
+            self.dispatch(t.kwargs)
+        self.write(")")
+
+    def _Subscript(self, t):
+        self.dispatch(t.value)
+        self.write("[")
+        self.dispatch(t.slice)
+        self.write("]")
+
+    # slice
+    def _Ellipsis(self, t):
+        self.write("...")
+
+    def _Index(self, t):
+        self.dispatch(t.value)
+
+    def _Slice(self, t):
+        if t.lower:
+            self.dispatch(t.lower)
+        self.write(":")
+        if t.upper:
+            self.dispatch(t.upper)
+        if t.step:
+            self.write(":")
+            self.dispatch(t.step)
+
+    def _ExtSlice(self, t):
+        interleave(lambda: self.write(', '), self.dispatch, t.dims)
+
+    # others
+    def _arguments(self, t):
+        first = True
+        nonDef = len(t.args)-len(t.defaults)
+        for a in t.args[0:nonDef]:
+            if first:first = False
+            else: self.write(", ")
+            self.dispatch(a)
+        for a,d in zip(t.args[nonDef:], t.defaults):
+            if first:first = False
+            else: self.write(", ")
+            self.dispatch(a),
+            self.write("=")
+            self.dispatch(d)
+        if t.vararg:
+            if first:first = False
+            else: self.write(", ")
+            self.write("*"+t.vararg)
+        if t.kwarg:
+            if first:first = False
+            else: self.write(", ")
+            self.write("**"+t.kwarg)
+
+    def _keyword(self, t):
+        self.write(t.arg)
+        self.write("=")
+        self.dispatch(t.value)
+
+    def _Lambda(self, t):
+        self.write("lambda ")
+        self.dispatch(t.args)
+        self.write(": ")
+        self.dispatch(t.body)
+
+    def _alias(self, t):
+        self.write(t.name)
+        if t.asname:
+            self.write(" as "+t.asname)
+
+def roundtrip(filename, output=sys.stdout):
+    source = open(filename).read()
+    tree = compile(source, filename, "exec", _ast.PyCF_ONLY_AST)
+    Unparser(tree, output)
+
+
+
+def testdir(a):
+    try:
+        names = [n for n in os.listdir(a) if n.endswith('.py')]
+    except OSError:
+        sys.stderr.write("Directory not readable: %s\n" % a)
+    else:
+        for n in names:
+            fullname = os.path.join(a, n)
+            if os.path.isfile(fullname):
+                output = io.StringIO()
+                print('Testing %s' % fullname)
+                try:
+                    roundtrip(fullname, output)
+                except Exception :
+                    e = sys.exc_info()[1]
+                    print('  Failed to compile, exception is %s' % repr(e))
+            elif os.path.isdir(fullname):
+                testdir(fullname)
+
+def main(args):
+    if args[0] == '--testdir':
+        for a in args[1:]:
+            testdir(a)
+    else:
+        for a in args:
+            roundtrip(a)
+
+if __name__=='__main__':
+    main(sys.argv[1:])

+# this file has been automatically generated running:
+# snakes/lang/asdl.py --output=snakes/lang/python/asdl.py snakes/lang/python/python.asdl
+# timestamp: 2010-04-22 11:40:44.120690
+
+from snakes.lang import ast
+from snkast import *
+
+class _AST (ast.AST):
+    def __init__ (self, **ARGS):
+        ast.AST.__init__(self)
+        for k, v in ARGS.items():
+            setattr(self, k, v)
+
+class arguments (_AST):
+    _fields = ('args', 'vararg', 'varargannotation', 'kwonlyargs', 'kwarg', 'kwargannotation', 'defaults', 'kw_defaults')
+    _attributes = ()
+    def __init__ (self, args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[], **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.args = list(args)
+        self.vararg = vararg
+        self.varargannotation = varargannotation
+        self.kwonlyargs = list(kwonlyargs)
+        self.kwarg = kwarg
+        self.kwargannotation = kwargannotation
+        self.defaults = list(defaults)
+        self.kw_defaults = list(kw_defaults)
+
+class slice (_AST):
+    pass
+
+class Slice (slice):
+    _fields = ('lower', 'upper', 'step')
+    _attributes = ()
+    def __init__ (self, lower=None, upper=None, step=None, **ARGS):
+        slice.__init__(self, **ARGS)
+        self.lower = lower
+        self.upper = upper
+        self.step = step
+
+class ExtSlice (slice):
+    _fields = ('dims',)
+    _attributes = ()
+    def __init__ (self, dims=[], **ARGS):
+        slice.__init__(self, **ARGS)
+        self.dims = list(dims)
+
+class Index (slice):
+    _fields = ('value',)
+    _attributes = ()
+    def __init__ (self, value, **ARGS):
+        slice.__init__(self, **ARGS)
+        self.value = value
+
+class cmpop (_AST):
+    pass
+
+class Eq (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class NotEq (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class Lt (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class LtE (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class Gt (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class GtE (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class Is (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class IsNot (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class In (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class NotIn (cmpop):
+    _fields = ()
+    _attributes = ()
+
+class expr_context (_AST):
+    pass
+
+class Load (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class Store (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class Del (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class AugLoad (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class AugStore (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class Param (expr_context):
+    _fields = ()
+    _attributes = ()
+
+class keyword (_AST):
+    _fields = ('arg', 'value')
+    _attributes = ()
+    def __init__ (self, arg, value, **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.arg = arg
+        self.value = value
+
+class unaryop (_AST):
+    pass
+
+class Invert (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class Not (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class UAdd (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class USub (unaryop):
+    _fields = ()
+    _attributes = ()
+
+class expr (_AST):
+    pass
+
+class BoolOp (expr):
+    _fields = ('op', 'values')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, op, values=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.op = op
+        self.values = list(values)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class BinOp (expr):
+    _fields = ('left', 'op', 'right')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, left, op, right, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.left = left
+        self.op = op
+        self.right = right
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class UnaryOp (expr):
+    _fields = ('op', 'operand')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, op, operand, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.op = op
+        self.operand = operand
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Lambda (expr):
+    _fields = ('args', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, args, body, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.args = args
+        self.body = body
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class IfExp (expr):
+    _fields = ('test', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, body, orelse, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.test = test
+        self.body = body
+        self.orelse = orelse
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Dict (expr):
+    _fields = ('keys', 'values')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, keys=[], values=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.keys = list(keys)
+        self.values = list(values)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Set (expr):
+    _fields = ('elts',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elts=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elts = list(elts)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class ListComp (expr):
+    _fields = ('elt', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elt, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elt = elt
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class SetComp (expr):
+    _fields = ('elt', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elt, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elt = elt
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class DictComp (expr):
+    _fields = ('key', 'value', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, key, value, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.key = key
+        self.value = value
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class GeneratorExp (expr):
+    _fields = ('elt', 'generators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elt, generators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elt = elt
+        self.generators = list(generators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Yield (expr):
+    _fields = ('value',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Compare (expr):
+    _fields = ('left', 'ops', 'comparators')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, left, ops=[], comparators=[], lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.left = left
+        self.ops = list(ops)
+        self.comparators = list(comparators)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Call (expr):
+    _fields = ('func', 'args', 'keywords', 'starargs', 'kwargs')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, func, args=[], keywords=[], starargs=None, kwargs=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.func = func
+        self.args = list(args)
+        self.keywords = list(keywords)
+        self.starargs = starargs
+        self.kwargs = kwargs
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Num (expr):
+    _fields = ('n',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, n, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.n = n
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Str (expr):
+    _fields = ('s',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, s, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.s = s
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Ellipsis (expr):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Attribute (expr):
+    _fields = ('value', 'attr', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, attr, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.attr = attr
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Subscript (expr):
+    _fields = ('value', 'slice', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, slice, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.slice = slice
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Starred (expr):
+    _fields = ('value', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.value = value
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Name (expr):
+    _fields = ('id', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, id, ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.id = id
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class List (expr):
+    _fields = ('elts', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elts=[], ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elts = list(elts)
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Tuple (expr):
+    _fields = ('elts', 'ctx')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, elts=[], ctx=None, lineno=0, col_offset=0, **ARGS):
+        expr.__init__(self, **ARGS)
+        self.elts = list(elts)
+        self.ctx = ctx
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class boolop (_AST):
+    pass
+
+class And (boolop):
+    _fields = ()
+    _attributes = ()
+
+class Or (boolop):
+    _fields = ()
+    _attributes = ()
+
+class stmt (_AST):
+    pass
+
+class FunctionDef (stmt):
+    _fields = ('name', 'args', 'body', 'decorator_list', 'returns')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, args, body=[], decorator_list=[], returns=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.name = name
+        self.args = args
+        self.body = list(body)
+        self.decorator_list = list(decorator_list)
+        self.returns = returns
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class ClassDef (stmt):
+    _fields = ('name', 'bases', 'keywords', 'starargs', 'kwargs', 'body', 'decorator_list')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, name, bases=[], keywords=[], starargs=None, kwargs=None, body=[], decorator_list=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.name = name
+        self.bases = list(bases)
+        self.keywords = list(keywords)
+        self.starargs = starargs
+        self.kwargs = kwargs
+        self.body = list(body)
+        self.decorator_list = list(decorator_list)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Return (stmt):
+    _fields = ('value',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Delete (stmt):
+    _fields = ('targets',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, targets=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.targets = list(targets)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Assign (stmt):
+    _fields = ('targets', 'value')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, targets=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.targets = list(targets)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class AugAssign (stmt):
+    _fields = ('target', 'op', 'value')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, target, op, value, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.target = target
+        self.op = op
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class For (stmt):
+    _fields = ('target', 'iter', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, target, iter, body=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.target = target
+        self.iter = iter
+        self.body = list(body)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class While (stmt):
+    _fields = ('test', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, body=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.test = test
+        self.body = list(body)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class If (stmt):
+    _fields = ('test', 'body', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, body=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.test = test
+        self.body = list(body)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class With (stmt):
+    _fields = ('context_expr', 'optional_vars', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, context_expr, optional_vars=None, body=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.context_expr = context_expr
+        self.optional_vars = optional_vars
+        self.body = list(body)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Raise (stmt):
+    _fields = ('exc', 'cause')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, exc=None, cause=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.exc = exc
+        self.cause = cause
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class TryExcept (stmt):
+    _fields = ('body', 'handlers', 'orelse')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, body=[], handlers=[], orelse=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.body = list(body)
+        self.handlers = list(handlers)
+        self.orelse = list(orelse)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class TryFinally (stmt):
+    _fields = ('body', 'finalbody')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, body=[], finalbody=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.body = list(body)
+        self.finalbody = list(finalbody)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Assert (stmt):
+    _fields = ('test', 'msg')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, test, msg=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.test = test
+        self.msg = msg
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Import (stmt):
+    _fields = ('names',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, names=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.names = list(names)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class ImportFrom (stmt):
+    _fields = ('module', 'names', 'level')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, module, names=[], level=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.module = module
+        self.names = list(names)
+        self.level = level
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Exec (stmt):
+    _fields = ('body', 'globals', 'locals')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, body, globals=None, locals=None, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.body = body
+        self.globals = globals
+        self.locals = locals
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Global (stmt):
+    _fields = ('names',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, names=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.names = list(names)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Nonlocal (stmt):
+    _fields = ('names',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, names=[], lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.names = list(names)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Expr (stmt):
+    _fields = ('value',)
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, value, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.value = value
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Pass (stmt):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Break (stmt):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class Continue (stmt):
+    _fields = ()
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, lineno=0, col_offset=0, **ARGS):
+        stmt.__init__(self, **ARGS)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class excepthandler (_AST):
+    pass
+
+class ExceptHandler (excepthandler):
+    _fields = ('type', 'name', 'body')
+    _attributes = ('lineno', 'col_offset')
+    def __init__ (self, type=None, name=None, body=[], lineno=0, col_offset=0, **ARGS):
+        excepthandler.__init__(self, **ARGS)
+        self.type = type
+        self.name = name
+        self.body = list(body)
+        self.lineno = int(lineno)
+        self.col_offset = int(col_offset)
+
+class alias (_AST):
+    _fields = ('name', 'asname')
+    _attributes = ()
+    def __init__ (self, name, asname=None, **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.name = name
+        self.asname = asname
+
+class comprehension (_AST):
+    _fields = ('target', 'iter', 'ifs')
+    _attributes = ()
+    def __init__ (self, target, iter, ifs=[], **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.target = target
+        self.iter = iter
+        self.ifs = list(ifs)
+
+class arg (_AST):
+    _fields = ('arg', 'annotation')
+    _attributes = ()
+    def __init__ (self, arg, annotation=None, **ARGS):
+        _AST.__init__(self, **ARGS)
+        self.arg = arg
+        self.annotation = annotation
+
+class operator (_AST):
+    pass
+
+class Add (operator):
+    _fields = ()
+    _attributes = ()
+
+class Sub (operator):
+    _fields = ()
+    _attributes = ()
+
+class Mult (operator):
+    _fields = ()
+    _attributes = ()
+
+class Div (operator):
+    _fields = ()
+    _attributes = ()
+
+class Mod (operator):
+    _fields = ()
+    _attributes = ()
+
+class Pow (operator):
+    _fields = ()
+    _attributes = ()
+
+class LShift (operator):
+    _fields = ()
+    _attributes = ()
+
+class RShift (operator):
+    _fields = ()
+    _attributes = ()
+
+class BitOr (operator):
+    _fields = ()
+    _attributes = ()
+
+class BitXor (operator):
+    _fields = ()
+    _attributes = ()
+
+class BitAnd (operator):
+    _fields = ()
+    _attributes = ()
+
+class FloorDiv (operator):
+    _fields = ()
+    _attributes = ()
+
+class mod (_AST):
+    pass
+
+class Module (mod):
+    _fields = ('body',)
+    _attributes = ()
+    def __init__ (self, body=[], **ARGS):
+        mod.__init__(self, **ARGS)
+        self.body = list(body)
+
+class Interactive (mod):
+    _fields = ('body',)
+    _attributes = ()
+    def __init__ (self, body=[], **ARGS):
+        mod.__init__(self, **ARGS)
+        self.body = list(body)
+
+class Expression (mod):
+    _fields = ('body',)
+    _attributes = ()
+    def __init__ (self, body, **ARGS):
+        mod.__init__(self, **ARGS)
+        self.body = body
+
+class Suite (mod):
+    _fields = ('body',)
+    _attributes = ()
+    def __init__ (self, body=[], **ARGS):
+        mod.__init__(self, **ARGS)
+        self.body = list(body)

+"""
+>>> testparser(Translator)
+"""
+
+import doctest, traceback, sys, re, operator, inspect
+from snakes.lang.pgen import ParseError
+from snakes.lang.python.pgen import parser
+import snakes.lang.python.asdl as ast
+from snakes import *
+
+_symbols = parser.tokenizer.tok_name.copy()
+# next statement overrides 'NT_OFFSET' entry with 'single_input'
+# (this is desired)
+_symbols.update(parser.symbolMap)
+
+class ParseTree (list) :
+    _symbols = _symbols
+    def __init__ (self, st) :
+        self.symbol = self._symbols[st[0][0]]
+        self.kind = st[0][0]
+        self.srow = st[0][1].srow
+        self.erow = st[0][1].erow
+        self.scol = st[0][1].scol
+        self.ecol = st[0][1].ecol
+        self.text = st[0][1]
+        self.filename = self.text.filename
+        list.__init__(self, (self.__class__(child) for child in st[1]))
+    def __repr__ (self) :
+        return repr(self.text)
+    def involve (self, rule) :
+        if self.kind == rule :
+            return True
+        for child in self :
+            if child.involve(rule) :
+                return True
+        return False
+    def source (self) :
+        lines = self.text.lexer.lines[self.srow-1:self.erow]
+        if self.srow == self.erow :
+            lines[0] = lines[0][self.scol:self.ecol]
+        else :
+            lines[0] = lines[0][self.scol:]
+            lines[-1] = lines[-1][:self.ecol]
+        return str("\n".join(l.rstrip("\n") for l in lines))
+
+class Translator (object) :
+    ParseTree = ParseTree
+    parser = parser
+    ST = ast
+    def __init__ (self, st) :
+        for value, name in self.parser.tokenizer.tok_name.items() :
+            setattr(self, name, value)
+        def isdict (obj) : return isinstance(obj, dict)
+        for name, d in inspect.getmembers(self.__class__, isdict) :
+            d = d.copy()
+            for key, val in d.items() :
+                try :
+                    d[key] = getattr(self.ST, val.__name__)
+                except AttributeError :
+                    pass
+            setattr(self, name, d)
+        self.ast = self.do(self.ParseTree(st))
+    def do (self, st, ctx=None) :
+        if ctx is None :
+            ctx = self.ST.Load
+        name = st.symbol
+        meth = getattr(self, "do_" + name)
+        tree = meth(st, ctx)
+        try :
+            tree.st = st
+        except AttributeError :
+            pass
+        return tree
+    # unary operations
+    _unary = {"not" : ast.Not,
+              "+" : ast.UAdd,
+              "-" : ast.USub,
+              "~" : ast.Invert}
+    def _do_unary (self, st, ctx) :
+        """unary: not_test | factor
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            return self.ST.UnaryOp(lineno=st.srow, col_offset=st.scol,
+                                   op=self._unary[st[0].text](lineno=st[0].srow,
+                                                              col_offset=st[0].scol),
+                                   operand=self.do(st[1], ctx))
+    # binary operations
+    _binary = {"+" : ast.Add,
+               "-" : ast.Sub,
+               "*" : ast.Mult,
+               "/" : ast.Div,
+               "%" : ast.Mod,
+               "&" : ast.BitAnd,
+               "|" : ast.BitOr,
+               "^" : ast.BitXor,
+               "<<" : ast.LShift,
+               ">>" : ast.RShift,
+               "**" : ast.Pow,
+               "//" : ast.FloorDiv}
+    def _do_binary (self, st, ctx) :
+        """binary: expr | xor_expr | and_expr | shift_expr | arith_expr | term
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            values = [self.do(child, ctx) for child in st[::2]]
+            ops = [(self._binary[child.text], child) for child in st[1::2]]
+            while len(values) > 1 :
+                left = values.pop(0)
+                right = values.pop(0)
+                operator, node = ops.pop(0)
+                values.insert(0, self.ST.BinOp(lineno=st.srow,
+                                               col_offset=st.scol,
+                                               left=left,
+                                               op=operator(lineno=node.srow,
+                                                           col_offset=node.scol),
+                                               right=right))
+            return values[0]
+    # boolean operation
+    _boolean = {"and" : ast.And,
+                "or" : ast.Or}
+    def _do_boolean (self, st, ctx) :
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            return self.ST.BoolOp(lineno=st.srow, col_offset=st.scol,
+                                  op=self._boolean[st[1].text](lineno=st[1].srow,
+                                                               col_offset=st[1].scol),
+                                  values=[self.do(child, ctx)
+                                          for child in st[::2]])
+    # start of rule handlers
+    def do_file_input (self, st, ctx) :
+        """file_input: (NEWLINE | stmt)* ENDMARKER
+        -> ast.Module
+
+        <<< pass
+        'Module(body=[Pass()])'
+        """
+        body = reduce(operator.add,
+                      (self.do(child, ctx)  for child in st
+                       if child.kind not in (self.NEWLINE, self.ENDMARKER)),
+                      [])
+        return self.ST.Module(lineno=st.srow,
+                              col_offset=st.scol,
+                              body=body)
+    def do_decorator (self, st, ctx) :
+        """decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
+        -> ast.AST
+
+        <<< @foo
+        ... def f() : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[Name(id='foo', ctx=Load())], returns=None)])"
+        <<< @foo.bar
+        ... def f() : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[Attribute(value=Name(id='foo', ctx=Load()), attr='bar', ctx=Load())], returns=None)])"
+        <<< @foo()
+        ... def f() : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[Call(func=Name(id='foo', ctx=Load()), args=[], keywords=[], starargs=None, kwargs=None)], returns=None)])"
+        <<< @foo(x, y)
+        ... def f() : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[Call(func=Name(id='foo', ctx=Load()), args=[Name(id='x', ctx=Load()), Name(id='y', ctx=Load())], keywords=[], starargs=None, kwargs=None)], returns=None)])"
+        <<< @foo.bar(x, y)
+        ... def f() : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[Call(func=Attribute(value=Name(id='foo', ctx=Load()), attr='bar', ctx=Load()), args=[Name(id='x', ctx=Load()), Name(id='y', ctx=Load())], keywords=[], starargs=None, kwargs=None)], returns=None)])"
+        """
+        names = self.do(st[1], ctx).split(".")
+        obj = self.ST.Name(lineno=st[1].srow, col_offset=st[1].scol,
+                           id=names.pop(0), ctx=ctx())
+        while names :
+            obj = self.ST.Attribute(lineno=st[1].srow,
+                                    col_offset=st[1].scol,
+                                    value=obj, attr=names.pop(0), ctx=ctx())
+        if len(st) == 3 :
+            return obj
+        elif len(st) == 5 :
+            return self.ST.Call(lineno=st[1].srow, col_offset=st[1].scol,
+                                func=obj, args=[], keywords=[],
+                                starargs=None, kwargs=None)
+        else :
+            args, keywords, starargs, kwargs = self.do(st[3], ctx)
+            return self.ST.Call(lineno=st[1].srow, col_offset=st[1].scol,
+                                func=obj, args=args, keywords=keywords,
+                                starargs=starargs, kwargs=kwargs)
+    def do_decorators (self, st, ctx) :
+        """decorators: decorator+
+        -> ast.AST+
+
+        <<< @foo
+        ... @bar
+        ... @spam.egg()
+        ... def f () :
+        ...     pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[Name(id='foo', ctx=Load()), Name(id='bar', ctx=Load()), Call(func=Attribute(value=Name(id='spam', ctx=Load()), attr='egg', ctx=Load()), args=[], keywords=[], starargs=None, kwargs=None)], returns=None)])"
+        """
+        return [self.do(child, ctx) for child in st]
+    def do_decorated (self, st, ctx) :
+        """decorated: decorators (classdef | funcdef)
+        -> ast.AST
+
+        <<< @foo
+        ... def f () :
+        ...     pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[Name(id='foo', ctx=Load())], returns=None)])"
+        <<< @foo
+        ... class c () :
+        ...     pass
+        "Module(body=[ClassDef(name='c', bases=[], keywords=[], starargs=None, kwargs=None, body=[Pass()], decorator_list=[Name(id='foo', ctx=Load())])])"
+        """
+        child = self.do(st[1], ctx)
+        child.decorator_list.extend(self.do(st[0], ctx))
+        return child
+    def do_funcdef (self, st, ctx) :
+        """funcdef: 'def' NAME parameters ['->' test] ':' suite
+        -> ast.FunctionDef
+
+        <<< def f(x, y) : x+y
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=None), arg(arg='y', annotation=None)], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Expr(value=BinOp(left=Name(id='x', ctx=Load()), op=Add(), right=Name(id='y', ctx=Load())))], decorator_list=[], returns=None)])"
+        <<< def f(x, y) -> int : x+y
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=None), arg(arg='y', annotation=None)], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Expr(value=BinOp(left=Name(id='x', ctx=Load()), op=Add(), right=Name(id='y', ctx=Load())))], decorator_list=[], returns=Name(id='int', ctx=Load()))])"
+        """
+        if len(st) == 5 :
+            return self.ST.FunctionDef(lineno=st.srow, col_offset=st.scol,
+                                       name=st[1].text,
+                                       args=self.do(st[2], ctx),
+                                       returns=None,
+                                       body=self.do(st[-1], ctx),
+                                       decorator_list=[])
+        else :
+            return self.ST.FunctionDef(lineno=st.srow, col_offset=st.scol,
+                                       name=st[1].text,
+                                       args=self.do(st[2], ctx),
+                                       returns=self.do(st[5], ctx),
+                                       body=self.do(st[-1], ctx),
+                                       decorator_list=[])
+    def do_parameters (self, st, ctx) :
+        """parameters: '(' [typedargslist] ')'
+        -> ast.arguments
+
+        <<< def f () : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[], returns=None)])"
+        <<< def f(x, y) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=None), arg(arg='y', annotation=None)], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[], returns=None)])"
+        """
+        if len(st) == 2 :
+            return self.ST.arguments(lineno=st.srow, col_offset=st.scol,
+                                     args=[], vararg=None,
+                                     varargannotation=None,
+                                     kwonlyargs=[], kwarg=None,
+                                     kwargannotation=None,
+                                     defaults=[], kw_defaults=[])
+        else :
+            return self.do(st[1], ctx)
+    def do_typedargslist (self, st, ctx) :
+        """typedargslist: ((tfpdef ['=' test] ',')*
+                ('*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef]
+                 | '**' tfpdef)
+                | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
+        -> ast.arguments
+
+        <<< def f(x) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=None)], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[], returns=None)])"
+        <<< def f(x, *y, z) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=None)], vararg='y', varargannotation=None, kwonlyargs=[arg(arg='z', annotation=None)], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[None]), body=[Pass()], decorator_list=[], returns=None)])"
+        <<< def f(*, x=1) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[arg(arg='x', annotation=None)], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[Num(n=1)]), body=[Pass()], decorator_list=[], returns=None)])"
+        <<< def f(x, y, *z, a=1, b=2, **d) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=None), arg(arg='y', annotation=None)], vararg='z', varargannotation=None, kwonlyargs=[arg(arg='a', annotation=None), arg(arg='b', annotation=None)], kwarg='d', kwargannotation=None, defaults=[], kw_defaults=[Num(n=1), Num(n=2)]), body=[Pass()], decorator_list=[], returns=None)])"
+        <<< def f(x:int) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=Name(id='int', ctx=Load()))], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[], returns=None)])"
+        <<< def f(x:int, *y:float, z:bool) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=Name(id='int', ctx=Load()))], vararg='y', varargannotation=Name(id='float', ctx=Load()), kwonlyargs=[arg(arg='z', annotation=Name(id='bool', ctx=Load()))], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[None]), body=[Pass()], decorator_list=[], returns=None)])"
+        <<< def f(*, x:int=1) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[arg(arg='x', annotation=Name(id='int', ctx=Load()))], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[Num(n=1)]), body=[Pass()], decorator_list=[], returns=None)])"
+        <<< def f(x:int, y, *z:float, a=1, b:bool=False, **d:object) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=Name(id='int', ctx=Load())), arg(arg='y', annotation=None)], vararg='z', varargannotation=Name(id='float', ctx=Load()), kwonlyargs=[arg(arg='a', annotation=None), arg(arg='b', annotation=Name(id='bool', ctx=Load()))], kwarg='d', kwargannotation=Name(id='object', ctx=Load()), defaults=[], kw_defaults=[Num(n=1), Name(id='False', ctx=Load())]), body=[Pass()], decorator_list=[], returns=None)])"
+        """
+        args = []
+        vararg = None
+        varargannotation = None
+        star = False
+        kwonlyargs = []
+        kwarg = None
+        kwargannotation = None
+        defaults = []
+        kw_defaults = []
+        nodes = list(st)
+        while nodes :
+            first = nodes.pop(0)
+            if first.text == "," :
+                pass
+            elif first.text == "*" :
+                star = True
+                if nodes and nodes[0].text != "," :
+                    vararg, varargannotation = self.do(nodes.pop(0), ctx)
+            elif first.text == "**" :
+                kwarg, kwargannotation = self.do(nodes.pop(0), ctx)
+            else :
+                n, a = self.do(first, ctx)
+                arg = self.ST.arg(lineno=first.srow, col_offset=first.scol,
+                                  arg=n, annotation=a)
+                if nodes and nodes[0].text == "=" :
+                    del nodes[0]
+                    d = self.do(nodes.pop(0), ctx)
+                else :
+                    d = None
+                if star :
+                    kwonlyargs.append(arg)
+                    kw_defaults.append(d)
+                else :
+                    args.append(arg)
+                    if d is not None :
+                        defaults.append(d)
+        return self.ST.arguments(lineno=st.srow, col_offset=st.scol,
+                                 args=args,
+                                 vararg=vararg,
+                                 varargannotation=varargannotation,
+                                 kwonlyargs=kwonlyargs,
+                                 kwarg=kwarg,
+                                 kwargannotation=kwargannotation,
+                                 defaults=defaults,
+                                 kw_defaults=kw_defaults)
+    def do_tfpdef (self, st, ctx) :
+        """tfpdef: NAME [':' test]
+        -> str, ast.AST?
+
+        <<< def f(x:int) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=Name(id='int', ctx=Load()))], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[], returns=None)])"
+        <<< def f(x:int, y:float) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=Name(id='int', ctx=Load())), arg(arg='y', annotation=Name(id='float', ctx=Load()))], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[], returns=None)])"
+        <<< def f(x, y:int) : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[arg(arg='x', annotation=None), arg(arg='y', annotation=Name(id='int', ctx=Load()))], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[], returns=None)])"
+        """
+        if len(st) == 1 :
+            return st[0].text, None
+        else :
+            return st[0].text, self.do(st[2], ctx)
+    def do_varargslist (self, st, ctx) :
+        """varargslist: ((vfpdef ['=' test] ',')*
+              ('*' [vfpdef] (',' vfpdef ['=' test])*  [',' '**' vfpdef]
+               | '**' vfpdef)
+              | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
+        -> ast.arguments
+
+        <<< lambda x, y : x+y
+        "Module(body=[Expr(value=Lambda(args=arguments(args=[arg(arg='x', annotation=None), arg(arg='y', annotation=None)], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=BinOp(left=Name(id='x', ctx=Load()), op=Add(), right=Name(id='y', ctx=Load()))))])"
+        <<< lambda x, y, z=1 : x+y+z
+        "Module(body=[Expr(value=Lambda(args=arguments(args=[arg(arg='x', annotation=None), arg(arg='y', annotation=None), arg(arg='z', annotation=None)], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[Num(n=1)], kw_defaults=[]), body=BinOp(left=BinOp(left=Name(id='x', ctx=Load()), op=Add(), right=Name(id='y', ctx=Load())), op=Add(), right=Name(id='z', ctx=Load()))))])"
+        """
+        tree = self.do_typedargslist(st, ctx)
+        tree.st = st
+        return tree
+    def do_vfpdef (self, st, ctx) :
+        """vfpdef: NAME
+        -> str, None
+
+        Return value (str, None) is choosen for compatibility with
+        do_tfpdef, so that do_typedargslist can be used for
+        do_varargslist.
+
+        <<< lambda x, y : x+y
+        "Module(body=[Expr(value=Lambda(args=arguments(args=[arg(arg='x', annotation=None), arg(arg='y', annotation=None)], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=BinOp(left=Name(id='x', ctx=Load()), op=Add(), right=Name(id='y', ctx=Load()))))])"
+        """
+        return st[0].text, None
+    def do_stmt (self, st, ctx) :
+        """stmt: simple_stmt | compound_stmt
+        -> ast.AST+
+
+        <<< pass
+        'Module(body=[Pass()])'
+        <<< pass; pass
+        'Module(body=[Pass(), Pass()])'
+        <<< with x : y
+        "Module(body=[With(context_expr=Name(id='x', ctx=Load()), optional_vars=None, body=[Expr(value=Name(id='y', ctx=Load()))])])"
+        """
+        child = self.do(st[0], ctx)
+        if isinstance(child, self.ST.AST) :
+            return [child]
+        else :
+            return child
+    def do_simple_stmt (self, st, ctx) :
+        """simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
+        -> ast.AST+
+
+        <<< del x; pass; import spam as egg
+        "Module(body=[Delete(targets=[Name(id='x', ctx=Del())]), Pass(), Import(names=[alias(name='spam', asname='egg')])])"
+        """
+        return [self.do(child, ctx) for child in st[::2]
+                if child.kind != self.NEWLINE]
+    def do_small_stmt (self, st, ctx) :
+        """small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt |
+                     import_stmt | global_stmt | nonlocal_stmt | assert_stmt)
+        -> ast.AST
+
+        <<< x
+        "Module(body=[Expr(value=Name(id='x', ctx=Load()))])"
+        <<< del x
+        "Module(body=[Delete(targets=[Name(id='x', ctx=Del())])])"
+        <<< pass
+        'Module(body=[Pass()])'
+        <<< import egg as spam
+        "Module(body=[Import(names=[alias(name='egg', asname='spam')])])"
+        <<< global x
+        "Module(body=[Global(names=['x'])])"
+        <<< nonlocal x
+        "Module(body=[Nonlocal(names=['x'])])"
+        <<< assert x
+        "Module(body=[Assert(test=Name(id='x', ctx=Load()), msg=None)])"
+        """
+        return self.do(st[0], ctx)
+    def do_expr_stmt (self, st, ctx) :
+        """expr_stmt: testlist (augassign (yield_expr|testlist) |
+                                ('=' (yield_expr|testlist))*)
+        -> ast.Expr
+
+        <<< x = y = 1
+        "Module(body=[Assign(targets=[Name(id='x', ctx=Store()), Name(id='y', ctx=Store())], value=Num(n=1))])"
+        <<< x, y = z = 1, 2
+        "Module(body=[Assign(targets=[Tuple(elts=[Name(id='x', ctx=Store()), Name(id='y', ctx=Store())], ctx=Store()), Name(id='z', ctx=Store())], value=Tuple(elts=[Num(n=1), Num(n=2)], ctx=Load()))])"
+        <<< x += 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=Add(), value=Num(n=1))])"
+        <<< x += yield 5
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=Add(), value=Yield(value=Num(n=5)))])"
+        <<< x = y = yield 1, 2
+        "Module(body=[Assign(targets=[Name(id='x', ctx=Store()), Name(id='y', ctx=Store())], value=Yield(value=Tuple(elts=[Num(n=1), Num(n=2)], ctx=Load())))])"
+        """
+        if len(st) == 1 :
+            return self.ST.Expr(lineno=st.srow, col_offset=st.scol,
+                                value=self.do(st[0], ctx))
+        elif st[1].symbol == "augassign" :
+            target = self.do(st[0], self.ST.Store)
+            if isinstance(target, self.ST.Tuple) :
+                raise ParseError(st[0].text, reason="illegal expression for"
+                                 " augmented assignment")
+            return self.ST.AugAssign(lineno=st.srow, col_offset=st.scol,
+                                     target=target,
+                                     op=self.do(st[1], ctx),
+                                     value=self.do(st[2], ctx))
+        else :
+            return self.ST.Assign(lineno=st.srow, col_offset=st.scol,
+                                  targets=[self.do(child, ast.Store)
+                                           for child in st[:-1:2]],
+                                  value=self.do(st[-1], ctx))
+    def do_augassign (self, st, ctx) :
+        """augassign: ('+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' |
+            '<<=' | '>>=' | '**=' | '//=')
+        -> ast.AST
+
+        <<< x += 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=Add(), value=Num(n=1))])"
+        <<< x -= 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=Sub(), value=Num(n=1))])"
+        <<< x *= 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=Mult(), value=Num(n=1))])"
+        <<< x /= 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=Div(), value=Num(n=1))])"
+        <<< x %= 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=Mod(), value=Num(n=1))])"
+        <<< x &= 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=BitAnd(), value=Num(n=1))])"
+        <<< x |= 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=BitOr(), value=Num(n=1))])"
+        <<< x ^= 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=BitXor(), value=Num(n=1))])"
+        <<< x <<= 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=LShift(), value=Num(n=1))])"
+        <<< x >>= 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=RShift(), value=Num(n=1))])"
+        <<< x **= 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=Pow(), value=Num(n=1))])"
+        <<< x //= 1
+        "Module(body=[AugAssign(target=Name(id='x', ctx=Store()), op=FloorDiv(), value=Num(n=1))])"
+        """
+        return self._binary[st[0].text[:-1]](lineno=st.srow, col_offset=st.scol)
+    def do_del_stmt (self, st, ctx) :
+        """del_stmt: 'del' exprlist
+        -> ast.Delete
+
+        <<< del x
+        "Module(body=[Delete(targets=[Name(id='x', ctx=Del())])])"
+        <<< del x, y
+        "Module(body=[Delete(targets=[Name(id='x', ctx=Del()), Name(id='y', ctx=Del())])])"
+        """
+        targets = self.do(st[1], ctx=self.ST.Del)
+        if isinstance(targets, self.ST.Tuple) :
+            targets = targets.elts
+        else :
+            targets = [targets]
+        return self.ST.Delete(lineno=st.srow, col_offset=st.scol,
+                              targets=targets)
+    def do_pass_stmt (self, st, ctx) :
+        """pass_stmt: 'pass'
+        -> ast.Pass
+
+        <<< pass
+        'Module(body=[Pass()])'
+        """
+        return self.ST.Pass(lineno=st.srow, col_offset=st.scol)
+    def do_flow_stmt (self, st, ctx) :
+        """flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt
+                 | yield_stmt
+        -> ast.AST
+
+        <<< break
+        'Module(body=[Break()])'
+        <<< continue
+        'Module(body=[Continue()])'
+        <<< return
+        'Module(body=[Return(value=None)])'
+        <<< raise
+        'Module(body=[Raise(exc=None, cause=None)])'
+        <<< yield
+        'Module(body=[Expr(value=Yield(value=None))])'
+        """
+        return self.do(st[0], ctx)
+    def do_break_stmt (self, st, ctx) :
+        """break_stmt: 'break'
+        -> ast.Break()
+
+        <<< break
+        'Module(body=[Break()])'
+        """
+        return self.ST.Break(lineno=st.srow, col_offset=st.scol)
+    def do_continue_stmt (self, st, ctx) :
+        """continue_stmt: 'continue'
+        -> ast.Continue
+
+        <<< continue
+        'Module(body=[Continue()])'
+        """
+        return self.ST.Continue(lineno=st.srow, col_offset=st.scol)
+    def do_return_stmt (self, st, ctx) :
+        """return_stmt: 'return' [testlist]
+        -> ast.Return
+
+        <<< return
+        'Module(body=[Return(value=None)])'
+        <<< return 1
+        'Module(body=[Return(value=Num(n=1))])'
+        <<< return 1, 2
+        'Module(body=[Return(value=Tuple(elts=[Num(n=1), Num(n=2)], ctx=Load()))])'
+        """
+        if len(st) == 1 :
+            return self.ST.Return(lineno=st.srow, col_offset=st.scol,
+                                  value=None)
+
+        else :
+            return self.ST.Return(lineno=st.srow, col_offset=st.scol,
+                                  value=self.do(st[1], ctx))
+    def do_yield_stmt (self, st, ctx) :
+        """yield_stmt: yield_expr
+        -> ast.Expr
+
+        <<< yield
+        'Module(body=[Expr(value=Yield(value=None))])'
+        <<< yield 42
+        'Module(body=[Expr(value=Yield(value=Num(n=42)))])'
+        """
+        return self.ST.Expr(lineno=st.srow, col_offset=st.scol,
+                            value=self.do(st[0], ctx))
+    def do_raise_stmt (self, st, ctx) :
+        """raise_stmt: 'raise' [test ['from' test]]
+        -> ast.Raise
+
+        <<< raise
+        'Module(body=[Raise(exc=None, cause=None)])'
+        <<< raise Exception
+        "Module(body=[Raise(exc=Name(id='Exception', ctx=Load()), cause=None)])"
+        <<< raise Exception from Exception
+        "Module(body=[Raise(exc=Name(id='Exception', ctx=Load()), cause=Name(id='Exception', ctx=Load()))])"
+        """
+        count = len(st)
+        if count == 1 :
+            return self.ST.Raise(lineno=st.srow, col_offset=st.scol,
+                                 exc=None, cause=None)
+        elif count == 2 :
+            return self.ST.Raise(lineno=st.srow, col_offset=st.scol,
+                                 exc=self.do(st[1], ctx),
+                                 cause=None)
+        else :
+            return self.ST.Raise(lineno=st.srow, col_offset=st.scol,
+                                 exc=self.do(st[1], ctx),
+                                 cause=self.do(st[3], ctx))
+    def do_import_stmt (self, st, ctx) :
+        """import_stmt: import_name | import_from
+        -> ast.AST
+
+        <<< import foo
+        "Module(body=[Import(names=[alias(name='foo', asname=None)])])"
+        <<< import foo.bar
+        "Module(body=[Import(names=[alias(name='foo.bar', asname=None)])])"
+        <<< import foo as bar
+        "Module(body=[Import(names=[alias(name='foo', asname='bar')])])"
+        <<< import foo.bar as egg
+        "Module(body=[Import(names=[alias(name='foo.bar', asname='egg')])])"
+        <<< import foo as bar, egg as spam
+        "Module(body=[Import(names=[alias(name='foo', asname='bar'), alias(name='egg', asname='spam')])])"
+        <<< import foo, bar, egg as spam
+        "Module(body=[Import(names=[alias(name='foo', asname=None), alias(name='bar', asname=None), alias(name='egg', asname='spam')])])"
+        """
+        return self.do(st[0], ctx)
+    def do_import_name (self, st, ctx) :
+        """import_name: 'import' dotted_as_names
+        -> ast.Import
+
+        <<< import foo
+        "Module(body=[Import(names=[alias(name='foo', asname=None)])])"
+        <<< import foo.bar
+        "Module(body=[Import(names=[alias(name='foo.bar', asname=None)])])"
+        <<< import foo as bar
+        "Module(body=[Import(names=[alias(name='foo', asname='bar')])])"
+        <<< import foo.bar as egg
+        "Module(body=[Import(names=[alias(name='foo.bar', asname='egg')])])"
+        <<< import foo as bar, egg as spam
+        "Module(body=[Import(names=[alias(name='foo', asname='bar'), alias(name='egg', asname='spam')])])"
+        <<< import foo, bar, egg as spam
+        "Module(body=[Import(names=[alias(name='foo', asname=None), alias(name='bar', asname=None), alias(name='egg', asname='spam')])])"
+        """
+        return self.ST.Import(lineno=st.srow, col_offset=st.scol,
+                              names=self.do(st[1], ctx))
+    def do_import_from (self, st, ctx) :
+        """import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+)
+              'import' ('*' | '(' import_as_names ')' | import_as_names))
+        -> ast.ImportFrom
+
+        <<< from foo import egg as spam
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='egg', asname='spam')], level=0)])"
+        <<< from .foo import egg as spam
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='egg', asname='spam')], level=1)])"
+        <<< from ...foo import egg as spam
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='egg', asname='spam')], level=3)])"
+        <<< from ...foo.bar import egg as spam
+        "Module(body=[ImportFrom(module='foo.bar', names=[alias(name='egg', asname='spam')], level=3)])"
+        <<< from foo import egg as spam, bar as baz
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='egg', asname='spam'), alias(name='bar', asname='baz')], level=0)])"
+        <<< from .foo import egg as spam, bar as baz
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='egg', asname='spam'), alias(name='bar', asname='baz')], level=1)])"
+        <<< from ...foo import egg as spam, bar as baz
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='egg', asname='spam'), alias(name='bar', asname='baz')], level=3)])"
+        <<< from ...foo.bar import egg as spam, baz
+        "Module(body=[ImportFrom(module='foo.bar', names=[alias(name='egg', asname='spam'), alias(name='baz', asname=None)], level=3)])"
+        <<< from foo import *
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='*', asname=None)], level=0)])"
+        <<< from .foo import *
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='*', asname=None)], level=1)])"
+        <<< from ...foo import *
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='*', asname=None)], level=3)])"
+        <<< from ...foo.bar import *
+        "Module(body=[ImportFrom(module='foo.bar', names=[alias(name='*', asname=None)], level=3)])"
+        """
+        level = 0
+        next = 1
+        for i, child in enumerate(st[1:]) :
+            text = child.text
+            if text not in (".", "...") :
+                next = i+1
+                break
+            level += len(text)
+        if text == "import" :
+            module = ""
+            next += 1
+        else :
+            module = self.do(st[next], ctx)
+            next += 2
+        text = st[next].text
+        if text == "*" :
+            names = [self.ST.alias(lineno=st[next].srow,
+                                   col_offset=st[next].scol,
+                                   name="*", asname=None)]
+        elif text == "(" :
+            names = self.do(st[next+1], ctx)
+        else :
+            names = self.do(st[next], ctx)
+        return self.ST.ImportFrom(lineno=st.srow, col_offset=st.scol,
+                                  module=module, names=names, level=level)
+    def do_import_as_name (self, st, ctx) :
+        """import_as_name: NAME ['as' NAME]
+        -> ast.alias
+
+        <<< from foo import egg as spam
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='egg', asname='spam')], level=0)])"
+        """
+        if len(st) == 1 :
+            return self.ST.alias(lineno=st.srow, col_offset=st.scol,
+                                 name=st[0].text,
+                                 asname=None)
+        else :
+            return self.ST.alias(lineno=st.srow, col_offset=st.scol,
+                                 name=st[0].text,
+                                 asname=st[2].text)
+    def do_dotted_as_name (self, st, ctx) :
+        """dotted_as_name: dotted_name ['as' NAME]
+        -> ast.alias
+
+        <<< import foo.bar as egg
+        "Module(body=[Import(names=[alias(name='foo.bar', asname='egg')])])"
+        """
+        if len(st) == 1 :
+            return self.ST.alias(lineno=st.srow, col_offset=st.scol,
+                                 name=self.do(st[0], ctx),
+                                 asname=None)
+        else :
+            return self.ST.alias(lineno=st.srow, col_offset=st.scol,
+                                 name=self.do(st[0], ctx),
+                                 asname=st[2].text)
+    def do_import_as_names (self, st, ctx) :
+        """import_as_names: import_as_name (',' import_as_name)* [',']
+        -> ast.alias+
+
+        <<< from foo import egg as spam
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='egg', asname='spam')], level=0)])"
+        <<< from foo import egg as spam, bar as baz
+        "Module(body=[ImportFrom(module='foo', names=[alias(name='egg', asname='spam'), alias(name='bar', asname='baz')], level=0)])"
+        """
+        return [self.do(child, ctx) for child in st[::2]]
+    def do_dotted_as_names (self, st, ctx) :
+        """dotted_as_names: dotted_as_name (',' dotted_as_name)*
+        -> ast.alias+
+
+        <<< import foo.bar, egg.spam as baz
+        "Module(body=[Import(names=[alias(name='foo.bar', asname=None), alias(name='egg.spam', asname='baz')])])"
+        """
+        return [self.do(child, ctx) for child in st[::2]]
+    def do_dotted_name (self, st, ctx) :
+        """dotted_name: NAME ('.' NAME)*
+        -> str
+
+        <<< import foo.bar
+        "Module(body=[Import(names=[alias(name='foo.bar', asname=None)])])"
+        """
+        return ".".join(child.text for child in st[::2])
+    def do_global_stmt (self, st, ctx) :
+        """global_stmt: 'global' NAME (',' NAME)*
+        -> ast.Global
+
+        <<< global x
+        "Module(body=[Global(names=['x'])])"
+        <<< global x, y
+        "Module(body=[Global(names=['x', 'y'])])"
+        """
+        return self.ST.Global(lineno=st.srow, col_offset=st.scol,
+                              names=[child.text for child in st[1::2]])
+    def do_nonlocal_stmt (self, st, ctx) :
+        """nonlocal_stmt: 'nonlocal' NAME (',' NAME)*
+        -> ast.Nonlocal
+
+        <<< nonlocal x
+        "Module(body=[Nonlocal(names=['x'])])"
+        <<< nonlocal x, y
+        "Module(body=[Nonlocal(names=['x', 'y'])])"
+        """
+        return self.ST.Nonlocal(lineno=st.srow, col_offset=st.scol,
+                                names=[child.text for child in st[1::2]])
+    def do_assert_stmt (self, st, ctx) :
+        """assert_stmt: 'assert' test [',' test]
+        -> ast.Assert
+
+        <<< assert x
+        "Module(body=[Assert(test=Name(id='x', ctx=Load()), msg=None)])"
+        <<< assert x, y
+        "Module(body=[Assert(test=Name(id='x', ctx=Load()), msg=Name(id='y', ctx=Load()))])"
+        """
+        if len(st) == 2 :
+            return self.ST.Assert(lineno=st.srow, col_offset=st.scol,
+                                  test=self.do(st[1], ctx),
+                                  msg=None)
+        else :
+            return self.ST.Assert(lineno=st.srow, col_offset=st.scol,
+                                  test=self.do(st[1], ctx),
+                                  msg=self.do(st[3], ctx))
+    def do_compound_stmt (self, st, ctx) :
+        """compound_stmt: (if_stmt | while_stmt | for_stmt | try_stmt
+                | with_stmt | funcdef | classdef | decorated)
+        -> ast.AST
+
+        <<< with x : pass
+        "Module(body=[With(context_expr=Name(id='x', ctx=Load()), optional_vars=None, body=[Pass()])])"
+        <<< if x : pass
+        "Module(body=[If(test=Name(id='x', ctx=Load()), body=[Pass()], orelse=[])])"
+        <<< while x : pass
+        "Module(body=[While(test=Name(id='x', ctx=Load()), body=[Pass()], orelse=[])])"
+        <<< for x in l : pass
+        "Module(body=[For(target=Name(id='x', ctx=Store()), iter=Name(id='l', ctx=Load()), body=[Pass()], orelse=[])])"
+        <<< try : pass
+        ... except : pass
+        'Module(body=[TryExcept(body=[Pass()], handlers=[ExceptHandler(type=None, name=None, body=[Pass()])], orelse=[])])'
+        <<< def f () : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[], returns=None)])"
+        <<< class c () : pass
+        "Module(body=[ClassDef(name='c', bases=[], keywords=[], starargs=None, kwargs=None, body=[Pass()], decorator_list=[])])"
+        <<< @foo
+        ... def f () : pass
+        "Module(body=[FunctionDef(name='f', args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=[Pass()], decorator_list=[Name(id='foo', ctx=Load())], returns=None)])"
+        """
+        return self.do(st[0], ctx)
+    def do_if_stmt (self, st, ctx) :
+        """if_stmt: 'if' test ':' suite ('elif' test ':' suite)*
+               ['else' ':' suite]
+        -> ast.If
+
+        <<< if x == 1 : pass
+        "Module(body=[If(test=Compare(left=Name(id='x', ctx=Load()), ops=[Eq()], comparators=[Num(n=1)]), body=[Pass()], orelse=[])])"
+        <<< if x == 1 : pass
+        ... else : pass
+        "Module(body=[If(test=Compare(left=Name(id='x', ctx=Load()), ops=[Eq()], comparators=[Num(n=1)]), body=[Pass()], orelse=[Pass()])])"
+        <<< if x == 1 : pass
+        ... elif y == 2 : pass
+        ... elif z == 3 : pass
+        ... else : pass
+        "Module(body=[If(test=Compare(left=Name(id='x', ctx=Load()), ops=[Eq()], comparators=[Num(n=1)]), body=[Pass()], orelse=[If(test=Compare(left=Name(id='y', ctx=Load()), ops=[Eq()], comparators=[Num(n=2)]), body=[Pass()], orelse=[If(test=Compare(left=Name(id='z', ctx=Load()), ops=[Eq()], comparators=[Num(n=3)]), body=[Pass()], orelse=[Pass()])])])])"
+
+        """
+        nodes = list(st)
+        first = None
+        last = None
+        while nodes :
+            if len(nodes) == 3 :
+                last.orelse.extend(self.do(nodes[2], ctx))
+                del nodes[:3]
+            else :
+                next = self.ST.If(lineno=nodes[0].srow,
+                                  col_offset=nodes[0].scol,
+                                  test=self.do(nodes[1], ctx),
+                                  body=self.do(nodes[3], ctx),
+                                  orelse=[])
+                if first is None :
+                    first = next
+                if last is not None :
+                    last.orelse.append(next)
+                last = next
+                del nodes[:4]
+        return first
+    def do_while_stmt (self, st, ctx) :
+        """while_stmt: 'while' test ':' suite ['else' ':' suite]
+        -> ast.While
+
+        <<< while x : pass
+        "Module(body=[While(test=Name(id='x', ctx=Load()), body=[Pass()], orelse=[])])"
+        <<< while x :
+        ...     pass
+        ...     pass
+        "Module(body=[While(test=Name(id='x', ctx=Load()), body=[Pass(), Pass()], orelse=[])])"
+        <<< while x :
+        ...     pass
+        ... else :
+        ...     pass
+        "Module(body=[While(test=Name(id='x', ctx=Load()), body=[Pass()], orelse=[Pass()])])"
+        """
+        if len(st) == 4 :
+            return self.ST.While(lineno=st.srow, col_offset=st.scol,
+                                 test=self.do(st[1], ctx),
+                                 body=self.do(st[3], ctx),
+                                 orelse=[])
+        else :
+            return self.ST.While(lineno=st.srow, col_offset=st.scol,
+                                 test=self.do(st[1], ctx),
+                                 body=self.do(st[3], ctx),
+                                 orelse=self.do(st[6], ctx))
+    def do_for_stmt (self, st, ctx) :
+        """for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+        -> ast.For
+
+        <<< for x in l : pass
+        "Module(body=[For(target=Name(id='x', ctx=Store()), iter=Name(id='l', ctx=Load()), body=[Pass()], orelse=[])])"
+        <<< for x in l :
+        ...     pass
+        ...     pass
+        "Module(body=[For(target=Name(id='x', ctx=Store()), iter=Name(id='l', ctx=Load()), body=[Pass(), Pass()], orelse=[])])"
+        <<< for x in l :
+        ...     pass
+        ... else :
+        ...     pass
+        "Module(body=[For(target=Name(id='x', ctx=Store()), iter=Name(id='l', ctx=Load()), body=[Pass()], orelse=[Pass()])])"
+        <<< for x, y in l : pass
+        "Module(body=[For(target=Tuple(elts=[Name(id='x', ctx=Store()), Name(id='y', ctx=Store())], ctx=Store()), iter=Name(id='l', ctx=Load()), body=[Pass()], orelse=[])])"
+        <<< for x in a, b : pass
+        "Module(body=[For(target=Name(id='x', ctx=Store()), iter=Tuple(elts=[Name(id='a', ctx=Load()), Name(id='b', ctx=Load())], ctx=Load()), body=[Pass()], orelse=[])])"
+        """
+        if len(st) == 6 :
+            return self.ST.For(lineno=st.srow, col_offset=st.scol,
+                               target=self.do(st[1], ast.Store),
+                               iter=self.do(st[3], ctx),
+                               body=self.do(st[5], ctx),
+                               orelse=[])
+        else :
+            return self.ST.For(lineno=st.srow, col_offset=st.scol,
+                               target=self.do(st[1], ast.Store),
+                               iter=self.do(st[3], ctx),
+                               body=self.do(st[5], ctx),
+                               orelse=self.do(st[8], ctx))
+    def do_try_stmt (self, st, ctx) :
+        """try_stmt: ('try' ':' suite
+           ((except_clause ':' suite)+
+            ['else' ':' suite]
+            ['finally' ':' suite] |
+	   'finally' ':' suite))
+        -> ast.TryExcept | ast.TryFinally
+
+        <<< try : pass
+        ... except : pass
+        'Module(body=[TryExcept(body=[Pass()], handlers=[ExceptHandler(type=None, name=None, body=[Pass()])], orelse=[])])'
+        <<< try : pass
+        ... except : pass
+        ... else : pass
+        ... finally : pass
+        'Module(body=[TryFinally(body=[TryExcept(body=[Pass()], handlers=[ExceptHandler(type=None, name=None, body=[Pass()])], orelse=[Pass()])], finalbody=[Pass()])])'
+        <<< try : pass
+        ... except TypeError : pass
+        ... except ValueError : pass
+        ... except : pass
+        "Module(body=[TryExcept(body=[Pass()], handlers=[ExceptHandler(type=Name(id='TypeError', ctx=Load()), name=None, body=[Pass()]), ExceptHandler(type=Name(id='ValueError', ctx=Load()), name=None, body=[Pass()]), ExceptHandler(type=None, name=None, body=[Pass()])], orelse=[])])"
+        """
+        handlers = []
+        finalbody = None
+        orelse = []
+        nodes = st[3:]
+        while nodes :
+            if nodes[0].text == "else" :
+                orelse.extend(self.do(nodes[2], ctx))
+            elif nodes[0].text == "finally" :
+                finalbody = self.do(nodes[2], ctx)
+            else :
+                t, n = self.do(nodes[0], ctx)
+                handlers.append(self.ST.ExceptHandler(lineno=nodes[0].srow,
+                                                      col_offset=nodes[0].scol,
+                                                      type=t, name=n,
+                                                      body=self.do(nodes[2], ctx)))
+            del nodes[:3]
+        stmt = self.ST.TryExcept(lineno=st.srow, col_offset=st.scol,
+                                 body=self.do(st[2], ctx),
+                                 handlers=handlers,
+                                 orelse=orelse)
+        if finalbody is None :
+            return stmt
+        else :
+            return self.ST.TryFinally(lineno=st.srow, col_offset=st.scol,
+                                      body=[stmt], finalbody=finalbody)
+    def do_with_stmt (self, st, ctx) :
+        """with_stmt: 'with' test [ with_var ] ':' suite
+        -> ast.With
+
+        <<< with x : pass
+        "Module(body=[With(context_expr=Name(id='x', ctx=Load()), optional_vars=None, body=[Pass()])])"
+        <<< with x as y : pass
+        "Module(body=[With(context_expr=Name(id='x', ctx=Load()), optional_vars=Name(id='y', ctx=Store()), body=[Pass()])])"
+        <<< with x :
+        ...     pass
+        "Module(body=[With(context_expr=Name(id='x', ctx=Load()), optional_vars=None, body=[Pass()])])"
+        <<< with x as y :
+        ...     pass
+        "Module(body=[With(context_expr=Name(id='x', ctx=Load()), optional_vars=Name(id='y', ctx=Store()), body=[Pass()])])"
+        """
+        if len(st) == 5 :
+            return self.ST.With(lineno=st.srow, col_offset=st.scol,
+                                context_expr=self.do(st[1], ctx),
+                                optional_vars=self.do(st[2], self.ST.Store),
+                                body=self.do(st[4], ctx))
+        else :
+            return self.ST.With(lineno=st.srow, col_offset=st.scol,
+                                context_expr=self.do(st[1], ctx),
+                                optional_vars=None,
+                                body=self.do(st[3], ctx))
+    def do_with_var (self, st, ctx) :
+        """with_var: 'as' expr
+        -> ast.Name
+
+        <<< with x as y : pass
+        "Module(body=[With(context_expr=Name(id='x', ctx=Load()), optional_vars=Name(id='y', ctx=Store()), body=[Pass()])])"
+        """
+        return self.do(st[1], ctx)
+    def do_except_clause (self, st, ctx) :
+        """except_clause: 'except' [test ['as' NAME]]
+        -> ast.AST?, ast.Name?
+
+        <<< try : pass
+        ... except NameError : pass
+        ... except TypeError as err : pass
+        ... except : pass
+        "Module(body=[TryExcept(body=[Pass()], handlers=[ExceptHandler(type=Name(id='NameError', ctx=Load()), name=None, body=[Pass()]), ExceptHandler(type=Name(id='TypeError', ctx=Load()), name=Name(id='err', ctx=Store()), body=[Pass()]), ExceptHandler(type=None, name=None, body=[Pass()])], orelse=[])])"
+        """
+        if len(st) == 1 :
+            return None, None
+        elif len(st) == 2 :
+            return self.do(st[1], ctx), None
+        else :
+            return self.do(st[1], ctx), self.ST.Name(lineno=st[3].srow,
+                                                     col_offset=st[3].scol,
+                                                     id=st[3].text,
+                                                     ctx=self.ST.Store())
+    def do_suite (self, st, ctx) :
+        """suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
+        -> ast.AST+
+
+        <<< with x : pass
+        "Module(body=[With(context_expr=Name(id='x', ctx=Load()), optional_vars=None, body=[Pass()])])"
+        <<< with x :
+        ...     pass
+        "Module(body=[With(context_expr=Name(id='x', ctx=Load()), optional_vars=None, body=[Pass()])])"
+        <<< with x :
+        ...     pass
+        ...     pass
+        "Module(body=[With(context_expr=Name(id='x', ctx=Load()), optional_vars=None, body=[Pass(), Pass()])])"
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            return reduce(operator.add,
+                          (self.do(child, ctx) for child in st[2:-1]),
+                          [])
+    def do_test (self, st, ctx) :
+        """test: or_test ['if' or_test 'else' test] | lambdef
+        -> ast.AST
+
+        <<< 3
+        'Module(body=[Expr(value=Num(n=3))])'
+        <<< 3 if x else 4
+        "Module(body=[Expr(value=IfExp(test=Name(id='x', ctx=Load()), body=Num(n=3), orelse=Num(n=4)))])"
+        <<< lambda x : x+1
+        "Module(body=[Expr(value=Lambda(args=arguments(args=[arg(arg='x', annotation=None)], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=BinOp(left=Name(id='x', ctx=Load()), op=Add(), right=Num(n=1))))])"
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            return self.ST.IfExp(lineno=st.srow, col_offset=st.scol,
+                                 test=self.do(st[2], ctx),
+                             body=self.do(st[0], ctx),
+                             orelse=self.do(st[4], ctx))
+    def do_test_nocond (self, st, ctx) :
+        """test_nocond: or_test | lambdef_nocond
+        -> ast.AST
+
+        <<< [x for x in (lambda: True, lambda: False) if x()]
+        "Module(body=[Expr(value=ListComp(elt=Name(id='x', ctx=Load()), generators=[comprehension(target=Name(id='x', ctx=Store()), iter=Tuple(elts=[Lambda(args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=Name(id='True', ctx=Load())), Lambda(args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=Name(id='False', ctx=Load()))], ctx=Load()), ifs=[Call(func=Name(id='x', ctx=Load()), args=[], keywords=[], starargs=None, kwargs=None)])]))])"
+        """
+        return self.do(st[0], ctx)
+    def do_lambdef (self, st, ctx) :
+        """lambdef: 'lambda' [varargslist] ':' test
+        -> ast.Lambda
+
+        <<< lambda : True
+        "Module(body=[Expr(value=Lambda(args=arguments(args=[], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=Name(id='True', ctx=Load())))])"
+        <<< lambda x : x+1
+        "Module(body=[Expr(value=Lambda(args=arguments(args=[arg(arg='x', annotation=None)], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=BinOp(left=Name(id='x', ctx=Load()), op=Add(), right=Num(n=1))))])"
+        """
+        if len(st) == 3 :
+            return self.ST.Lambda(lineno=st.srow, col_offset=st.scol,
+                                  args=self.ST.arguments(lineno=st.srow,
+                                                         col_offset=st.scol,
+                                                         args=[], vararg=None,
+                                                         varargannotation=None,
+                                                         kwonlyargs=[], kwarg=None,
+                                                         kwargannotation=None,
+                                                         defaults=[], kw_defaults=[]),
+                                  body=self.do(st[-1], ctx))
+        else :
+            return self.ST.Lambda(lineno=st.srow, col_offset=st.scol,
+                                  args=self.do(st[1], ctx),
+                                  body=self.do(st[-1], ctx))
+    def do_lambdef_nocond (self, st, ctx) :
+        """lambdef_nocond: 'lambda' [varargslist] ':' test_nocond
+        -> ast.Lambda
+
+        <<< [x for x in l if lambda y : x]
+        "Module(body=[Expr(value=ListComp(elt=Name(id='x', ctx=Load()), generators=[comprehension(target=Name(id='x', ctx=Store()), iter=Name(id='l', ctx=Load()), ifs=[Lambda(args=arguments(args=[arg(arg='y', annotation=None)], vararg=None, varargannotation=None, kwonlyargs=[], kwarg=None, kwargannotation=None, defaults=[], kw_defaults=[]), body=Name(id='x', ctx=Load()))])]))])"
+        """
+        tree = self.do_lambdef(st, ctx)
+        tree.st = st
+        return tree
+    def do_or_test (self, st, ctx) :
+        """or_test: and_test ('or' and_test)*
+        -> ast.AST
+
+        <<< x or y
+        "Module(body=[Expr(value=BoolOp(op=Or(), values=[Name(id='x', ctx=Load()), Name(id='y', ctx=Load())]))])"
+        <<< x or y or z
+        "Module(body=[Expr(value=BoolOp(op=Or(), values=[Name(id='x', ctx=Load()), Name(id='y', ctx=Load()), Name(id='z', ctx=Load())]))])"
+        """
+        return self._do_boolean(st, ctx)
+    def do_and_test (self, st, ctx) :
+        """and_test: not_test ('and' not_test)*
+        -> ast.AST
+
+        <<< x and y
+        "Module(body=[Expr(value=BoolOp(op=And(), values=[Name(id='x', ctx=Load()), Name(id='y', ctx=Load())]))])"
+        <<< x and y and z
+        "Module(body=[Expr(value=BoolOp(op=And(), values=[Name(id='x', ctx=Load()), Name(id='y', ctx=Load()), Name(id='z', ctx=Load())]))])"
+        """
+        return self._do_boolean(st, ctx)
+    def do_not_test (self, st, ctx) :
+        """not_test: 'not' not_test | comparison
+        -> ast.AST
+
+        <<< not x
+        "Module(body=[Expr(value=UnaryOp(op=Not(), operand=Name(id='x', ctx=Load())))])"
+        <<< not not x
+        "Module(body=[Expr(value=UnaryOp(op=Not(), operand=UnaryOp(op=Not(), operand=Name(id='x', ctx=Load()))))])"
+        """
+        return self._do_unary(st, ctx)
+    def do_comparison (self, st, ctx) :
+        """comparison: star_expr (comp_op star_expr)*
+        -> ast.AST
+
+        <<< *x < *y <= *z
+        "Module(body=[Expr(value=Compare(left=Starred(value=Name(id='x', ctx=Load()), ctx=Load()), ops=[Lt(), LtE()], comparators=[Starred(value=Name(id='y', ctx=Load()), ctx=Load()), Starred(value=Name(id='z', ctx=Load()), ctx=Load())]))])"
+        <<< x < y <= z
+        "Module(body=[Expr(value=Compare(left=Name(id='x', ctx=Load()), ops=[Lt(), LtE()], comparators=[Name(id='y', ctx=Load()), Name(id='z', ctx=Load())]))])"
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            return self.ST.Compare(lineno=st.srow, col_offset=st.scol,
+                                   left=self.do(st[0], ctx),
+                                   ops = [self.do(child, ctx)
+                                          for child in st[1::2]],
+                                   comparators = [self.do(child, ctx)
+                                                  for child in st[2::2]])
+    _comparison = {"<" : ast.Lt,
+                   ">" : ast.Gt,
+                   "==" : ast.Eq,
+                   ">=" : ast.GtE,
+                   "<=" : ast.LtE,
+                   "!=" : ast.NotEq,
+                   "<>" : ast.NotEq,
+                   "in" : ast.In,
+                   "not in" : ast.NotIn,
+                   "is" : ast.Is,
+                   "is not" : ast.IsNot}
+    def do_comp_op (self, st, ctx) :
+        """comp_op: '<'|'>'|'=='|'>='|'<='|'!='|'<>'|'in'|'not' 'in'|'is'
+                |'is' 'not'
+        -> ast.cmpop
+
+        <<< 1 < 2
+        'Module(body=[Expr(value=Compare(left=Num(n=1), ops=[Lt()], comparators=[Num(n=2)]))])'
+        <<< 1 > 2
+        'Module(body=[Expr(value=Compare(left=Num(n=1), ops=[Gt()], comparators=[Num(n=2)]))])'
+        <<< 1 == 2
+        'Module(body=[Expr(value=Compare(left=Num(n=1), ops=[Eq()], comparators=[Num(n=2)]))])'
+        <<< 1 >= 2
+        'Module(body=[Expr(value=Compare(left=Num(n=1), ops=[GtE()], comparators=[Num(n=2)]))])'
+        <<< 1 <= 2
+        'Module(body=[Expr(value=Compare(left=Num(n=1), ops=[LtE()], comparators=[Num(n=2)]))])'
+        <<< 1 != 2
+        'Module(body=[Expr(value=Compare(left=Num(n=1), ops=[NotEq()], comparators=[Num(n=2)]))])'
+        <<< 1 <> 2
+        'Module(body=[Expr(value=Compare(left=Num(n=1), ops=[NotEq()], comparators=[Num(n=2)]))])'
+        <<< 1 in 2
+        'Module(body=[Expr(value=Compare(left=Num(n=1), ops=[In()], comparators=[Num(n=2)]))])'
+        <<< 1 not in 2
+        'Module(body=[Expr(value=Compare(left=Num(n=1), ops=[NotIn()], comparators=[Num(n=2)]))])'
+        <<< 1 is 2
+        'Module(body=[Expr(value=Compare(left=Num(n=1), ops=[Is()], comparators=[Num(n=2)]))])'
+        <<< 1 is not 2
+        'Module(body=[Expr(value=Compare(left=Num(n=1), ops=[IsNot()], comparators=[Num(n=2)]))])'
+        """
+        text = " ".join(child.text for child in st)
+        return self._comparison[text](lineno=st.srow, col_offset=st.scol)
+    def do_star_expr (self, st, ctx) :
+        """star_expr: ['*'] expr
+        -> ast.AST
+
+        <<< x
+        "Module(body=[Expr(value=Name(id='x', ctx=Load()))])"
+        <<< *x
+        "Module(body=[Expr(value=Starred(value=Name(id='x', ctx=Load()), ctx=Load()))])"
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            return self.ST.Starred(lineno=st.srow, col_offset=st.scol,
+                                   value=self.do(st[1], ctx),
+                                   ctx=ctx())
+    def do_expr (self, st, ctx) :
+        """expr: xor_expr ('|' xor_expr)*
+        -> ast.AST
+
+        <<< 1
+        'Module(body=[Expr(value=Num(n=1))])'
+        <<< 1 | 2
+        'Module(body=[Expr(value=BinOp(left=Num(n=1), op=BitOr(), right=Num(n=2)))])'
+        <<< 1 | 2 | 3
+        'Module(body=[Expr(value=BinOp(left=BinOp(left=Num(n=1), op=BitOr(), right=Num(n=2)), op=BitOr(), right=Num(n=3)))])'
+        """
+        return self._do_binary(st, ctx)
+    def do_xor_expr (self, st, ctx) :
+        """xor_expr: and_expr ('^' and_expr)*
+        -> ast.AST
+
+        <<< 1
+        'Module(body=[Expr(value=Num(n=1))])'
+        <<< 1 ^ 2
+        'Module(body=[Expr(value=BinOp(left=Num(n=1), op=BitXor(), right=Num(n=2)))])'
+        <<< 1 ^ 2 ^ 3
+        'Module(body=[Expr(value=BinOp(left=BinOp(left=Num(n=1), op=BitXor(), right=Num(n=2)), op=BitXor(), right=Num(n=3)))])'
+        """
+        return self._do_binary(st, ctx)
+    def do_and_expr (self, st, ctx) :
+        """and_expr: shift_expr ('&' shift_expr)*
+        -> ast.AST
+
+        <<< 1
+        'Module(body=[Expr(value=Num(n=1))])'
+        <<< 1 & 2
+        'Module(body=[Expr(value=BinOp(left=Num(n=1), op=BitAnd(), right=Num(n=2)))])'
+        <<< 1 & 2 & 3
+        'Module(body=[Expr(value=BinOp(left=BinOp(left=Num(n=1), op=BitAnd(), right=Num(n=2)), op=BitAnd(), right=Num(n=3)))])'
+        """
+        return self._do_binary(st, ctx)
+    def do_shift_expr (self, st, ctx) :
+        """shift_expr: arith_expr (('<<'|'>>') arith_expr)*
+        -> ast.AST
+
+        <<< 1
+        'Module(body=[Expr(value=Num(n=1))])'
+        <<< 1 << 2
+        'Module(body=[Expr(value=BinOp(left=Num(n=1), op=LShift(), right=Num(n=2)))])'
+        <<< 1 << 2 >> 3
+        'Module(body=[Expr(value=BinOp(left=BinOp(left=Num(n=1), op=LShift(), right=Num(n=2)), op=RShift(), right=Num(n=3)))])'
+        """
+        return self._do_binary(st, ctx)
+    def do_arith_expr (self, st, ctx) :
+        """arith_expr: term (('+'|'-') term)*
+        -> ast.AST
+
+        <<< 1
+        'Module(body=[Expr(value=Num(n=1))])'
+        <<< 1 + 2
+        'Module(body=[Expr(value=BinOp(left=Num(n=1), op=Add(), right=Num(n=2)))])'
+        <<< 1 + 2 - 3
+        'Module(body=[Expr(value=BinOp(left=BinOp(left=Num(n=1), op=Add(), right=Num(n=2)), op=Sub(), right=Num(n=3)))])'
+        """
+        return self._do_binary(st, ctx)
+    def do_term (self, st, ctx) :
+        """term: factor (('*'|'/'|'%'|'//') factor)*
+        -> ast.AST
+
+        <<< 1
+        'Module(body=[Expr(value=Num(n=1))])'
+        <<< 1 * 2
+        'Module(body=[Expr(value=BinOp(left=Num(n=1), op=Mult(), right=Num(n=2)))])'
+        <<< 1 * 2 / 3
+        'Module(body=[Expr(value=BinOp(left=BinOp(left=Num(n=1), op=Mult(), right=Num(n=2)), op=Div(), right=Num(n=3)))])'
+        <<< 1 * 2 / 3 % 4
+        'Module(body=[Expr(value=BinOp(left=BinOp(left=BinOp(left=Num(n=1), op=Mult(), right=Num(n=2)), op=Div(), right=Num(n=3)), op=Mod(), right=Num(n=4)))])'
+        <<< 1 * 2 / 3 % 4 // 5
+        'Module(body=[Expr(value=BinOp(left=BinOp(left=BinOp(left=BinOp(left=Num(n=1), op=Mult(), right=Num(n=2)), op=Div(), right=Num(n=3)), op=Mod(), right=Num(n=4)), op=FloorDiv(), right=Num(n=5)))])'
+        """
+        return self._do_binary(st, ctx)
+    def do_factor (self, st, ctx) :
+        """factor: ('+'|'-'|'~') factor | power
+        -> ast.AST
+
+        <<< 1
+        'Module(body=[Expr(value=Num(n=1))])'
+        <<< +1
+        'Module(body=[Expr(value=UnaryOp(op=UAdd(), operand=Num(n=1)))])'
+        <<< -1
+        'Module(body=[Expr(value=Num(n=-1))])'
+        <<< ~1
+        'Module(body=[Expr(value=UnaryOp(op=Invert(), operand=Num(n=1)))])'
+        <<< +-1
+        'Module(body=[Expr(value=UnaryOp(op=UAdd(), operand=Num(n=-1)))])'
+        <<< -+1
+        'Module(body=[Expr(value=UnaryOp(op=USub(), operand=UnaryOp(op=UAdd(), operand=Num(n=1))))])'
+        <<< +-~1
+        'Module(body=[Expr(value=UnaryOp(op=UAdd(), operand=UnaryOp(op=USub(), operand=UnaryOp(op=Invert(), operand=Num(n=1)))))])'
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            tree = self._do_unary(st, ctx)
+            if (isinstance(tree.op, self.ST.USub)
+                and isinstance(tree.operand, self.ST.Num)
+                and tree.operand.n > 0) :
+                tree = self.ST.Num(lineno=st.srow, col_offset=st.scol,
+                                   n = -tree.operand.n)
+            return tree
+    def do_power (self, st, ctx) :
+        """power: atom trailer* ['**' factor]
+        -> ast.AST
+
+        <<< 1 ** 2
+        'Module(body=[Expr(value=BinOp(left=Num(n=1), op=Pow(), right=Num(n=2)))])'
+        <<< a.b ** 2
+        "Module(body=[Expr(value=BinOp(left=Attribute(value=Name(id='a', ctx=Load()), attr='b', ctx=Load()), op=Pow(), right=Num(n=2)))])"
+        """
+        if len(st) == 1 :
+            return self.do(st[0], ctx)
+        else :
+            left = self.do(st[0], ctx)
+            power = None
+            for child in st[1:] :
+                if child.text == "**" :
+                    power = self.do(st[-1], ctx)
+                    break
+                trailer = self.do(child, ctx)
+                left = trailer(left, st.srow, st.scol)
+            if power :
+                return self.ST.BinOp(lineno=st.srow, col_offset=st.scol,
+                                     left=left,
+                                     op=self.ST.Pow(lineno=st[-2].srow,
+                                                    col_offset=st[-2].scol),
+                                     right=power)
+            else :
+                return left
+    def do_atom (self, st, ctx) :
+        """atom: ('(' [yield_expr|testlist_comp] ')' |
+            '[' [testlist_comp] ']' |
+            '{' [dictorsetmaker] '}' |
+            NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False')
+        -> ast.AST
+
+        <<< foo
+        "Module(body=[Expr(value=Name(id='foo', ctx=Load()))])"
+        <<< True
+        "Module(body=[Expr(value=Name(id='True', ctx=Load()))])"
+        <<< 42
+        'Module(body=[Expr(value=Num(n=42))])'
+        <<< 1.5
+        'Module(body=[Expr(value=Num(n=1.5))])'
+        <<< 'hello'
+        "Module(body=[Expr(value=Str(s='hello'))])"
+        <<< 'hello' 'world'
+        "Module(body=[Expr(value=Str(s='helloworld'))])"
+        <<< '''hello
+        ... world'''
+        "Module(body=[Expr(value=Str(s='hello\\\\nworld'))])"
+        <<< [1, 2, 3]
+        'Module(body=[Expr(value=List(elts=[Num(n=1), Num(n=2), Num(n=3)], ctx=Load()))])'
+        <<< [x for x in l]
+        "Module(body=[Expr(value=ListComp(elt=Name(id='x', ctx=Load()), generators=[comprehension(target=Name(id='x', ctx=Store()), iter=Name(id='l', ctx=Load()), ifs=[])]))])"
+        <<< (1, 2, 3)
+        'Module(body=[Expr(value=Tuple(elts=[Num(n=1), Num(n=2), Num(n=3)], ctx=Load()))])'
+        <<< (1,)
+        'Module(body=[Expr(value=Tuple(elts=[Num(n=1)], ctx=Load()))])'
+        <<< (1)
+        'Module(body=[Expr(value=Num(n=1))])'
+        <<< (x for x in l)
+        "Module(body=[Expr(value=GeneratorExp(elt=Name(id='x', ctx=Load()), generators=[comprehension(target=Name(id='x', ctx=Store()), iter=Name(id='l', ctx=Load()), ifs=[])]))])"
+        <<< {1, 2, 3}
+        'Module(body=[Expr(value=Set(elts=[Num(n=1), Num(n=2), Num(n=3)]))])'
+        <<< {x for x in l}
+        "Module(body=[Expr(value=SetComp(elt=Name(id='x', ctx=Load()), generators=[comprehension(target=Name(id='x', ctx=Store()), iter=Name(id='l', ctx=Load()), ifs=[])]))])"
+        <<< {1:2, 3:4}
+        'Module(body=[Expr(value=Dict(keys=[Num(n=1), Num(n=3)], values=[Num(n=2), Num(n=4)]))])'
+        <<< {x:y for x, y in l}
+        "Module(body=[Expr(value=DictComp(key=Name(id='x', ctx=Load()), value=Name(id='y', ctx=Load()), generators=[comprehension(target=Tuple(elts=[Name(id='x', ctx=Store()), Name(id='y', ctx=Store())], ctx=Store()), iter=Name(id='l', ctx=Load()), ifs=[])]))])"
+        """
+        kind, text = st[0].kind, st[0].text
+        if kind == self.NUMBER :
+            return self.ST.Num(lineno=st.srow, col_offset=st.scol,
+                               n=self.ST.literal_eval(text))
+        elif kind == self.NAME :
+            return self.ST.Name(lineno=st.srow, col_offset=st.scol,
+                                id=text, ctx=ctx())
+        elif kind == self.STRING :
+            return self.ST.Str(lineno=st.srow, col_offset=st.scol,
+                               s="".join(self.ST.literal_eval(child.text)
+                                         for child in st))
+        elif text == "..." :
+            return self.ST.Ellipsis(lineno=st.srow, col_offset=st.scol)
+        elif text == "[" :
+            if len(st) == 2 :
+                return self.ST.List(lineno=st.srow, col_offset=st.scol,
+                                    elts=[], ctx=ctx())
+            else :
+                loop, elts, atom = self.do(st[1], ctx)
+                if atom is not None :
+                    elts=[atom]
+                if loop is None :
+                    return self.ST.List(lineno=st.srow, col_offset=st.scol,
+                                        elts=elts, ctx=ctx())
+                else :
+                    return self.ST.ListComp(lineno=st.srow, col_offset=st.scol,
+                                            elt=loop, generators=elts)
+        elif text == "(" :
+            if len(st) == 2 :
+                return self.ST.Tuple(lineno=st.srow, col_offset=st.scol,
+                                     elts=[], ctx=ctx())
+            elif st[1].symbol == "yield_expr" :
+                return self.do(st[1], ctx)
+            else :
+                loop, elts, atom = self.do(st[1], ctx)
+                if atom is not None :
+                    return atom
+                elif loop is None :
+                    return self.ST.Tuple(lineno=st.srow, col_offset=st.scol,
+                                         elts=elts, ctx=ctx())
+                else :
+                    return self.ST.GeneratorExp(lineno=st.srow, col_offset=st.scol,
+                                                elt=loop, generators=elts)
+        else : # text == "{"
+            if len(st) == 2 :
+                return self.ST.Dict(lineno=st.srow, col_offset=st.scol,
+                                    keys=[], values=[])
+            else :
+                return self.do(st[1], ctx)
+    def do_testlist_comp (self, st, ctx) :
+        """testlist_comp: test ( comp_for | (',' test)* [','] )
+        -> ast.AST?, ast.AST+
+
+        <<< [1, 2, 3]
+        'Module(body=[Expr(value=List(elts=[Num(n=1), Num(n=2), Num(n=3)], ctx=Load()))])'
+        <<< [x for x in l]
+        "Module(body=[Expr(value=ListComp(elt=Name(id='x', ctx=Load()), generators=[comprehension(target=Name(id='x', ctx=Store()), iter=Name(id='l', ctx=Load()), ifs=[])]))])"
+        """
+        if len(st) == 1 :
+            return None, None, self.do(st[0])
+        elif st[1].text == "," :
+            return None, [self.do(child, ctx) for child in st[::2]], None
+        else :
+            return self.do(st[0], ctx), self.do(st[1], ctx)[0], None
+    def do_trailer (self, st, ctx) :
+        """trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
+        -> (tree, line, column -> ast.AST)
+
+        <<< a.b
+        "Module(body=[Expr(value=Attribute(value=Name(id='a', ctx=Load()), attr='b', ctx=Load()))])"
+        <<< a.b.c
+        "Module(body=[Expr(value=Attribute(value=Attribute(value=Name(id='a', ctx=Load()), attr='b', ctx=Load()), attr='c', ctx=Load()))])"
+        <<< a.b[c].d
+        "Module(body=[Expr(value=Attribute(value=Subscript(value=Attribute(value=Name(id='a', ctx=Load()), attr='b', ctx=Load()), slice=Index(value=Name(id='c', ctx=Load())), ctx=Load()), attr='d', ctx=Load()))])"
+        <<< f()
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[], keywords=[], starargs=None, kwargs=None))])"
+        <<< f(x)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[Name(id='x', ctx=Load())], keywords=[], starargs=None, kwargs=None))])"
+        <<< f(x, *l, y=2)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[Name(id='x', ctx=Load())], keywords=[keyword(arg='y', value=Num(n=2))], starargs=Name(id='l', ctx=Load()), kwargs=None))])"
+        <<< f(x, *l, y=2, **d)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[Name(id='x', ctx=Load())], keywords=[keyword(arg='y', value=Num(n=2))], starargs=Name(id='l', ctx=Load()), kwargs=Name(id='d', ctx=Load())))])"
+        <<< f(*l)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[], keywords=[], starargs=Name(id='l', ctx=Load()), kwargs=None))])"
+        <<< f(**d)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[], keywords=[], starargs=None, kwargs=Name(id='d', ctx=Load())))])"
+        <<< f(x)(a=1, b=2)
+        "Module(body=[Expr(value=Call(func=Call(func=Name(id='f', ctx=Load()), args=[Name(id='x', ctx=Load())], keywords=[], starargs=None, kwargs=None), args=[], keywords=[keyword(arg='a', value=Num(n=1)), keyword(arg='b', value=Num(n=2))], starargs=None, kwargs=None))])"
+        """
+        hd = st[0].text
+        if hd == "." :
+            def trail (tree, lineno, col_offset) :
+                return self.ST.Attribute(lineno=lineno,
+                                         col_offset=col_offset,
+                                         value=tree,
+                                         attr=st[1].text,
+                                         ctx=ctx())
+        elif hd == "[" :
+            subscript = self.do(st[1], ctx)
+            if len(subscript) == 1 :
+                subscript = subscript[0]
+            else :
+                subscript = self.ST.ExtSlice(lineno=st[1].srow,
+                                             col_offset=st[1].scol,
+                                             dims=subscript,
+                                             ctx=ctx())
+            def trail (tree, lineno, col_offset) :
+                return self.ST.Subscript(lineno=lineno,
+                                         col_offset=col_offset,
+                                         value=tree,
+                                         slice=subscript,
+                                         ctx=ctx())
+        elif len(st) == 2 : # hd = "("
+            def trail (tree, lineno, col_offset) :
+                return self.ST.Call(lineno=lineno, col_offset=col_offset,
+                                    func=tree, args=[], keywords=[],
+                                    starargs=None, kwargs=None)
+        else : # hd = "("
+            def trail (tree, lineno, col_offset) :
+                args, keywords, starargs, kwargs = self.do(st[1], ctx)
+                return self.ST.Call(lineno=lineno, col_offset=col_offset,
+                                    func=tree, args=args, keywords=keywords,
+                                    starargs=starargs, kwargs=kwargs)
+        return trail
+    def do_subscriptlist (self, st, ctx) :
+        """subscriptlist: subscript (',' subscript)* [',']
+        -> ast.Slice+
+
+        <<< l[:]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=None, upper=None, step=None), ctx=Load()))])"
+        <<< l[1:]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=Num(n=1), upper=None, step=None), ctx=Load()))])"
+        <<< l[1::]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=Num(n=1), upper=None, step=Name(id='None', ctx=Load())), ctx=Load()))])"
+        <<< l[1:2:]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=Num(n=1), upper=Num(n=2), step=Name(id='None', ctx=Load())), ctx=Load()))])"
+        <<< l[1:2:3]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=Num(n=1), upper=Num(n=2), step=Num(n=3)), ctx=Load()))])"
+        <<< l[::]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=None, upper=None, step=Name(id='None', ctx=Load())), ctx=Load()))])"
+        <<< l[:2:]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=None, upper=Num(n=2), step=Name(id='None', ctx=Load())), ctx=Load()))])"
+        <<< l[:2:3]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=None, upper=Num(n=2), step=Num(n=3)), ctx=Load()))])"
+        <<< l[::3]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=None, upper=None, step=Num(n=3)), ctx=Load()))])"
+        <<< l[1:2:3,4:5:6]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=ExtSlice(dims=[Slice(lower=Num(n=1), upper=Num(n=2), step=Num(n=3)), Slice(lower=Num(n=4), upper=Num(n=5), step=Num(n=6))]), ctx=Load()))])"
+        """
+        return [self.do(child, ctx) for child in st[::2]]
+    def do_subscript (self, st, ctx) :
+        """subscript: test | [test] ':' [test] [sliceop]
+        -> ast.Slice | ast.Index
+
+        <<< l[:]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=None, upper=None, step=None), ctx=Load()))])"
+        <<< l[1:]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=Num(n=1), upper=None, step=None), ctx=Load()))])"
+        <<< l[1::]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=Num(n=1), upper=None, step=Name(id='None', ctx=Load())), ctx=Load()))])"
+        <<< l[1:2:]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=Num(n=1), upper=Num(n=2), step=Name(id='None', ctx=Load())), ctx=Load()))])"
+        <<< l[1:2:3]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=Num(n=1), upper=Num(n=2), step=Num(n=3)), ctx=Load()))])"
+        <<< l[::]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=None, upper=None, step=Name(id='None', ctx=Load())), ctx=Load()))])"
+        <<< l[:2:]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=None, upper=Num(n=2), step=Name(id='None', ctx=Load())), ctx=Load()))])"
+        <<< l[:2:3]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=None, upper=Num(n=2), step=Num(n=3)), ctx=Load()))])"
+        <<< l[::3]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=None, upper=None, step=Num(n=3)), ctx=Load()))])"
+        """
+        count = len(st)
+        if count == 1 and st[0].text == ":" :
+            return self.ST.Slice(lineno=st.srow, col_offset=st.scol,
+                                 lower=None, upper=None, step=None)
+        elif count == 1 :
+            return self.ST.Index(lineno=st.srow, col_offset=st.scol,
+                                 value=self.do(st[0], ctx))
+        elif count == 4 :
+            return self.ST.Slice(lineno=st.srow, col_offset=st.scol,
+                                 lower=self.do(st[0], ctx),
+                                 upper=self.do(st[2], ctx),
+                                 step=self.do(st[3], ctx))
+        elif count == 3 and st[-1].symbol == "test" :
+            return self.ST.Slice(lineno=st.srow, col_offset=st.scol,
+                                 lower=self.do(st[0], ctx),
+                                 upper=self.do(st[2], ctx),
+                                 step=None)
+        elif count == 3 and st[0].text == ":" :
+            return self.ST.Slice(lineno=st.srow, col_offset=st.scol,
+                                 lower=None,
+                                 upper=self.do(st[1], ctx),
+                                 step=self.do(st[2], ctx))
+        elif count == 3 :
+            return self.ST.Slice(lineno=st.srow, col_offset=st.scol,
+                                 lower=self.do(st[0], ctx),
+                                 upper=None,
+                                 step=self.do(st[2], ctx))
+        elif count == 2 and st[-1].symbol == "sliceop" :
+            return self.ST.Slice(lineno=st.srow, col_offset=st.scol,
+                                 lower=None,
+                                 upper=None,
+                                 step=self.do(st[1], ctx))
+        elif count == 2 and st[0].text == ":" :
+            return self.ST.Slice(lineno=st.srow, col_offset=st.scol,
+                                 lower=None,
+                                 upper=self.do(st[1], ctx),
+                                 step=None)
+        else :
+            return self.ST.Slice(lineno=st.srow, col_offset=st.scol,
+                                 lower=self.do(st[0], ctx),
+                                 upper=None,
+                                 step=None)
+    def do_sliceop (self, st, ctx) :
+        """sliceop: ':' [test]
+        -> ast.AST
+
+        <<< l[1::]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=Num(n=1), upper=None, step=Name(id='None', ctx=Load())), ctx=Load()))])"
+        <<< l[::3]
+        "Module(body=[Expr(value=Subscript(value=Name(id='l', ctx=Load()), slice=Slice(lower=None, upper=None, step=Num(n=3)), ctx=Load()))])"
+        """
+        if len(st) == 1 :
+            return self.ST.Name(lineno=st.srow, col_offset=st.scol,
+                                id="None", ctx=ctx())
+        else :
+            return self.do(st[1], ctx)
+    def do_exprlist (self, st, ctx) :
+        """exprlist: star_expr (',' star_expr)* [',']
+        -> ast.AST+
+
+        <<< del x
+        "Module(body=[Delete(targets=[Name(id='x', ctx=Del())])])"
+        <<< del x, y
+        "Module(body=[Delete(targets=[Name(id='x', ctx=Del()), Name(id='y', ctx=Del())])])"
+        """
+        tree = self.do_testlist(st, ctx)
+        tree.st = st
+        return tree
+    def do_testlist (self, st, ctx) :
+        """testlist: test (',' test)* [',']
+        -> ast.AST | ast.Tuple
+
+        <<< 1
+        'Module(body=[Expr(value=Num(n=1))])'
+        <<< 1, 2
+        'Module(body=[Expr(value=Tuple(elts=[Num(n=1), Num(n=2)], ctx=Load()))])'
+        """
+        lst = [self.do(child, ctx) for child in st[::2]]
+        if len(lst) == 1 :
+            return lst[0]
+        else :
+            return self.ST.Tuple(lineno=st.srow, col_offset=st.scol,
+                                 elts=lst, ctx=ctx())
+    def do_dictorsetmaker (self, st, ctx) :
+        """dictorsetmaker: ( (test ':' test (comp_for | (',' test ':' test)* [','])) |
+                  (test (comp_for | (',' test)* [','])) )
+        -> ast.Dict | ast.DictComp | ast.Set | ast.SetComp
+
+        <<< {1, 2, 3}
+        'Module(body=[Expr(value=Set(elts=[Num(n=1), Num(n=2), Num(n=3)]))])'
+        <<< {x for x in l}
+        "Module(body=[Expr(value=SetComp(elt=Name(id='x', ctx=Load()), generators=[comprehension(target=Name(id='x', ctx=Store()), iter=Name(id='l', ctx=Load()), ifs=[])]))])"
+        <<< {1:2, 3:4}
+        'Module(body=[Expr(value=Dict(keys=[Num(n=1), Num(n=3)], values=[Num(n=2), Num(n=4)]))])'
+        <<< {x:y for x, y in l}
+        "Module(body=[Expr(value=DictComp(key=Name(id='x', ctx=Load()), value=Name(id='y', ctx=Load()), generators=[comprehension(target=Tuple(elts=[Name(id='x', ctx=Store()), Name(id='y', ctx=Store())], ctx=Store()), iter=Name(id='l', ctx=Load()), ifs=[])]))])"
+        <<< {42}
+        'Module(body=[Expr(value=Set(elts=[Num(n=42)]))])'
+        """
+        if len(st) == 1 :
+            return self.ST.Set(lineno=st.srow, col_offset=st.scol,
+                               elts=[self.do(st[0], ctx)])
+        elif st[1].text == ":" :
+            if st[3].text == "," :
+                return self.ST.Dict(lineno=st.srow, col_offset=st.scol,
+                                    keys=[self.do(child, ctx)
+                                          for child in st[::4]],
+                                    values=[self.do(child, ctx)
+                                            for child in st[2::4]])
+            else :
+                return self.ST.DictComp(lineno=st.srow, col_offset=st.scol,
+                                        key=self.do(st[0], ctx),
+                                        value=self.do(st[2], ctx),
+                                        generators=self.do(st[3], ctx)[0])
+        else :
+            loop, elts, atom = self.do_testlist_comp(st, ctx)
+            if loop is None :
+                return self.ST.Set(lineno=st.srow, col_offset=st.scol,
+                                   elts=elts)
+            else :
+                return self.ST.SetComp(lineno=st.srow, col_offset=st.scol,
+                                       elt=loop, generators=elts)
+    def do_classdef (self, st, ctx) :
+        """classdef: 'class' NAME ['(' [arglist] ')'] ':' suite
+        -> ast.ClassDef
+
+        <<< class c : pass
+        "Module(body=[ClassDef(name='c', bases=[], keywords=[], starargs=None, kwargs=None, body=[Pass()], decorator_list=[])])"
+        <<< class c () : pass
+        "Module(body=[ClassDef(name='c', bases=[], keywords=[], starargs=None, kwargs=None, body=[Pass()], decorator_list=[])])"
+        <<< class c (object, foo=bar) : pass
+        "Module(body=[ClassDef(name='c', bases=[Name(id='object', ctx=Load())], keywords=[keyword(arg='foo', value=Name(id='bar', ctx=Load()))], starargs=None, kwargs=None, body=[Pass()], decorator_list=[])])"
+        """
+        if len(st) <= 6 :
+            return self.ST.ClassDef(lineno=st.srow, col_offset=st.scol,
+                                    name=st[1].text,
+                                    bases=[],
+                                    keywords=[],
+                                    starargs=None,
+                                    kwargs=None,
+                                    body=self.do(st[-1], ctx),
+                                    decorator_list=[])
+        else :
+            args, keywords, starargs, kwargs = self.do(st[3], ctx)
+            return self.ST.ClassDef(lineno=st.srow, col_offset=st.scol,
+                                    name=st[1].text,
+                                    bases=args,
+                                    keywords=keywords,
+                                    starargs=starargs,
+                                    kwargs=kwargs,
+                                    body=self.do(st[-1], ctx),
+                                    decorator_list=[])
+    def do_arglist (self, st, ctx) :
+        """arglist: (argument ',')* (argument [',']
+                         |'*' test (',' argument)* [',' '**' test]
+                         |'**' test)
+        -> args=ast.AST*, keywords=ast.keyword*, starargs=ast.AST?, kwargs=ast.AST?
+
+        <<< f(x)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[Name(id='x', ctx=Load())], keywords=[], starargs=None, kwargs=None))])"
+        <<< f(x, *l, y=2)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[Name(id='x', ctx=Load())], keywords=[keyword(arg='y', value=Num(n=2))], starargs=Name(id='l', ctx=Load()), kwargs=None))])"
+        <<< f(x, *l, y=2, **d)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[Name(id='x', ctx=Load())], keywords=[keyword(arg='y', value=Num(n=2))], starargs=Name(id='l', ctx=Load()), kwargs=Name(id='d', ctx=Load())))])"
+        <<< f(*l)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[], keywords=[], starargs=Name(id='l', ctx=Load()), kwargs=None))])"
+        <<< f(**d)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[], keywords=[], starargs=None, kwargs=Name(id='d', ctx=Load())))])"
+        <<< f(x=1, y=2, x=3)
+        Traceback (most recent call last):
+          ...
+        ParseError: ... keyword argument repeated
+        """
+        args = []
+        keywords = []
+        allkw = set()
+        starargs = None
+        kwargs = None
+        nodes = [n for n in st if n.text != ","]
+        while nodes :
+            if nodes[0].text == "*" :
+                starargs = self.do(nodes[1], ctx)
+                del nodes[:2]
+            elif nodes[0].text == "**" :
+                kwargs = self.do(nodes[1], ctx)
+                del nodes[:2]
+            else :
+                arg = self.do(nodes[0], ctx)
+                if isinstance(arg, self.ST.keyword) :
+                    if arg.arg in allkw :
+                        raise ParseError(nodes[0].text,
+                                         reason="keyword argument repeated")
+                    keywords.append(arg)
+                    allkw.add(arg.arg)
+                elif starargs is not None :
+                    raise ParseError(nodes[0].text, reason="only named"
+                                     " arguments may follow *expression")
+                else :
+                    args.append(arg)
+                del nodes[0]
+        return args, keywords, starargs, kwargs
+    def do_argument (self, st, ctx) :
+        """argument: test [comp_for] | test '=' test
+        -> ast.keyword | ast.GeneratorExp
+
+        <<< f(x)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[Name(id='x', ctx=Load())], keywords=[], starargs=None, kwargs=None))])"
+        <<< f(x=1)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[], keywords=[keyword(arg='x', value=Num(n=1))], starargs=None, kwargs=None))])"
+        <<< f(x for x in l)
+        "Module(body=[Expr(value=Call(func=Name(id='f', ctx=Load()), args=[GeneratorExp(elt=Name(id='x', ctx=Load()), generators=[comprehension(target=Name(id='x', ctx=Store()), iter=Name(id='l', ctx=Load()), ifs=[])])], keywords=[], starargs=None, kwargs=None))])"
+        """
+        test = self.do(st[0], ctx)
+        if len(st) == 1 :
+            return test
+        elif len(st) == 3 :
+            if not isinstance(test, self.ST.Name) :
+                raise ParseError(st[0].text, reason="keyword can't be an"
+                                 " expression")
+            return self.ST.keyword(lineno=st.srow, col_offset=st.scol,
+                                   arg=test.id,
+                                   value=self.do(st[2], ctx))
+        else :
+            comp, ifs = self.do(st[1], ctx)
+            return self.ST.GeneratorExp(lineno=st.srow, col_offset=st.scol,
+                                        elt=test, generators=comp)
+    def do_comp_iter (self, st, ctx) :
+        """comp_iter: comp_for | comp_if
+        -> comprehension*, ast.AST*
+
+        <<< [a for b in c if d if e for f in g if h]
+        "Module(body=[Expr(value=ListComp(elt=Name(id='a', ctx=Load()), generators=[comprehension(target=Name(id='b', ctx=Store()), iter=Name(id='c', ctx=Load()), ifs=[Name(id='d', ctx=Load()), Name(id='e', ctx=Load())]), comprehension(target=Name(id='f', ctx=Store()), iter=Name(id='g', ctx=Load()), ifs=[Name(id='h', ctx=Load())])]))])"
+        """
+        return self.do(st[0], ctx)
+    def do_comp_for (self, st, ctx) :
+        """comp_for: 'for' exprlist 'in' or_test [comp_iter]
+        -> comprehension+, []
+
+        <<< [a for b in c if d if e for f in g if h]
+        "Module(body=[Expr(value=ListComp(elt=Name(id='a', ctx=Load()), generators=[comprehension(target=Name(id='b', ctx=Store()), iter=Name(id='c', ctx=Load()), ifs=[Name(id='d', ctx=Load()), Name(id='e', ctx=Load())]), comprehension(target=Name(id='f', ctx=Store()), iter=Name(id='g', ctx=Load()), ifs=[Name(id='h', ctx=Load())])]))])"
+        """
+        if len(st) == 4 :
+            return [self.ST.comprehension(lineno=st.srow,
+                                          col_offset=st.scol,
+                                          target=self.do(st[1], ast.Store),
+                                          iter=self.do(st[3], ctx),
+                                          ifs=[])], []
+        else :
+            comp, ifs = self.do(st[4], ctx)
+            return [self.ST.comprehension(lineno=st.srow,
+                                          col_offset=st.scol,
+                                          target=self.do(st[1], ast.Store),
+                                          iter=self.do(st[3], ctx),
+                                          ifs=ifs)] + comp, []
+    def do_comp_if (self, st, ctx) :
+        """comp_if: 'if' test_nocond [comp_iter]
+        -> comprehension*, ast.AST+
+
+        <<< [a for b in c if d if e for f in g if h]
+        "Module(body=[Expr(value=ListComp(elt=Name(id='a', ctx=Load()), generators=[comprehension(target=Name(id='b', ctx=Store()), iter=Name(id='c', ctx=Load()), ifs=[Name(id='d', ctx=Load()), Name(id='e', ctx=Load())]), comprehension(target=Name(id='f', ctx=Store()), iter=Name(id='g', ctx=Load()), ifs=[Name(id='h', ctx=Load())])]))])"
+        """
+        if len(st) == 2 :
+            return [], [self.do(st[1], ctx)]
+        else :
+            comp, ifs = self.do(st[2], ctx)
+            return comp, [self.do(st[1], ctx)] + ifs
+    def do_yield_expr (self, st, ctx) :
+        """yield_expr: 'yield' [testlist]
+        -> ast.Yield
+
+        <<< yield
+        'Module(body=[Expr(value=Yield(value=None))])'
+        <<< yield 42
+        'Module(body=[Expr(value=Yield(value=Num(n=42)))])'
+        <<< yield 42, 43
+        'Module(body=[Expr(value=Yield(value=Tuple(elts=[Num(n=42), Num(n=43)], ctx=Load())))])'
+        """
+        if len(st) == 2 :
+            return self.ST.Yield(lineno=st.srow, col_offset=st.scol,
+                                 value=self.do(st[1], ctx))
+        else :
+            return self.ST.Yield(lineno=st.srow, col_offset=st.scol,
+                                 value=None)
+    @classmethod
+    def parse (cls, expr, mode="exec", filename="<string>") :
+        tree = cls(cls.parser.parseString(expr.strip() + "\n",
+                                          filename=filename)).ast
+        if mode == "exec" :
+            return tree
+        elif mode == "eval" :
+            if len(tree.body) > 1 or not isinstance(tree.body[0], cls.ST.Expr) :
+                raise ParseError(None, reason="invalid syntax")
+            return cls.ST.Expression(body=tree.body[0].value)
+        elif mode == "single" :
+            return cls.ST.Interactive(body=tree.body)
+        else :
+            raise ValueError("arg 2 must be 'exec', 'eval' or 'single'")
+
+parse = Translator.parse
+
+class ParseTestParser (doctest.DocTestParser) :
+    _EXAMPLE_RE = re.compile(r'''
+        # Source consists of a PS1 line followed by zero or more PS2 lines.
+        (?P<source>
+            (?:^(?P<indent> [ ]*) <<<    .*)    # PS1 line
+            (?:\n           [ ]*  \.\.\. .*)*)  # PS2 lines
+        \n?
+        # Want consists of any non-blank lines that do not start with PS1.
+        (?P<want> (?:(?![ ]*$)    # Not a blank line
+                     (?![ ]*<<<)  # Not a line starting with PS1
+                     .*$\n?       # But any other line
+                  )*)
+        ''', re.MULTILINE | re.VERBOSE)
+    def __init__ (self, translator) :
+        self.Translator = translator
+    def parse (self, string, name="<string>") :
+        examples = doctest.DocTestParser.parse(self, string, name)
+        try :
+            rule = name.split(".do_", 1)[1]
+        except :
+            rule = None
+        for i, exple in enumerate(examples) :
+            if isinstance(exple, str) :
+                continue
+            elif name.split(".")[1] not in self.Translator.__dict__ :
+                examples[i] = ("skipping example for another language: %r"
+                               % exple.source)
+                continue
+            if rule is not None :
+                source = exple.source.strip() + "\n"
+                try :
+                    tree = self.Translator.ParseTree(self.Translator.parser.parseString(source))
+                except :
+                    print("could not parse %r at %s:%s" % (source, name,
+                                                           exple.lineno))
+                    raise
+                if not tree.involve(self.Translator.parser.stringMap[rule]) :
+                    print(("test at %s:%s does not involve rule %s"
+                           % (name, exple.lineno, rule)))
+                    examples[i] = "<test skipped>"
+                    continue
+            examples[i] = doctest.Example(
+                source=("ast.dump(parse(%r))") % exple.source,
+                want=exple.want,
+                exc_msg=exple.exc_msg,
+                lineno=exple.lineno,
+                indent=exple.indent,
+                options=exple.options)
+        return examples
+
+def testparser (translator) :
+    for rule in translator.parser.stringMap :
+        try :
+            assert "<<<" in getattr(translator, "do_" + rule).__doc__
+        except AttributeError :
+            print("no handler for rule %r" % rule)
+            continue
+        except TypeError :
+            print("missing doc for rule %r" % rule)
+            continue
+        except AssertionError :
+            print("missing test for rule %r" % rule)
+            continue
+    finder = doctest.DocTestFinder(parser=ParseTestParser(translator))
+    runner = doctest.DocTestRunner(optionflags=doctest.NORMALIZE_WHITESPACE
+                                   | doctest.ELLIPSIS)
+    for name, method in inspect.getmembers(translator, inspect.ismethod) :
+        if not name.startswith("do_") :
+            continue
+        for test in finder.find(method, "%s.%s" % (translator.__name__, name)) :
+            runner.run(test)
+    runner.summarize()
+
+if __name__ == "__main__" :
+    testparser(Translator)

+module Python version "$Revision: SNAKES $"
+{
+	mod = Module(stmt* body)
+	    | Interactive(stmt* body)
+	    | Expression(expr body)
+	    | Suite(stmt* body)
+
+	stmt = FunctionDef(identifier name, arguments args, 
+                           stmt* body, expr* decorator_list, expr? returns)
+	      | ClassDef(identifier name, 
+			 expr* bases,
+			 keyword* keywords,
+			 expr? starargs,
+			 expr? kwargs,
+			 stmt* body,
+			 expr *decorator_list)
+	      | Return(expr? value)
+
+	      | Delete(expr* targets)
+	      | Assign(expr* targets, expr value)
+	      | AugAssign(expr target, operator op, expr value)
+
+	      | For(expr target, expr iter, stmt* body, stmt* orelse)
+	      | While(expr test, stmt* body, stmt* orelse)
+	      | If(expr test, stmt* body, stmt* orelse)
+	      | With(expr context_expr, expr? optional_vars, stmt* body)
+
+	      | Raise(expr? exc, expr? cause)
+	      | TryExcept(stmt* body, excepthandler* handlers, stmt* orelse)
+	      | TryFinally(stmt* body, stmt* finalbody)
+	      | Assert(expr test, expr? msg)
+
+	      | Import(alias* names)
+	      | ImportFrom(identifier module, alias* names, int? level)
+
+	      | Exec(expr body, expr? globals, expr? locals)
+
+	      | Global(identifier* names)
+	      | Nonlocal(identifier* names)
+	      | Expr(expr value)
+	      | Pass | Break | Continue
+
+	      attributes (int lineno, int col_offset)
+
+	expr = BoolOp(boolop op, expr* values)
+	     | BinOp(expr left, operator op, expr right)
+	     | UnaryOp(unaryop op, expr operand)
+	     | Lambda(arguments args, expr body)
+	     | IfExp(expr test, expr body, expr orelse)
+	     | Dict(expr* keys, expr* values)
+	     | Set(expr* elts)
+	     | ListComp(expr elt, comprehension* generators)
+	     | SetComp(expr elt, comprehension* generators)
+	     | DictComp(expr key, expr value, comprehension* generators)
+	     | GeneratorExp(expr elt, comprehension* generators)
+	     | Yield(expr? value)
+	     | Compare(expr left, cmpop* ops, expr* comparators)
+	     | Call(expr func, expr* args, keyword* keywords,
+			 expr? starargs, expr? kwargs)
+	     | Num(object n)
+	     | Str(string s)
+	     | Ellipsis
+
+	     | Attribute(expr value, identifier attr, expr_context ctx)
+	     | Subscript(expr value, slice slice, expr_context ctx)
+	     | Starred(expr value, expr_context ctx)
+	     | Name(identifier id, expr_context ctx)
+	     | List(expr* elts, expr_context ctx) 
+	     | Tuple(expr* elts, expr_context ctx)
+
+	      attributes (int lineno, int col_offset)
+
+	expr_context = Load | Store | Del | AugLoad | AugStore | Param
+
+	slice = Slice(expr? lower, expr? upper, expr? step) 
+	      | ExtSlice(slice* dims) 
+	      | Index(expr value) 
+
+	boolop = And | Or 
+
+	operator = Add | Sub | Mult | Div | Mod | Pow | LShift 
+                 | RShift | BitOr | BitXor | BitAnd | FloorDiv
+
+	unaryop = Invert | Not | UAdd | USub
+
+	cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn
+
+	comprehension = (expr target, expr iter, expr* ifs)
+
+	excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)
+	                attributes (int lineno, int col_offset)
+
+	arguments = (arg* args, identifier? vararg, expr? varargannotation,
+                     arg* kwonlyargs, identifier? kwarg,
+                     expr? kwargannotation, expr* defaults,
+                     expr* kw_defaults)
+	arg = (identifier arg, expr? annotation)
+
+        keyword = (identifier arg, expr value)
+
+        alias = (identifier name, identifier? asname)
+}

+# Grammar for Python in SNAKES
+# This is a mixture of the grammars from various Python versions
+
+$ELLIPSIS '...'
+
+file_input: (NEWLINE | stmt)* ENDMARKER
+
+decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
+decorators: decorator+
+decorated: decorators (classdef | funcdef)
+funcdef: 'def' NAME parameters ['-' '>' test] ':' suite
+parameters: '(' [typedargslist] ')'
+typedargslist: ((tfpdef ['=' test] ',')*
+                ('*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef]
+                 | '**' tfpdef)
+                | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
+tfpdef: NAME [':' test]
+varargslist: ((vfpdef ['=' test] ',')*
+              ('*' [vfpdef] (',' vfpdef ['=' test])*  [',' '**' vfpdef]
+               | '**' vfpdef)
+              | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
+vfpdef: NAME
+
+stmt: simple_stmt | compound_stmt
+simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
+small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt |
+             import_stmt | global_stmt | nonlocal_stmt | assert_stmt)
+expr_stmt: testlist (augassign (yield_expr|testlist) |
+                     ('=' (yield_expr|testlist))*)
+augassign: ('+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' |
+            '<<=' | '>>=' | '**=' | '//=')
+del_stmt: 'del' exprlist
+pass_stmt: 'pass'
+flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
+break_stmt: 'break'
+continue_stmt: 'continue'
+return_stmt: 'return' [testlist]
+yield_stmt: yield_expr
+raise_stmt: 'raise' [test ['from' test]]
+import_stmt: import_name | import_from
+import_name: 'import' dotted_as_names
+import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+)
+              'import' ('*' | '(' import_as_names ')' | import_as_names))
+import_as_name: NAME ['as' NAME]
+dotted_as_name: dotted_name ['as' NAME]
+import_as_names: import_as_name (',' import_as_name)* [',']
+dotted_as_names: dotted_as_name (',' dotted_as_name)*
+dotted_name: NAME ('.' NAME)*
+global_stmt: 'global' NAME (',' NAME)*
+nonlocal_stmt: 'nonlocal' NAME (',' NAME)*
+assert_stmt: 'assert' test [',' test]
+
+compound_stmt: (if_stmt | while_stmt | for_stmt | try_stmt | with_stmt
+                | funcdef | classdef | decorated)
+if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
+while_stmt: 'while' test ':' suite ['else' ':' suite]
+for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+try_stmt: ('try' ':' suite
+           ((except_clause ':' suite)+
+	    ['else' ':' suite]
+	    ['finally' ':' suite] |
+	   'finally' ':' suite))
+with_stmt: 'with' test [ with_var ] ':' suite
+with_var: 'as' expr
+except_clause: 'except' [test ['as' NAME]]
+suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
+
+test: or_test ['if' or_test 'else' test] | lambdef
+test_nocond: or_test | lambdef_nocond
+lambdef: 'lambda' [varargslist] ':' test
+lambdef_nocond: 'lambda' [varargslist] ':' test_nocond
+or_test: and_test ('or' and_test)*
+and_test: not_test ('and' not_test)*
+not_test: 'not' not_test | comparison
+comparison: star_expr (comp_op star_expr)*
+comp_op: '<'|'>'|'=='|'>='|'<='|'!='|'<>'|'in'|'not' 'in'|'is'|'is' 'not'
+star_expr: ['*'] expr
+expr: xor_expr ('|' xor_expr)*
+xor_expr: and_expr ('^' and_expr)*
+and_expr: shift_expr ('&' shift_expr)*
+shift_expr: arith_expr (('<<'|'>>') arith_expr)*
+arith_expr: term (('+'|'-') term)*
+term: factor (('*'|'/'|'%'|'//') factor)*
+factor: ('+'|'-'|'~') factor | power
+power: atom trailer* ['**' factor]
+atom: ('(' [yield_expr|testlist_comp] ')' |
+       '[' [testlist_comp] ']' |
+       '{' [dictorsetmaker] '}' |
+       NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False')
+testlist_comp: test ( comp_for | (',' test)* [','] )
+trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
+subscriptlist: subscript (',' subscript)* [',']
+subscript: test | [test] ':' [test] [sliceop]
+sliceop: ':' [test]
+exprlist: star_expr (',' star_expr)* [',']
+testlist: test (',' test)* [',']
+dictorsetmaker: ( (test ':' test (comp_for | (',' test ':' test)* [','])) |
+                  (test (comp_for | (',' test)* [','])) )
+
+classdef: 'class' NAME ['(' [arglist] ')'] ':' suite
+
+arglist: (argument ',')* (argument [',']
+                         |'*' test (',' argument)* [',' '**' test] 
+                         |'**' test)
+argument: test [comp_for] | test '=' test
+
+comp_iter: comp_for | comp_if
+comp_for: 'for' exprlist 'in' or_test [comp_iter]
+comp_if: 'if' test_nocond [comp_iter]
+
+yield_expr: 'yield' [testlist]

+"Usage: unparse.py <path to source file>"
+import sys
+import _ast
+from snakes.compat import *
+
+def interleave(inter, f, seq):
+    """Call f on each item in seq, calling inter() in between.
+    """
+    seq = iter(seq)
+    try:
+        f(next(seq))
+    except StopIteration:
+        pass
+    else:
+        for x in seq:
+            inter()
+            f(x)
+
+class Unparser:
+    """Methods in this class recursively traverse an AST and
+    output source code for the abstract syntax; original formatting
+    is disregarged. """
+
+    def __init__(self, tree, file = sys.stdout):
+        """Unparser(tree, file=sys.stdout) -> None.
+         Print the source for tree to file."""
+        self.f = file
+        self._indent = 0
+        self.dispatch(tree)
+        self.f.write("\n")
+        self.f.flush()
+
+    def fill(self, text = ""):
+        "Indent a piece of text, according to the current indentation level"
+        self.f.write("\n" + "    "*self._indent + text)
+
+    def write(self, text):
+        "Append a piece of text to the current line."
+        self.f.write(text)
+
+    def enter(self):
+        "Print ':', and increase the indentation."
+        self.write(":")
+        self._indent += 1
+
+    def leave(self):
+        "Decrease the indentation level."
+        self._indent -= 1
+
+    def dispatch(self, tree):
+        "Dispatcher function, dispatching tree type T to method _T."
+        if isinstance(tree, list):
+            for t in tree:
+                self.dispatch(t)
+            return
+        meth = getattr(self, "_"+tree.__class__.__name__)
+        meth(tree)
+
+
+    ############### Unparsing methods ######################
+    # There should be one method per concrete grammar type #
+    # Constructors should be grouped by sum type. Ideally, #
+    # this would follow the order in the grammar, but      #
+    # currently doesn't.                                   #
+    ########################################################
+
+    def _Module(self, tree):
+        for stmt in tree.body:
+            self.dispatch(stmt)
+
+    # stmt
+    def _Expr(self, tree):
+        self.fill()
+        self.dispatch(tree.value)
+
+    def _Import(self, t):
+        self.fill("import ")
+        interleave(lambda: self.write(", "), self.dispatch, t.names)
+
+    def _ImportFrom(self, t):
+        self.fill("from ")
+        self.write(t.module)
+        self.write(" import ")
+        interleave(lambda: self.write(", "), self.dispatch, t.names)
+        # XXX(jpe) what is level for?
+
+    def _Assign(self, t):
+        self.fill()
+        for target in t.targets:
+            self.dispatch(target)
+            self.write(" = ")
+        self.dispatch(t.value)
+
+    def _AugAssign(self, t):
+        self.fill()
+        self.dispatch(t.target)
+        self.write(" "+self.binop[t.op.__class__.__name__]+"= ")
+        self.dispatch(t.value)
+
+    def _Return(self, t):
+        self.fill("return")
+        if t.value:
+            self.write(" ")
+            self.dispatch(t.value)
+
+    def _Pass(self, t):
+        self.fill("pass")
+
+    def _Break(self, t):
+        self.fill("break")
+
+    def _Continue(self, t):
+        self.fill("continue")
+
+    def _Delete(self, t):
+        self.fill("del ")
+        self.dispatch(t.targets)
+
+    def _Assert(self, t):
+        self.fill("assert ")
+        self.dispatch(t.test)
+        if t.msg:
+            self.write(", ")
+            self.dispatch(t.msg)
+
+    def _Exec(self, t):
+        self.fill("exec ")
+        self.dispatch(t.body)
+        if t.globals:
+            self.write(" in ")
+            self.dispatch(t.globals)
+        if t.locals:
+            self.write(", ")
+            self.dispatch(t.locals)
+
+    def _Print(self, t):
+        self.fill("print ")
+        do_comma = False
+        if t.dest:
+            self.write(">>")
+            self.dispatch(t.dest)
+            do_comma = True
+        for e in t.values:
+            if do_comma:self.write(", ")
+            else:do_comma=True
+            self.dispatch(e)
+        if not t.nl:
+            self.write(",")
+
+    def _Global(self, t):
+        self.fill("global ")
+        interleave(lambda: self.write(", "), self.write, t.names)
+
+    def _Yield(self, t):
+        self.write("(")
+        self.write("yield")
+        if t.value:
+            self.write(" ")
+            self.dispatch(t.value)
+        self.write(")")
+
+    def _Raise(self, t):
+        self.fill('raise ')
+        if t.type:
+            self.dispatch(t.type)
+        if t.inst:
+            self.write(", ")
+            self.dispatch(t.inst)
+        if t.tback:
+            self.write(", ")
+            self.dispatch(t.tback)
+
+    def _TryExcept(self, t):
+        self.fill("try")
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+        for ex in t.handlers:
+            self.dispatch(ex)
+        if t.orelse:
+            self.fill("else")
+            self.enter()
+            self.dispatch(t.orelse)
+            self.leave()
+
+    def _TryFinally(self, t):
+        self.fill("try")
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+        self.fill("finally")
+        self.enter()
+        self.dispatch(t.finalbody)
+        self.leave()
+
+    def _ExceptHandler(self, t):
+        self.fill("except")
+        if t.type:
+            self.write(" ")
+            self.dispatch(t.type)
+        if t.name:
+            self.write(", ")
+            self.dispatch(t.name)
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+    def _ClassDef(self, t):
+        self.write("\n")
+        self.fill("class "+t.name)
+        if t.bases:
+            self.write("(")
+            for a in t.bases:
+                self.dispatch(a)
+                self.write(", ")
+            self.write(")")
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+    def _FunctionDef(self, t):
+        self.write("\n")
+        for deco in t.decorator_list:
+            self.fill("@")
+            self.dispatch(deco)
+        self.fill("def "+t.name + "(")
+        self.dispatch(t.args)
+        self.write(")")
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+    def _For(self, t):
+        self.fill("for ")
+        self.dispatch(t.target)
+        self.write(" in ")
+        self.dispatch(t.iter)
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+        if t.orelse:
+            self.fill("else")
+            self.enter()
+            self.dispatch(t.orelse)
+            self.leave
+
+    def _If(self, t):
+        self.fill("if ")
+        self.dispatch(t.test)
+        self.enter()
+        # XXX elif?
+        self.dispatch(t.body)
+        self.leave()
+        if t.orelse:
+            self.fill("else")
+            self.enter()
+            self.dispatch(t.orelse)
+            self.leave()
+
+    def _While(self, t):
+        self.fill("while ")
+        self.dispatch(t.test)
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+        if t.orelse:
+            self.fill("else")
+            self.enter()
+            self.dispatch(t.orelse)
+            self.leave
+
+    def _With(self, t):
+        self.fill("with ")
+        self.dispatch(t.context_expr)
+        if t.optional_vars:
+            self.write(" as ")
+            self.dispatch(t.optional_vars)
+        self.enter()
+        self.dispatch(t.body)
+        self.leave()
+
+    # expr
+    def _Str(self, tree):
+        self.write(repr(tree.s))
+
+    def _Name(self, t):
+        self.write(t.id)
+
+    def _Repr(self, t):
+        self.write("`")
+        self.dispatch(t.value)
+        self.write("`")
+
+    def _Num(self, t):
+        self.write(repr(t.n))
+
+    def _List(self, t):
+        self.write("[")
+        interleave(lambda: self.write(", "), self.dispatch, t.elts)
+        self.write("]")
+
+    def _ListComp(self, t):
+        self.write("[")
+        self.dispatch(t.elt)
+        for gen in t.generators:
+            self.dispatch(gen)
+        self.write("]")
+
+    def _GeneratorExp(self, t):
+        self.write("(")
+        self.dispatch(t.elt)
+        for gen in t.generators:
+            self.dispatch(gen)
+        self.write(")")
+
+    def _comprehension(self, t):
+        self.write(" for ")
+        self.dispatch(t.target)
+        self.write(" in ")
+        self.dispatch(t.iter)
+        for if_clause in t.ifs:
+            self.write(" if ")
+            self.dispatch(if_clause)
+
+    def _IfExp(self, t):
+        self.write("(")
+        self.dispatch(t.body)
+        self.write(" if ")
+        self.dispatch(t.test)
+        self.write(" else ")
+        self.dispatch(t.orelse)
+        self.write(")")
+
+    def _Dict(self, t):
+        self.write("{")
+        def writem(arg):
+            (k, v) = arg
+            self.dispatch(k)
+            self.write(": ")
+            self.dispatch(v)
+        interleave(lambda: self.write(", "), writem, zip(t.keys, t.values))
+        self.write("}")
+
+    def _Set(self, t) :
+        self.write("set([")
+        if len(t.elts) == 1:
+            (elt,) = t.elts
+            self.dispatch(elt)
+            self.write(",")
+        else:
+            interleave(lambda: self.write(", "), self.dispatch, t.elts)
+        self.write("])")
+
+    def _Tuple(self, t):
+        self.write("(")
+        if len(t.elts) == 1:
+            (elt,) = t.elts
+            self.dispatch(elt)
+            self.write(",")
+        else:
+            interleave(lambda: self.write(", "), self.dispatch, t.elts)
+        self.write(")")
+
+    unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"}
+    def _UnaryOp(self, t):
+        self.write(self.unop[t.op.__class__.__name__])
+        self.write("(")
+        self.dispatch(t.operand)
+        self.write(")")
+
+    binop = { "Add":"+", "Sub":"-", "Mult":"*", "Div":"/", "Mod":"%",
+              "LShift":">>", "RShift":"<<", "BitOr":"|", "BitXor":"^", "BitAnd":"&",
+              "FloorDiv":"//", "Pow": "**"}
+    def _BinOp(self, t):
+        self.write("(")
+        self.dispatch(t.left)
+        self.write(" " + self.binop[t.op.__class__.__name__] + " ")
+        self.dispatch(t.right)
+        self.write(")")
+
+    cmpops = {"Eq":"==", "NotEq":"!=", "Lt":"<", "LtE":"<=", "Gt":">", "GtE":">=",
+              "Is":"is", "IsNot":"is not", "In":"in", "NotIn":"not in"}
+    def _Compare(self, t):
+        self.write("(")
+        self.dispatch(t.left)
+        for o, e in zip(t.ops, t.comparators):
+            self.write(" " + self.cmpops[o.__class__.__name__] + " ")
+            self.dispatch(e)
+        self.write(")")
+
+    boolops = {"And": 'and', "Or": 'or'}
+    def _BoolOp(self, t):
+        self.write("(")
+        s = " %s " % self.boolops[t.op.__class__.__name__]
+        interleave(lambda: self.write(s), self.dispatch, t.values)
+        self.write(")")
+
+    def _Attribute(self,t):
+        self.dispatch(t.value)
+        self.write(".")
+        self.write(t.attr)
+
+    def _Call(self, t):
+        self.dispatch(t.func)
+        self.write("(")
+        comma = False
+        for e in t.args:
+            if comma: self.write(", ")
+            else: comma = True
+            self.dispatch(e)
+        for e in t.keywords:
+            if comma: self.write(", ")
+            else: comma = True
+            self.dispatch(e)
+        if t.starargs:
+            if comma: self.write(", ")
+            else: comma = True
+            self.write("*")
+            self.dispatch(t.starargs)
+        if t.kwargs:
+            if comma: self.write(", ")
+            else: comma = True
+            self.write("**")
+            self.dispatch(t.kwargs)
+        self.write(")")
+
+    def _Subscript(self, t):
+        self.dispatch(t.value)
+        self.write("[")
+        self.dispatch(t.slice)
+        self.write("]")
+
+    # slice
+    def _Ellipsis(self, t):
+        self.write("...")
+
+    def _Index(self, t):
+        self.dispatch(t.value)
+
+    def _Slice(self, t):
+        if t.lower:
+            self.dispatch(t.lower)
+        self.write(":")
+        if t.upper:
+            self.dispatch(t.upper)
+        if t.step:
+            self.write(":")
+            self.dispatch(t.step)
+
+    def _ExtSlice(self, t):
+        interleave(lambda: self.write(', '), self.dispatch, t.dims)
+
+    # others
+    def _arguments(self, t):
+        first = True
+        nonDef = len(t.args)-len(t.defaults)
+        for a in t.args[0:nonDef]:
+            if first:first = False
+            else: self.write(", ")
+            self.dispatch(a)
+        for a,d in zip(t.args[nonDef:], t.defaults):
+            if first:first = False
+            else: self.write(", ")
+            self.dispatch(a),
+            self.write("=")
+            self.dispatch(d)
+        if t.vararg:
+            if first:first = False
+            else: self.write(", ")
+            self.write("*"+t.vararg)
+        if t.kwarg:
+            if first:first = False
+            else: self.write(", ")
+            self.write("**"+t.kwarg)
+
+    def _keyword(self, t):
+        self.write(t.arg)
+        self.write("=")
+        self.dispatch(t.value)
+
+    def _Lambda(self, t):
+        self.write("lambda ")
+        self.dispatch(t.args)
+        self.write(": ")
+        self.dispatch(t.body)
+
+    def _alias(self, t):
+        self.write(t.name)
+        if t.asname:
+            self.write(" as "+t.asname)
+
+def roundtrip(filename, output=sys.stdout):
+    source = open(filename).read()
+    tree = compile(source, filename, "exec", _ast.PyCF_ONLY_AST)
+    Unparser(tree, output)
+
+
+
+def testdir(a):
+    try:
+        names = [n for n in os.listdir(a) if n.endswith('.py')]
+    except OSError:
+        sys.stderr.write("Directory not readable: %s\n" % a)
+    else:
+        for n in names:
+            fullname = os.path.join(a, n)
+            if os.path.isfile(fullname):
+                output = io.StringIO()
+                print('Testing %s' % fullname)
+                try:
+                    roundtrip(fullname, output)
+                except Exception:
+                    e = sys.exc_info()[1]
+                    print('  Failed to compile, exception is %r' % e)
+            elif os.path.isdir(fullname):
+                testdir(fullname)
+
+def main(args):
+    if args[0] == '--testdir':
+        for a in args[1:]:
+            testdir(a)
+    else:
+        for a in args:
+            roundtrip(a)
+
+if __name__=='__main__':
+    main(sys.argv[1:])

+"""A plugins system.
+
+The first example shows how to load a plugin: we load
+C{snakes.plugins.hello} and plug it into C{snakes.nets}, which results
+in a new module that actually C{snakes.nets} extended by
+C{snakes.plugins.hello}.
+
+>>> import snakes.plugins as plugins
+>>> hello_nets = plugins.load('hello', 'snakes.nets')
+>>> n = hello_nets.PetriNet('N')
+>>> n.hello()
+Hello from N
+>>> n = hello_nets.PetriNet('N', hello='Hi, this is %s!')
+>>> n.hello()
+Hi, this is N!
+
+The next example shows how to simulate the effect of C{import module}:
+we give to C{load} a thrid argument that is the name of the created
+module, from which it becomes possible to import names or C{*}.
+
+B{Warning:} this feature will not work C{load} is not called from the
+module where we then do the C{from ... import ...}. This is exactly
+the same when, from a module C{foo} that you load a module C{bar}: if
+C{bar} loads other modules they will not be imported in C{foo}.
+
+>>> plugins.load('hello', 'snakes.nets', 'another_version')
+<module ...>
+>>> from another_version import PetriNet
+>>> n = PetriNet('another net')
+>>> n.hello()
+Hello from another net
+>>> n = PetriNet('yet another net', hello='Hi, this is %s!')
+>>> n.hello()
+Hi, this is yet another net!
+
+How to define a plugin is explained in the example C{hello}.
+"""
+
+import imp, sys, inspect
+from functools import wraps
+
+def update (module, objects) :
+    """Update a module content
+    """
+    for obj in objects :
+        if isinstance(obj, tuple) :
+            try :
+                n, o = obj
+            except :
+                raise ValueError("expected (name, object) and got '%r'" % obj)
+            setattr(module, n, o)
+        elif inspect.isclass(obj) or inspect.isfunction(obj) :
+            setattr(module, obj.__name__, obj)
+        else :
+            raise ValueError("cannot plug '%r'" % obj)
+
+def build (name, module, *objects) :
+    """Builds an extended module.
+
+    The parameter C{module} is exactly that taken by the function
+    C{extend} of a plugin. This list argument C{objects} holds all the
+    objects, constructed in C{extend}, that are extensions of objects
+    from C{module}. The resulting value should be returned by
+    C{extend}.
+
+    @param name: the name of the constructed module
+    @type name: C{str}
+    @param module: the extended module
+    @type module: C{module}
+    @param objects: the sub-objects
+    @type objects: each is a class object
+    @return: the new module
+    @rtype: C{module}
+    """
+    result = imp.new_module(name)
+    result.__dict__.update(module.__dict__)
+    update(result, objects)
+    result.__plugins__ = (module.__dict__.get("__plugins__",
+                                              (module.__name__,))
+                          + (name,))
+    for obj in objects :
+        if inspect.isclass(obj) :
+            obj.__plugins__ = result.__plugins__
+    return result
+
+def load (plugins, base, name=None) :
+    """Load plugins.
+
+    C{plugins} can be a single plugin name or module or a list of such
+    values. If C{name} is not C{None}, the extended module is loaded
+    ad C{name} in C{sys.modules} as well as in the global environment
+    from which C{load} was called.
+
+    @param plugins: the module that implements the plugin, or its name,
+      or a collection of such values
+    @type plugins: C{str} or C{module}, or a C{list}/C{tuple}/... of
+      such values
+    @param base: the module being extended or its name
+    @type base: C{str} or C{module}
+    @param name: the name of the created module
+    @type name: C{str}
+    @return: the extended module
+    @rtype: C{module}
+    """
+    if type(base) is str :
+        result = __import__(base, fromlist=["__name__"])
+    else :
+        result = base
+    if isinstance(plugins, str) :
+        plugins = [plugins]
+    else :
+        try :
+            plugins = list(plugins)
+        except TypeError :
+            plugins = [plugins]
+    for i, p in enumerate(plugins) :
+        if isinstance(p, str) and not p.startswith("snakes.plugins.") :
+            plugins[i] = "snakes.plugins." + p
+    for plug in plugins :
+        if type(plug) is str :
+            plug = __import__(plug, fromlist=["__name__"])
+        result = plug.extend(result)
+    if name is not None :
+        result.__name__ = name
+        sys.modules[name] = result
+        inspect.stack()[1][0].f_globals[name] = result
+    return result
+
+def plugin (base, depends=[], conflicts=[]) :
+    """Decorator for extension functions
+
+    @param base: name of base module (usually 'snakes.nets')
+    @type base: str
+    @param depends: list of plugins on which this one depends
+    @type depends: list of str
+    @param conflicts: list of plugins with which this one conflicts
+    @type conflicts: list of str
+    @return: the appropriate decorator
+    @rtype: function
+    """
+    def wrapper (fun) :
+        @wraps(fun)
+        def extend (module) :
+            try :
+                loaded = set(module.__plugins__)
+            except AttributeError :
+                loaded = set()
+            for name in depends :
+                if name not in loaded :
+                    module = load(name, module)
+                    loaded.update(module.__plugins__)
+            conf = set(conflicts) & loaded
+            if len(conf) > 0 :
+                raise ValueError("plugin conflict (%s)" % ", ".join(conf))
+            objects = fun(module)
+            if type(objects) is not tuple :
+                objects = (objects,)
+            return build(fun.__module__, module, *objects)
+        module = sys.modules[fun.__module__]
+        module.__test__ = {"extend" : extend}
+        objects = fun(__import__(base, fromlist=["__name__"]))
+        if type(objects) is not tuple :
+            objects = (objects,)
+        update(module, objects)
+        return extend
+    return wrapper
+
+def new_instance (cls, obj) :
+    """Create a copy of C{obj} which is an instance of C{cls}
+    """
+    result = object.__new__(cls)
+    result.__dict__.update(obj.__dict__)
+    return result

+import snakes.plugins
+from snakes.plugins import new_instance
+from snakes.pnml import Tree
+from snakes.data import iterate
+
+class Cluster (object) :
+    def __init__ (self, nodes=[], children=[]) :
+        """
+        >>> Cluster(['a', 'b'],
+        ...         [Cluster(['1', '2'],
+        ...                  [Cluster(['A'])]),
+        ...          Cluster(['3', '4', '5'],
+        ...                  [Cluster(['C', 'D'])])])
+        Cluster(...)
+
+        """
+        self._nodes = set(nodes)
+        self._children = []
+        self._cluster = {}
+        for child in children :
+            self.add_child(child)
+    __pnmltag__ = "clusters"
+    def __pnmldump__ (self) :
+        """
+        >>> Cluster(['a', 'b'],
+        ...         [Cluster(['1', '2'],
+        ...                  [Cluster(['A'])]),
+        ...          Cluster(['3', '4', '5'],
+        ...                  [Cluster(['C', 'D'])])]).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>...
+         <clusters>
+          <node>
+          ...
+          </node>
+          <node>
+          ...
+          </node>
+          <clusters>
+          ...
+          </clusters>
+         </clusters>
+        </pnml>
+        """
+        result = Tree(self.__pnmltag__, None)
+        for node in self._nodes :
+            result.add_child(Tree("node", node))
+        for child in self._children :
+            result.add_child(Tree.from_obj(child))
+        return result
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """
+        >>> t = Cluster(['a', 'b'],
+        ...             [Cluster(['1', '2'],
+        ...                      [Cluster(['A'])]),
+        ...              Cluster(['3', '4', '5'],
+        ...                      [Cluster(['C', 'D'])])]).__pnmldump__()
+        >>> Cluster.__pnmlload__(t)
+        Cluster(['...', '...'],
+                [Cluster(['...', '...'],
+                         [Cluster(['A'], [])]),
+                 Cluster(['...', '...', '...'],
+                         [Cluster(['...', '...'], [])])])
+        """
+
+        result = cls()
+        for child in tree.children :
+            if child.name == "node" :
+                result.add_node(child.data)
+            else :
+                result.add_child(child.to_obj())
+        return result
+    def __str__ (self) :
+        return "cluster_%s" % str(id(self)).replace("-", "m")
+    def __repr__ (self) :
+        """
+        >>> Cluster(['a', 'b'],
+        ...         [Cluster(['1', '2'],
+        ...                  [Cluster(['A'])]),
+        ...          Cluster(['3', '4', '5'],
+        ...                  [Cluster(['C', 'D'])])])
+        Cluster(['...', '...'],
+                [Cluster(['...', '...'],
+                         [Cluster(['A'], [])]),
+                 Cluster(['...', '...', '...'],
+                         [Cluster(['...', '...'], [])])])
+        """
+        return "%s([%s], [%s])" % (self.__class__.__name__,
+                                   ", ".join(repr(n) for n in self.nodes()),
+                                   ", ".join(repr(c) for c in self.children()))
+    def copy (self) :
+        """
+        >>> Cluster(['a', 'b'],
+        ...         [Cluster(['1', '2'],
+        ...                  [Cluster(['A'])]),
+        ...          Cluster(['3', '4', '5'],
+        ...                  [Cluster(['C', 'D'])])]).copy()
+        Cluster(['...', '...'],
+                [Cluster(['...', '...'],
+                         [Cluster(['A'], [])]),
+                 Cluster(['...', '...', '...'],
+                         [Cluster(['...', '...'], [])])])
+        """
+        return self.__class__(self._nodes,
+                              (child.copy() for child in self._children))
+    def get_path (self, name) :
+        """
+        >>> Cluster(['a', 'b'],
+        ...         [Cluster(['1', '2'],
+        ...                  [Cluster(['A'])]),
+        ...          Cluster(['3', '4', '5'],
+        ...                  [Cluster(['C', 'D'])])]).get_path('C')
+        [1, 0]
+        """
+        if name in self._nodes :
+            return []
+        else :
+            for num, child in enumerate(self._children) :
+                if name in child :
+                    return [num] + child.get_path(name)
+    def add_node (self, name, path=None) :
+        """
+        >>> c = Cluster(['a', 'b'],
+        ...             [Cluster(['1', '2'],
+        ...                      [Cluster(['A'])]),
+        ...              Cluster(['3', '4', '5'],
+        ...                      [Cluster(['C', 'D'])])])
+        >>> c.add_node('c')
+        Cluster([...'c'...], ...)
+        >>> c.add_node('E', [1, 0])
+        Cluster([...'E'...], [])
+        >>> c
+        Cluster([...'c'...],
+                [Cluster(['...', '...'],
+                         [Cluster(['A'], [])]),
+                 Cluster(['...', '...', '...'],
+                         [Cluster([...'E'...], [])])])
+        """
+        if path in (None, [], ()) :
+            self._nodes.add(name)
+            return self
+        else :
+            while len(self._children) <= path[0] :
+                self._children.append(self.__class__())
+            target = self._children[path[0]].add_node(name, path[1:])
+            self._cluster[name] = target
+            return target
+    def remove_node (self, name) :
+        """
+        >>> c = Cluster(['a', 'b'],
+        ...             [Cluster(['1', '2'],
+        ...                      [Cluster(['A'])]),
+        ...              Cluster(['3', '4', '5'],
+        ...                      [Cluster(['C', 'D'])])])
+        >>> c.remove_node('4')
+        >>> c
+        Cluster(['...', '...'],
+                [Cluster(['...', '...'],
+                         [Cluster(['A'], [])]),
+                 Cluster(['...', '...'],
+                         [Cluster(['...', '...'], [])])])
+
+        """
+        if name in self._cluster :
+            self._cluster[name].remove_node(name)
+        else :
+            self._nodes.remove(name)
+    def rename_node (self, old, new) :
+        """
+        >>> c = Cluster(['a', 'b'],
+        ...             [Cluster(['1', '2'],
+        ...                      [Cluster(['A'])]),
+        ...              Cluster(['3', '4', '5'],
+        ...                      [Cluster(['C', 'D'])])])
+        >>> c.rename_node('4', '42')
+        >>> c
+        Cluster(['...', '...'],
+                [Cluster(['...', '...'],
+                         [Cluster(['A'], [])]),
+                 Cluster([...'42'...],
+                         [Cluster(['...', '...'], [])])])
+        """
+        if old in self._cluster :
+            self._cluster[old].rename_node(old, new)
+            self._cluster[new] = self._cluster[old]
+            del self._cluster[old]
+        elif old in self._nodes :
+            self._nodes.remove(old)
+            self._nodes.add(new)
+        else :
+            for child in self.children() :
+                child.rename_node(old, new)
+    def add_child (self, cluster=None) :
+        """
+        >>> c = Cluster(['a', 'b'],
+        ...             [Cluster(['1', '2'],
+        ...                      [Cluster(['A'])]),
+        ...              Cluster(['3', '4', '5'],
+        ...                      [Cluster(['C', 'D'])])])
+        >>> c.add_child(c.copy())
+        >>> c
+        Cluster(['...', '...'],
+                [Cluster(['...', '...'],
+                         [Cluster(['A'], [])]),
+                 Cluster(['...', '...', '...'],
+                         [Cluster(['...', '...'], [])]),
+                 Cluster(['...', '...'],
+                         [Cluster(['...', '...'],
+                                  [Cluster(['A'], [])]),
+                          Cluster(['...', '...', '...'],
+                                  [Cluster(['...', '...'], [])])])])
+        """
+        if cluster is None :
+            cluster = Cluster()
+        self._cluster.update(cluster._cluster)
+        for node in cluster._nodes :
+            self._cluster[node] = cluster
+        self._children.append(cluster)
+    def nodes (self, all=False) :
+        """
+        >>> list(sorted(Cluster(['a', 'b'],
+        ...         [Cluster(['1', '2'],
+        ...                  [Cluster(['A'])]),
+        ...          Cluster(['3', '4', '5'],
+        ...                  [Cluster(['C', 'D'])])]).nodes()))
+        ['a', 'b']
+        >>> list(sorted(Cluster(['a', 'b'],
+        ...         [Cluster(['1', '2'],
+        ...                  [Cluster(['A'])]),
+        ...          Cluster(['3', '4', '5'],
+        ...                  [Cluster(['C', 'D'])])]).nodes(True)))
+        ['1', '2', '3', '4', '5', 'A', 'C', 'D', 'a', 'b']
+        """
+        if all :
+            result = set()
+            for cluster in self :
+                result.update(cluster.nodes())
+            return result
+        else :
+            return set(self._nodes)
+    def children (self) :
+        """
+        >>> Cluster(['a', 'b'],
+        ...         [Cluster(['1', '2'],
+        ...                  [Cluster(['A'])]),
+        ...          Cluster(['3', '4', '5'],
+        ...                  [Cluster(['C', 'D'])])]).children()
+        (Cluster(['...', '...'],
+                 [Cluster(['A'], [])]),
+         Cluster(['...', '...', '...'],
+                 [Cluster(['...', '...'], [])]))
+        """
+        return tuple(self._children)
+    def __contains__ (self, name) :
+        """
+        >>> c = Cluster(['a', 'b'],
+        ...             [Cluster(['1', '2'],
+        ...                      [Cluster(['A'])]),
+        ...              Cluster(['3', '4', '5'],
+        ...                      [Cluster(['C', 'D'])])])
+        >>> 'a' in c
+        True
+        >>> 'x' in c
+        False
+        >>> '4' in c
+        True
+        """
+        if name in self._nodes :
+            return True
+        for child in self._children :
+            if name in child :
+                return True
+        return False
+    def __iter__ (self) :
+        """
+        >>> c = Cluster(['a', 'b'],
+        ...             [Cluster(['1', '2'],
+        ...                      [Cluster(['A'])]),
+        ...              Cluster(['3', '4', '5'],
+        ...                      [Cluster(['C', 'D'])])])
+        >>> for cluster in c :
+        ...    print(list(sorted(cluster.nodes())))
+        ['a', 'b']
+        ['1', '2']
+        ['A']
+        ['3', '4', '5']
+        ['C', 'D']
+        """
+        yield self
+        for child in self._children :
+            for item in child :
+                yield item
+
+@snakes.plugins.plugin("snakes.nets")
+def extend (module) :
+    class PetriNet (module.PetriNet) :
+        def __init__ (self, name, **options) :
+            module.PetriNet.__init__(self, name, **options)
+            self.clusters = Cluster()
+        def copy (self, name=None, **options) :
+            result = module.PetriNet.copy(self, name, **options)
+            result.clusters = self.clusters.copy()
+            return result
+        def __pnmldump__ (self) :
+            result = module.PetriNet.__pnmldump__(self)
+            result.add_child(Tree.from_obj(self.clusters))
+            return result
+        @classmethod
+        def __pnmlload__ (cls, tree) :
+            result = new_instance(cls, module.PetriNet.__pnmlload__(tree))
+            result.clusters = tree.child(Cluster.__pnmltag__).to_obj()
+            return result
+        def add_place (self, place, **options) :
+            path = options.pop("cluster", None)
+            module.PetriNet.add_place(self, place, **options)
+            self.clusters.add_node(place.name, path)
+        def remove_place (self, name, **options) :
+            module.PetriNet.remove_place(self, name, **options)
+            self.clusters.remove_node(name)
+        def add_transition (self, trans, **options) :
+            path = options.pop("cluster", None)
+            module.PetriNet.add_transition(self, trans, **options)
+            self.clusters.add_node(trans.name, path)
+        def remove_transition (self, name, **options) :
+            module.PetriNet.remove_transition(self, name, **options)
+            self.clusters.remove_node(name)
+        def rename_node (self, old, new, **options) :
+            module.PetriNet.rename_node(self, old, new, **options)
+            self.clusters.rename_node(old, new)
+    return PetriNet, Cluster

+"""Draw Petri nets using PyGraphViz
+
+ - adds a method C{draw} to C{PetriNet} and C{StateGraph} that creates
+   a drawing of the object in a file.
+
+>>> import snakes.plugins
+>>> snakes.plugins.load('gv', 'snakes.nets', 'nets')
+<module ...>
+>>> from nets import *
+>>> n = PetriNet('N')
+>>> n.add_place(Place('p00', [0]))
+>>> n.add_transition(Transition('t10'))
+>>> n.add_place(Place('p11'))
+>>> n.add_transition(Transition('t01'))
+>>> n.add_input('p00', 't10', Variable('x'))
+>>> n.add_output('p11', 't10', Expression('x+1'))
+>>> n.add_input('p11', 't01', Variable('y'))
+>>> n.add_output('p00', 't01', Expression('y-1'))
+
+>>> for engine in ('neato', 'dot', 'circo', 'twopi', 'fdp') :
+...     n.draw(',test-gv-%s.png' % engine, engine=engine)
+
+>>> s = StateGraph(n)
+>>> s.build()
+>>> s.draw(',test-gv-graph.png')
+
+>>> for node in sorted(n.node(), key=str) :
+...     node.pos.moveto(-100, -100)
+>>> n.layout()
+>>> any(node.pos == (-100, -100) for node in sorted(n.node(), key=str))
+False
+"""
+
+import os, os.path, subprocess, collections
+import snakes.plugins
+from snakes.plugins.clusters import Cluster
+from snakes.compat import *
+
+class Graph (Cluster) :
+    def __init__ (self, attr) :
+        Cluster.__init__(self)
+        self.attributes = {}
+        self.attr = dict(style="invis")
+        self.attr.update(attr)
+        self.edges = collections.defaultdict(list)
+    def add_node (self, node, attr) :
+        self.attributes[node] = attr
+        Cluster.add_node(self, node)
+    def add_edge (self, src, dst, attr) :
+        self.edges[src, dst].append(attr)
+    def has_edge (self, src, dst) :
+        if (src, dst) in self.edges :
+            return True
+        for child in self.children() :
+            if child.has_edge(src, dst) :
+                return True
+        return False
+    def _dot_attr (self, attr, tag=None) :
+        if tag is None :
+            tag = ""
+        else :
+            tag = "%s " % tag
+        return (["%s[" % tag,
+                 ["%s=%s" % (key, self.escape(str(val)))
+                  for key, val in attr.items()],
+                 "];"])
+    def _dot (self) :
+        body = []
+        lines = ["subgraph %s {" % self, self._dot_attr(self.attr, "graph"),
+                 body, "}"]
+        for node in self.nodes() :
+            body.append(node)
+            body.append(self._dot_attr(self.attributes[node]))
+        for child in self.children() :
+            body.extend(child._dot())
+        for (src, dst), lst in self.edges.items() :
+            for attr in lst :
+                body.append("%s -> %s" % (src, dst))
+                body.append(self._dot_attr(attr))
+        return lines
+    def _dot_text (self, lines, indent=0) :
+        for l in lines :
+            if isinstance(l, str) :
+                yield " "*indent*2 + l
+            else :
+                for x in self._dot_text(l, indent+1) :
+                    yield x
+    def dot (self) :
+        self.done = set()
+        return "\n".join(self._dot_text(["digraph {",
+                                         ['node [label="N",'
+                                          ' fillcolor="#FFFFFF",'
+                                          ' fontcolor="#000000",'
+                                          ' style=filled];',
+                                          'edge [style="solid"];',
+                                          'graph [splines="true",'
+                                          ' overlap="false"];'],
+                                         self._dot(),
+                                         "}"]))
+    def escape (self, text) :
+        return '"%s"' % text.replace('"', r'\"')
+    def render (self, filename, engine="dot", debug=False) :
+        if engine not in ("dot", "neato", "twopi", "circo", "fdp") :
+            raise ValueError("unknown GraphViz engine %r" % engine)
+        outfile = open(filename + ".dot", "w")
+        outfile.write(self.dot())
+        outfile.close()
+        if debug :
+            dot = subprocess.Popen([engine, "-T" + filename.rsplit(".", 1)[-1],
+                                    "-o" + filename, outfile.name],
+                                   stdin=subprocess.PIPE)
+        else :
+            dot = subprocess.Popen([engine, "-T" + filename.rsplit(".", 1)[-1],
+                                    "-o" + filename, outfile.name],
+                                   stdin=subprocess.PIPE,
+                                   stdout=subprocess.PIPE,
+                                   stderr=subprocess.PIPE)
+        dot.communicate()
+        if not debug :
+            os.unlink(outfile.name)
+        if dot.returncode != 0 :
+            raise IOError("%s exited with status %s" % (engine, dot.returncode))
+    def layout (self, engine="dot", debug=False) :
+        if engine not in ("dot", "neato", "twopi", "circo", "fdp") :
+            raise ValueError("unknown GraphViz engine %r" % engine)
+        if debug :
+            dot = subprocess.Popen([engine, "-Tplain"],
+                                   stdin=subprocess.PIPE,
+                                   stdout=subprocess.PIPE)
+        else :
+            dot = subprocess.Popen([engine, "-Tplain"],
+                                   stdin=subprocess.PIPE,
+                                   stdout=subprocess.PIPE,
+                                   stderr=subprocess.PIPE)
+        if PY3 :
+            out, err = dot.communicate(bytes(self.dot(),
+                                             snakes.defaultencoding))
+            out = out.decode(snakes.defaultencoding)
+        else :
+            out, err = dot.communicate(self.dot())
+        if dot.returncode != 0 :
+            raise IOError("%s exited with status %s"
+                          % (engine, dot.returncode))
+        for line in (l.strip() for l in out.splitlines()
+                     if l.strip().startswith("node")) :
+            node, name, x, y, rest = line.split(None, 4)
+            yield name, float(x), float(y)
+
+@snakes.plugins.plugin("snakes.nets",
+                       depends=["snakes.plugins.clusters",
+                                "snakes.plugins.pos"])
+def extend (module) :
+    class PetriNet (module.PetriNet) :
+        "An extension with a method C{draw}"
+        def draw (self, filename=None, engine="dot", debug=False,
+                  graph_attr=None, cluster_attr=None,
+                  place_attr=None, trans_attr=None, arc_attr=None) :
+            """
+            @param filename: the name of the image file to create or
+              C{None} if only the computed graph is needed
+            @type filename: C{None} or C{str}
+            @param engine: the layout engine to use: 'dot' (default),
+              'neato', 'circo', 'twopi' or 'fdp'
+            @type engine: C{str}
+            @param place_attr: a function to format places, it will be
+              called with the place and its attributes dict as
+              parameters
+            @type place_attr: C{function(Place,dict)->None}
+            @param trans_attr: a function to format transitions, it
+              will be called with the transition and its attributes dict
+              as parameters
+            @type trans_attr: C{function(Transition,dict)->None}
+            @param arc_attr:  a function to format arcs, it will be
+              called with the label and its attributes dict as
+              parameters
+            @type arc_attr: C{function(ArcAnnotation,dict)->None}
+            @param cluster_attr: a function to format clusters of
+              nodes, it will be called with the cluster and its
+              attributes dict as parameters
+            @type cluster_attr: C{function(snakes.plugins.clusters.Cluster,dict)->None}
+            @return: C{None} if C{filename} is not C{None}, the
+              computed graph otherwise
+            @rtype: C{None} or C{pygraphviz.AGraph}
+            """
+            nodemap = dict((node.name, "node_%s" % num)
+                           for num, node in enumerate(self.node()))
+            g = self._copy(nodemap, self.clusters, cluster_attr,
+                           place_attr, trans_attr)
+            self._copy_edges(nodemap, g, arc_attr)
+            if graph_attr :
+                graph_attr(self, g.attr)
+            if filename is None :
+                g.nodemap = nodemap
+                return g
+            else :
+                g.render(filename, engine, debug)
+        def _copy (self, nodemap, sub, cluster_attr, place_attr, trans_attr) :
+            attr = dict(style="invis")
+            if cluster_attr :
+                cluster_attr(sub, attr)
+            graph = Graph(attr)
+            for name in sub.nodes() :
+                if self.has_place(name) :
+                    node = self.place(name)
+                    attr = dict(shape="ellipse",
+                                label="%s\\n%s" % (node.name, node.tokens))
+                    if place_attr :
+                        place_attr(node, attr)
+                else :
+                    node = self.transition(name)
+                    attr = dict(shape="rectangle",
+                                label="%s\\n%s" % (node.name, str(node.guard)))
+                    if trans_attr :
+                        trans_attr(node, attr)
+                graph.add_node(nodemap[name], attr)
+            for child in sub.children() :
+                graph.add_child(self._copy(nodemap, child, cluster_attr,
+                                           place_attr, trans_attr))
+            return graph
+        def _copy_edges (self, nodemap, graph, arc_attr) :
+            for trans in self.transition() :
+                for place, label in trans.input() :
+                    attr = dict(arrowhead="normal",
+                                label=" %s " % label)
+                    if arc_attr :
+                        arc_attr(label, attr)
+                    graph.add_edge(nodemap[place.name], nodemap[trans.name],
+                                   attr)
+                for place, label in trans.output() :
+                    attr = dict(arrowhead="normal",
+                                label=" %s " % label)
+                    if arc_attr :
+                        arc_attr(label, attr)
+                    graph.add_edge(nodemap[trans.name], nodemap[place.name],
+                                   attr)
+        def layout (self, xscale=1.0, yscale=1.0, engine="dot",
+                    debug=False, graph_attr=None, cluster_attr=None,
+                    place_attr=None, trans_attr=None, arc_attr=None) :
+            g = self.draw(None, engine, debug, graph_attr, cluster_attr,
+                          place_attr, trans_attr, arc_attr)
+            node = dict((v, k) for k, v in g.nodemap.items())
+            for n, x, y in g.layout(engine, debug) :
+                self.node(node[n]).pos.moveto(x*xscale, y*yscale)
+
+    class StateGraph (module.StateGraph) :
+        "An extension with a method C{draw}"
+        def draw (self, filename=None, engine="dot", debug=False,
+                  node_attr=None, edge_attr=None, graph_attr=None) :
+            """
+            @param filename: the name of the image file to create or
+              C{None} if only the computed graph is needed
+            @type filename: C{None} or C{str}
+            @param engine: the layout engine to use: 'dot' (default),
+              'neato', 'circo', 'twopi' or 'fdp'
+            @type engine: C{str}
+            @param node_attr: a function to format nodes, it will be
+              called with the state number, the C{StateGraph} object
+              and attributes dict as parameters
+            @type node_attr: C{function(int,StateGraph,dict)->None}
+            @param edge_attr: a function to format edges, it
+              will be called with the transition, its mode and
+              attributes dict as parameters
+            @type trans_attr: C{function(Transition,Substitution,dict)->None}
+            @param graph_attr: a function to format grapg, it
+              will be called with the state graphe and attributes dict
+              as parameters
+            @type graph_attr: C{function(StateGraph,dict)->None}
+            @return: C{None} if C{filename} is not C{None}, the
+              computed graph otherwise
+            @rtype: C{None} or C{pygraphviz.AGraph}
+            """
+            attr = dict(style="invis",
+                        splines="true")
+            if graph_attr :
+                graph_attr(self, attr)
+            graph = Graph(attr)
+            for state in self._done :
+                self.goto(state)
+                attr = dict(shape="rectangle")
+                if state == 0 :
+                    attr["shape"] = ""
+                if node_attr :
+                    node_attr(state, self, attr)
+                graph.add_node(str(state), attr)
+                for succ, (trans, mode) in self.successors().items() :
+                    attr = dict(arrowhead="normal",
+                                label="%s\\n%s" % (trans.name, mode))
+                    if edge_attr :
+                        edge_attr(trans, mode, attr)
+                    graph.add_edge(str(state), str(succ), attr)
+            if filename is None :
+                return graph
+            else :
+                graph.render(filename, engine, debug)
+    return PetriNet, StateGraph

+"""An example plugin that allows instances class C{PetriNet} to say hello.
+
+A new method C{hello} is added. The constructor is added a keyword
+argument C{hello} that must be the C{str} to print when calling
+C{hello}, with one C{%s} that will be replaced by the name of the net
+when C{hello} is called.
+
+Defining a plugins need writing a module with a single function called
+C{extend} that takes a single argument that is the module to be
+extended.
+
+Inside the function, extensions of the classes in the module are
+defined as normal sub-classes.
+
+The function C{extend} should return the extended module created by
+C{snakes.plugins.build} that takes as arguments: the name of the
+extended module, the module taken as argument and the sub-classes
+defined (expected as a list argument C{*args} in no special order).
+
+If the plugin depends on other plugins, for instance C{foo} and
+C{bar}, the function C{extend} should be decorated by
+C{@depends('foo', 'bar')}.
+
+Read the source code of this module to have an example
+"""
+
+import snakes.plugins
+
+@snakes.plugins.plugin("snakes.nets")
+def extend (module) :
+    """Extends C{module}
+    """
+    class PetriNet (module.PetriNet) :
+        """Extension of the class C{PetriNet} in C{module}
+        """
+        def __init__ (self, name, **args) :
+            """When extending an existing method, take care that you
+            may be working on an already extended class, so you so not
+            know how its arguments have been changed. So, always use
+            those from the unextended class plus C{**args}, remove
+            from it what your plugin needs and pass it to the method
+            of the extended class if you need to call it.
+
+            >>> PetriNet('N').hello()
+            Hello from N
+            >>> PetriNet('N', hello='Hi! This is %s...').hello()
+            Hi! This is N...
+
+            @param args: plugin options
+            @keyword hello: the message to print, with C{%s} where the
+              net name should appear.
+            @type hello: C{str}
+            """
+            self._hello = args.pop("hello", "Hello from %s")
+            module.PetriNet.__init__(self, name, **args)
+        def hello (self) :
+            """A new method C{hello}
+
+            >>> n = PetriNet('N')
+            >>> n.hello()
+            Hello from N
+            """
+            print(self._hello % self.name)
+    return PetriNet

+"""A plugin to add labels to nodes and nets.
+
+"""
+
+from snakes.plugins import plugin, new_instance
+from snakes.pnml import Tree
+
+@plugin("snakes.nets")
+def extend (module) :
+    class Transition (module.Transition) :
+        def label (self, *get, **set) :
+            if not hasattr(self, "_labels") :
+                self._labels = {}
+            result = tuple(self._labels[g] for g in get)
+            self._labels.update(set)
+            if len(get) == 1 :
+                return result[0]
+            elif len(get) > 1 :
+                return result
+            elif len(set) == 0 :
+                return self._labels.copy()
+        def has_label (self, name, *names) :
+            if len(names) == 0 :
+                return name in self._labels
+            else :
+                return tuple(n in self._labels for n in (name,) + names)
+        def copy (self, name=None, **options) :
+            if not hasattr(self, "_labels") :
+                self._labels = {}
+            result = module.Transition.copy(self, name, **options)
+            result._labels = self._labels.copy()
+            return result
+        def __pnmldump__ (self) :
+            """
+            >>> t = Transition('t')
+            >>> t.label(foo='bar', spam=42)
+            >>> t.__pnmldump__()
+            <?xml version="1.0" encoding="utf-8"?>
+            <pnml>
+             <transition id="t">
+              <label name="foo">
+               <object type="str">
+                bar
+               </object>
+              </label>
+              <label name="spam">
+               <object type="int">
+                42
+               </object>
+              </label>
+             </transition>
+            </pnml>
+            """
+            t = module.Transition.__pnmldump__(self)
+            if hasattr(self, "_labels") :
+                for key, val in self._labels.items() :
+                    t.add_child(Tree("label", None,
+                                     Tree.from_obj(val),
+                                     name=key))
+            return t
+        @classmethod
+        def __pnmlload__ (cls, tree) :
+            """
+            >>> old = Transition('t')
+            >>> old.label(foo='bar', spam=42)
+            >>> p = old.__pnmldump__()
+            >>> new = Transition.__pnmlload__(p)
+            >>> new
+            Transition('t', Expression('True'))
+            >>> new.__class__
+            <class 'snakes.plugins.labels.Transition'>
+            >>> new.label('foo', 'spam')
+            ('bar', 42)
+            """
+            t = new_instance(cls, module.Transition.__pnmlload__(tree))
+            t._labels = dict((lbl["name"], lbl.child().to_obj())
+                             for lbl in tree.get_children("label"))
+            return t
+    class Place (module.Place) :
+        def label (self, *get, **set) :
+            if not hasattr(self, "_labels") :
+                self._labels = {}
+            result = tuple(self._labels[g] for g in get)
+            self._labels.update(set)
+            if len(get) == 1 :
+                return result[0]
+            elif len(get) > 1 :
+                return result
+            elif len(set) == 0 :
+                return self._labels.copy()
+        def has_label (self, name, *names) :
+            if len(names) == 0 :
+                return name in self._labels
+            else :
+                return tuple(n in self._labels for n in (name,) + names)
+        def copy (self, name=None, **options) :
+            if not hasattr(self, "_labels") :
+                self._labels = {}
+            result = module.Place.copy(self, name, **options)
+            result._labels = self._labels.copy()
+            return result
+        def __pnmldump__ (self) :
+            """
+            >>> p = Place('p')
+            >>> p.label(foo='bar', spam=42)
+            >>> p.__pnmldump__()
+            <?xml version="1.0" encoding="utf-8"?>
+            <pnml>
+             <place id="p">
+              <type domain="universal"/>
+              <initialMarking>
+               <multiset/>
+              </initialMarking>
+              <label name="foo">
+               <object type="str">
+                bar
+               </object>
+              </label>
+              <label name="spam">
+               <object type="int">
+                42
+               </object>
+              </label>
+             </place>
+            </pnml>
+            """
+            t = module.Place.__pnmldump__(self)
+            if hasattr(self, "_labels") :
+                for key, val in self._labels.items() :
+                    t.add_child(Tree("label", None,
+                                     Tree.from_obj(val),
+                                     name=key))
+            return t
+        @classmethod
+        def __pnmlload__ (cls, tree) :
+            """
+            >>> old = Place('p')
+            >>> old.label(foo='bar', spam=42)
+            >>> p = old.__pnmldump__()
+            >>> new = Place.__pnmlload__(p)
+            >>> new
+            Place('p', MultiSet([]), tAll)
+            >>> new.__class__
+            <class 'snakes.plugins.labels.Place'>
+            >>> new.label('foo', 'spam')
+            ('bar', 42)
+            """
+            p = new_instance(cls, module.Place.__pnmlload__(tree))
+            p._labels = dict((lbl["name"], lbl.child().to_obj())
+                             for lbl in tree.get_children("label"))
+            return p
+    class PetriNet (module.PetriNet) :
+        def label (self, *get, **set) :
+            if not hasattr(self, "_labels") :
+                self._labels = {}
+            result = tuple(self._labels[g] for g in get)
+            self._labels.update(set)
+            if len(get) == 1 :
+                return result[0]
+            elif len(get) > 1 :
+                return result
+            elif len(set) == 0 :
+                return self._labels.copy()
+        def has_label (self, name, *names) :
+            if len(names) == 0 :
+                return name in self._labels
+            else :
+                return tuple(n in self._labels for n in (name,) + names)
+        def copy (self, name=None, **options) :
+            if not hasattr(self, "_labels") :
+                self._labels = {}
+            result = module.PetriNet.copy(self, name, **options)
+            result._labels = self._labels.copy()
+            return result
+        def __pnmldump__ (self) :
+            """
+            >>> n = PetriNet('n')
+            >>> n.label(foo='bar', spam=42)
+            >>> n.__pnmldump__()
+            <?xml version="1.0" encoding="utf-8"?>
+            <pnml>
+             <net id="n">
+              <label name="foo">
+               <object type="str">
+                bar
+               </object>
+              </label>
+              <label name="spam">
+               <object type="int">
+                42
+               </object>
+              </label>
+             </net>
+            </pnml>
+            """
+            t = module.PetriNet.__pnmldump__(self)
+            if hasattr(self, "_labels") :
+                for key, val in self._labels.items() :
+                    t.add_child(Tree("label", None,
+                                     Tree.from_obj(val),
+                                     name=key))
+            return t
+        @classmethod
+        def __pnmlload__ (cls, tree) :
+            """
+            >>> old = PetriNet('n')
+            >>> old.label(foo='bar', spam=42)
+            >>> p = old.__pnmldump__()
+            >>> new = PetriNet.__pnmlload__(p)
+            >>> new
+            PetriNet('n')
+            >>> new.__class__
+            <class 'snakes.plugins.labels.PetriNet'>
+            >>> new.label('foo', 'spam')
+            ('bar', 42)
+            """
+            n = new_instance(cls, module.PetriNet.__pnmlload__(tree))
+            n._labels = dict((lbl["name"], lbl.child().to_obj())
+                             for lbl in tree.get_children("label"))
+            return n
+        def merge_places (self, target, sources, **options) :
+            module.PetriNet.merge_places(self, target, sources, **options)
+            new = self.place(target)
+            for place in sources :
+                new.label(**dict(self.place(place).label()))
+        def merge_transitions (self, target, sources, **options) :
+            module.PetriNet.merge_transitions(self, target, sources, **options)
+            new = self.transition(target)
+            for trans in sources :
+                new.label(**dict(self.transition(trans).label()))
+    return Transition, Place, PetriNet

+"""A plugin to compose nets.
+
+The compositions are based on place status and automatically merge
+some nodes (buffers and variables, tick transitions).
+
+>>> import snakes.plugins
+>>> snakes.plugins.load('ops', 'snakes.nets', 'nets')
+<module ...>
+>>> from nets import *
+>>> from snakes.plugins.status import entry, internal, exit, buffer
+>>> basic = PetriNet('basic')
+>>> basic.add_place(Place('e', status=entry))
+>>> basic.add_place(Place('x', status=exit))
+>>> basic.add_transition(Transition('t'))
+>>> basic.add_input('e', 't', Value(1))
+>>> basic.add_output('x', 't', Value(2))
+>>> basic.add_place(Place('b', [1], status=buffer('buf')))
+
+>>> n = basic.copy()
+>>> n.hide(entry)
+>>> n.node('e').status
+Status(None)
+>>> n.hide(buffer('buf'), buffer(None))
+>>> n.node('b').status
+Buffer('buffer')
+
+>>> n = basic / 'buf'
+>>> n.node('[b/buf]').status
+Buffer('buffer')
+
+>>> n = basic & basic
+>>> n.status(internal)
+('[x&e]',)
+>>> n.place('[x&e]').pre
+{'[t&]': Value(2)}
+>>> n.place('[x&e]').post
+{'[&t]': Value(1)}
+>>> n.status(buffer('buf'))
+('[b&b]',)
+
+>>> n = basic + basic
+>>> n.status(entry)
+('[e+e]',)
+>>> list(sorted(n.place('[e+e]').post.items()))
+[('[+t]', Value(1)), ('[t+]', Value(1))]
+>>> n.status(exit)
+('[x+x]',)
+>>> list(sorted(n.place('[x+x]').pre.items()))
+[('[+t]', Value(2)), ('[t+]', Value(2))]
+
+>>> n = basic * basic
+>>> n.status(entry)
+('[e,x*e]',)
+>>> n.place('[e,x*e]').post
+{'[t*]': Value(1), '[*t]': Value(1)}
+>>> n.place('[e,x*e]').pre
+{'[t*]': Value(2)}
+
+>>> n1 = basic.copy()
+>>> n1.declare('global x; x=1')
+>>> n2 = basic.copy()
+>>> n2.globals['y'] = 2
+>>> n = n1 + n2
+>>> n.globals['x'], n.globals['y']
+(1, 2)
+>>> n._declare
+['global x; x=1']
+"""
+
+import snakes.plugins
+from snakes.plugins.status import Status, entry, exit, internal
+from snakes.data import cross
+from snakes.plugins.clusters import Cluster
+
+def _glue (op, one, two) :
+    result = one.__class__("(%s%s%s)" % (one.name, op, two.name))
+    def new (name) :
+        return "[%s%s]" % (name, op)
+    for net in (one, two) :
+        result.clusters.add_child(Cluster())
+        result._declare = list(set(result._declare) | set(net._declare))
+        result.globals.update(net.globals)
+        for place in net.place() :
+            result.add_place(place.copy(new(place.name)),
+                             cluster=[-1]+net.clusters.get_path(place.name))
+        for trans in net.transition() :
+            result.add_transition(trans.copy(new(trans.name)),
+                                  cluster=[-1]+net.clusters.get_path(trans.name))
+            for place, label in trans.input() :
+                result.add_input(new(place.name),
+                                 new(trans.name),
+                                 label.copy())
+            for place, label in trans.output() :
+                result.add_output(new(place.name),
+                                  new(trans.name),
+                                  label.copy())
+        def new (name) :
+            return "[%s%s]" % (op, name)
+    for status in result.status :
+        result.status.merge(status)
+        new = result.status(status)
+        if len(new) == 1 :
+            name  = "[%s%s%s]" % (",".join(sorted(one.status(status))),
+                                  op,
+                                  ",".join(sorted(two.status(status))))
+            if name != new[0] :
+                result.rename_node(new[0], name)
+    return result
+
+@snakes.plugins.plugin("snakes.nets",
+                       depends=["snakes.plugins.clusters",
+                                "snakes.plugins.status"])
+def extend (module) :
+    "Build the extended module"
+    class PetriNet (module.PetriNet) :
+        def __or__ (self, other) :
+            "Parallel"
+            return _glue("|", self, other)
+        def __and__ (self, other) :
+            "Sequence"
+            result = _glue("&", self, other)
+            remove = set()
+            for x, e in cross((self.status(exit), other.status(entry))) :
+                new = "[%s&%s]" % (x, e)
+                new_x, new_e = "[%s&]" % x, "[&%s]" % e
+                result.merge_places(new, (new_x, new_e), status=internal)
+                remove.update((new_x, new_e))
+            for p in remove :
+                result.remove_place(p)
+            return result
+        def __add__ (self, other) :
+            "Choice"
+            result = _glue("+", self, other)
+            for status in (entry, exit) :
+                remove = set()
+                for l, r in cross((self.status(status),
+                                   other.status(status))) :
+                    new = "[%s+%s]" % (l, r)
+                    new_l, new_r = "[%s+]" % l, "[+%s]" % r
+                    result.merge_places(new, (new_l, new_r), status=status)
+                    remove.update((new_l, new_r))
+                for p in remove :
+                    result.remove_place(p)
+            return result
+        def __mul__ (self, other) :
+            "Iteration"
+            result = _glue("*", self, other)
+            remove = set()
+            for e1, x1, e2 in cross((self.status(entry),
+                                     self.status(exit),
+                                     other.status(entry))) :
+                new = "[%s,%s*%s]" % (e1, x1, e2)
+                new_e1, new_x1 = "[%s*]" % e1, "[%s*]" % x1
+                new_e2 = "[*%s]" % e2
+                result.merge_places(new, (new_e1, new_x1, new_e2),
+                                    status=entry)
+                remove.update((new_e1, new_x1, new_e2))
+            for p in remove :
+                result.remove_place(p)
+            return result
+        def hide (self, old, new=None) :
+            if new is None :
+                new = Status(None)
+            for node in self.status(old) :
+                self.set_status(node, new)
+        def __div__ (self, name) :
+            result = self.copy()
+            for node in result.node() :
+                result.rename_node(node.name, "[%s/%s]" % (node, name))
+            for status in result.status :
+                if status._value == name :
+                    result.hide(status, status.__class__(status._name, None))
+            return result
+        def __truediv__ (self, other) :
+            return self.__div__(other)
+    return PetriNet

+"""A plugin to add positions to the nodes.
+
+ - C{Place} and C{Transition} constructors are added an optional
+   argument C{pos=(x,y)} to set their position
+
+ - C{Place} and C{Transition} are added an attribute C{pos} that is
+   pair of numbers with attributes C{x} and C{y} and methods
+   C{shift(dx, dy)} and C{moveto(x, y)}
+
+ - Petri nets are added methods C{bbox()} that returns a pair of
+   extrema C{((xmin, ymin), (xmax, ymax))}, a method C{shift(dx, dy)}
+   that shift all the nodes, and a method C{transpose()} that rotates
+   the net in such a way that the top-down direction becomes
+   left-right
+
+>>> import snakes.plugins
+>>> snakes.plugins.load('pos', 'snakes.nets', 'nets')
+<module ...>
+>>> from nets import PetriNet, Place, Transition
+>>> n = PetriNet('N')
+>>> n.add_place(Place('p00'))
+>>> n.add_transition(Transition('t10', pos=(1, 0)))
+>>> n.add_place(Place('p11', pos=(1, 1)))
+>>> n.add_transition(Transition('t01', pos=(0, 1)))
+>>> n.node('t10').pos
+Position(1, 0)
+>>> n.node('t10').pos.x
+1
+>>> n.node('t10').pos.y
+0
+>>> n.node('t10').pos.y = 1
+Traceback (most recent call last):
+  ...
+AttributeError: readonly attribute
+>>> n.node('t10').pos()
+(1, 0)
+>>> n.bbox()
+((0, 0), (1, 1))
+>>> n.shift(1, 2)
+>>> n.bbox()
+((1, 2), (2, 3))
+>>> n.node('t01').copy().pos
+Position(1, 3)
+>>> n.transpose()
+>>> n.node('t01').pos
+Position(-3, 1)
+"""
+
+from snakes import SnakesError
+from snakes.compat import *
+from snakes.plugins import plugin, new_instance
+from snakes.pnml import Tree
+
+class Position (object) :
+    "The position of a node"
+    def __init__ (self, x, y) :
+        self.__dict__["x"] = x
+        self.__dict__["y"] = y
+    def __str__ (self) :
+        return "(%s, %s)" % (str(self.x), str(self.y))
+    def __repr__ (self) :
+        return "Position(%s, %s)" % (str(self.x), str(self.y))
+    def __setattr__ (self, name, value) :
+        if name in ("x", "y") :
+            raise AttributeError("readonly attribute")
+        else :
+            self.__dict__[name] = value
+    def moveto (self, x, y) :
+        self.__init__(x, y)
+    def shift (self, dx, dy) :
+        self.__init__(self.x + dx, self.y + dy)
+    def __getitem__ (self, rank) :
+        if rank == 0 :
+            return self.x
+        elif rank == 1 :
+            return self.y
+        else :
+            raise IndexError("Position index out of range")
+    def __iter__ (self) :
+        yield self.x
+        yield self.y
+    def __call__ (self) :
+        return (self.x, self.y)
+
+@plugin("snakes.nets")
+def extend (module) :
+    class Place (module.Place) :
+        def __init__ (self, name, tokens=[], check=None, **args) :
+            x, y = args.pop("pos", (0, 0))
+            self.pos = Position(x, y)
+            module.Place.__init__(self, name, tokens, check, **args)
+        def copy (self, name=None, **args) :
+            x, y = args.pop("pos", self.pos())
+            result = module.Place.copy(self, name, **args)
+            result.pos.moveto(x, y)
+            return result
+        def __pnmldump__ (self) :
+            """
+            >>> p = Place('p', pos=(1, 2))
+            >>> p.__pnmldump__()
+            <?xml version="1.0" encoding="utf-8"?>
+            <pnml>
+             <place id="p">
+              <type domain="universal"/>
+              <initialMarking>
+               <multiset/>
+              </initialMarking>
+              <graphics>
+               <position x="1" y="2"/>
+              </graphics>
+             </place>
+            </pnml>
+            """
+            t = module.Place.__pnmldump__(self)
+            try :
+                gfx = t.child("graphics")
+            except SnakesError :
+                gfx = Tree("graphics", None)
+                t.add_child(gfx)
+            gfx.add_child(Tree("position", None,
+                               x=str(self.pos.x),
+                               y=str(self.pos.y)))
+            return t
+        @classmethod
+        def __pnmlload__ (cls, tree) :
+            """
+            >>> old = Place('p', pos=(1, 2))
+            >>> p = old.__pnmldump__()
+            >>> new = Place.__pnmlload__(p)
+            >>> new.pos
+            Position(1, 2)
+            >>> new
+            Place('p', MultiSet([]), tAll)
+            >>> new.__class__
+            <class 'snakes.plugins.pos.Place'>
+            """
+            result = new_instance(cls, module.Place.__pnmlload__(tree))
+            try :
+                p = tree.child("graphics").child("position")
+                x, y = eval(p["x"]), eval(p["y"])
+                result.pos = Position(x, y)
+            except SnakesError :
+                result.pos = Position(0, 0)
+            return result
+    class Transition (module.Transition) :
+        def __init__ (self, name, guard=None, **args) :
+            x, y = args.pop("pos", (0, 0))
+            self.pos = Position(x, y)
+            module.Transition.__init__(self, name, guard, **args)
+        def copy (self, name=None, **args) :
+            x, y = args.pop("pos", self.pos())
+            result = module.Transition.copy(self, name, **args)
+            result.pos.moveto(x, y)
+            return result
+        def __pnmldump__ (self) :
+            """
+            >>> t = Transition('t', pos=(2, 1))
+            >>> t.__pnmldump__()
+            <?xml version="1.0" encoding="utf-8"?>
+            <pnml>
+             <transition id="t">
+              <graphics>
+               <position x="2" y="1"/>
+              </graphics>
+             </transition>
+            </pnml>
+            """
+            t = module.Transition.__pnmldump__(self)
+            t.add_child(Tree("graphics", None,
+                             Tree("position", None,
+                                  x=str(self.pos.x),
+                                  y=str(self.pos.y))))
+            return t
+        @classmethod
+        def __pnmlload__ (cls, tree) :
+            """
+            >>> old = Transition('t', pos=(2, 1))
+            >>> p = old.__pnmldump__()
+            >>> new = Transition.__pnmlload__(p)
+            >>> new.pos
+            Position(2, 1)
+            >>> new
+            Transition('t', Expression('True'))
+            >>> new.__class__
+            <class 'snakes.plugins.pos.Transition'>
+            """
+            result = new_instance(cls, module.Transition.__pnmlload__(tree))
+            try :
+                p = tree.child("graphics").child("position")
+                x, y = eval(p["x"]), eval(p["y"])
+                result.pos = Position(x, y)
+            except SnakesError :
+                result.pos = Position(0, 0)
+            return result
+    class PetriNet (module.PetriNet) :
+        def add_place (self, place, **args) :
+            if "pos" in args :
+                x, y = args.pop("pos")
+                place.pos.moveto(x, y)
+            module.PetriNet.add_place(self, place, **args)
+        def add_transition (self, trans, **args) :
+            if "pos" in args :
+                x, y = args.pop("pos")
+                trans.pos.moveto(x, y)
+            module.PetriNet.add_transition(self, trans, **args)
+        def merge_places (self, target, sources, **args) :
+            pos = args.pop("pos", None)
+            module.PetriNet.merge_places(self, target, sources, **args)
+            if pos is None :
+                pos = reduce(complex.__add__,
+                             (complex(*self._place[name].pos())
+                              for name in sources)) / len(sources)
+                x, y = pos.real, pos.imag
+            else :
+                x, y = pos
+            self._place[target].pos.moveto(x, y)
+        def merge_transitions (self, target, sources, **args) :
+            pos = args.pop("pos", None)
+            module.PetriNet.merge_transitions(self, target, sources, **args)
+            if pos is None :
+                pos = reduce(complex.__add__,
+                             (complex(*self._trans[name].pos())
+                              for name in sources)) / len(sources)
+                x, y = pos.real, pos.imag
+            else :
+                x, y = pos
+            self._trans[target].pos.moveto(x, y)
+        def bbox (self) :
+            if len(self._node) == 0 :
+                return (0, 0), (0, 0)
+            else :
+                nodes = iter(self._node.values())
+                xmin, ymin = next(nodes).pos()
+                xmax, ymax = xmin, ymin
+                for n in nodes :
+                    x, y = n.pos()
+                    xmin = min(xmin, x)
+                    xmax = max(xmax, x)
+                    ymin = min(ymin, y)
+                    ymax = max(ymax, y)
+                return (xmin, ymin), (xmax, ymax)
+        def shift (self, dx, dy) :
+            for node in self.node() :
+                node.pos.shift(dx, dy)
+        def transpose (self) :
+            for node in self.node() :
+                x, y = node.pos()
+                node.pos.moveto(-y, x)
+    return Place, Transition, PetriNet, Position

+from snakes.plugins import plugin
+from snakes.pnml import Tree, loads, dumps
+import imp, sys, socket, traceback, operator
+
+class QueryError (Exception) :
+    pass
+
+class Query (object) :
+    def __init__ (self, name, *larg, **karg) :
+        self._name = name
+        self._larg = tuple(larg)
+        self._karg = dict(karg)
+    __pnmltag__ = "query"
+    def __pnmldump__ (self) :
+        """
+        >>> Query('set', 'x', 42).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <query name="set">
+          <argument>
+           <object type="str">
+            x
+           </object>
+          </argument>
+          <argument>
+           <object type="int">
+            42
+           </object>
+          </argument>
+         </query>
+        </pnml>
+        >>> Query('test', x=1).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <query name="test">
+          <keyword name="x">
+           <object type="int">
+            1
+           </object>
+          </keyword>
+         </query>
+        </pnml>
+        >>> Query('test', 'x', 42, y=1).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <query name="test">
+          <argument>
+           <object type="str">
+            x
+           </object>
+          </argument>
+          <argument>
+           <object type="int">
+            42
+           </object>
+          </argument>
+          <keyword name="y">
+           <object type="int">
+            1
+           </object>
+          </keyword>
+         </query>
+        </pnml>
+        >>> Query('set', 'x', Query('call', 'x.upper')).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <query name="set">
+          <argument>
+           <object type="str">
+            x
+           </object>
+          </argument>
+          <argument>
+           <query name="call">
+            <argument>
+             <object type="str">
+              x.upper
+             </object>
+            </argument>
+           </query>
+          </argument>
+         </query>
+        </pnml>
+        """
+        children = []
+        for arg in self._larg :
+            children.append(Tree("argument", None,
+                                 Tree.from_obj(arg)))
+        for name, value in self._karg.items() :
+            children.append(Tree("keyword", None,
+                                 Tree.from_obj(value),
+                                 name=name))
+        return Tree(self.__pnmltag__, None, *children, **{"name": self._name})
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """
+        >>> Tree._tag2obj = {'query': Query}
+        >>> t = Query('test', 'x', 42, y=1).__pnmldump__()
+        >>> q = Query.__pnmlload__(t)
+        >>> q._name
+        'test'
+        >>> q._larg
+        ('x', 42)
+        >>> q._karg
+        {'y': 1}
+        """
+        larg = (child.child().to_obj()
+                for child in tree.get_children("argument"))
+        karg = dict((child["name"], child.child().to_obj())
+                    for child in tree.get_children("keyword"))
+        return cls(tree["name"], *larg, **karg)
+    def run (self, envt) :
+        """
+        >>> import imp
+        >>> env = imp.new_module('environment')
+        >>> Query('set', 'x', 'hello').run(env)
+        >>> env.x
+        'hello'
+        >>> Query('set', 'x', Query('call', 'x.upper')).run(env)
+        >>> env.x
+        'HELLO'
+        >>> Query('test', 1, 2, 3).run(env)
+        Traceback (most recent call last):
+         ...
+        QueryError: unknown query 'test'
+        """
+        try :
+            handler = getattr(self, "_run_%s" % self._name)
+        except AttributeError :
+            raise QueryError("unknown query %r" % self._name)
+        self._envt = envt
+        larg = tuple(a.run(envt) if isinstance(a, self.__class__) else a
+                     for a in self._larg)
+        karg = dict((n, v.run(envt) if isinstance(v, self.__class__) else v)
+                    for n, v in self._karg.items())
+        try :
+            return handler(*larg, **karg)
+        except TypeError :
+            cls, val, tb = sys.exc_info()
+            try :
+                fun, msg = str(val).strip().split("()", 1)
+            except :
+                raise val
+            if fun.startswith("_run_") and hasattr(self, fun) :
+                raise TypeError(fun[5:] + "()" + msg)
+            raise val
+    def _get_object (self, path) :
+        obj = self._envt
+        for n in path :
+            obj = getattr(obj, n)
+        return obj
+    def _run_set (self, name, value) :
+        """
+        >>> import imp
+        >>> env = imp.new_module('environment')
+        >>> Query('set', 'x', 1).run(env)
+        >>> env.x
+        1
+        """
+        path = name.split(".")
+        setattr(self._get_object(path[:-1]), path[-1], value)
+    def _run_get (self, name) :
+        """
+        >>> import imp
+        >>> env = imp.new_module('environment')
+        >>> env.x = 2
+        >>> Query('get', 'x').run(env)
+        2
+        """
+        path = name.split(".")
+        return self._get_object(path)
+    def _run_del (self, name) :
+        """
+        >>> import imp
+        >>> env = imp.new_module('environment')
+        >>> env.x = 2
+        >>> Query('del', 'x').run(env)
+        >>> env.x
+        Traceback (most recent call last):
+         ...
+        AttributeError: 'module' object has no attribute 'x'
+        """
+        path = name.split(".")
+        delattr(self._get_object(path[:-1]), path[-1])
+    def _run_call (self, fun, *larg, **karg) :
+        """
+        >>> import imp
+        >>> env = imp.new_module('environment')
+        >>> env.x = 'hello'
+        >>> Query('call', 'x.center', 7).run(env)
+        ' hello '
+        >>> env.__dict__.update(__builtins__)
+        >>> Query('call', Query('call', 'getattr',
+        ...                     Query('call', 'x.center', 7),
+        ...                     'upper')).run(env)
+        ' HELLO '
+        """
+        if isinstance(fun, str) :
+            fun = self._get_object(fun.split("."))
+        return fun(*larg, **karg)
+
+@plugin("snakes.nets")
+def extend (module) :
+    class UDPServer (object) :
+        def __init__ (self, port, size=2**20, verbose=0) :
+            self._size = size
+            self._verbose = verbose
+            self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            self._sock.bind(("", port))
+            self._env = imp.new_module("snk")
+            self._env.__dict__.update(__builtins__)
+            self._env.__dict__.update(operator.__dict__)
+            self._env.__dict__.update(module.__dict__)
+        def recvfrom (self) :
+            return self._sock.recvfrom(self._size)
+        def sendto (self, data, address) :
+            self._sock.sendto(data.strip() + "\n", address)
+        def run (self) :
+            while True :
+                data, address = self.recvfrom()
+                data = data.strip()
+                if self._verbose :
+                    print("# query from %s:%u" % address)
+                try :
+                    if self._verbose > 1 :
+                        print(data)
+                    res = loads(data).run(self._env)
+                    if res is None :
+                        res = Tree("answer", None, status="ok")
+                    else :
+                        res = Tree("answer", None, Tree.from_obj(res),
+                                   status="ok")
+                except :
+                    cls, val, tb = sys.exc_info()
+                    res = Tree("answer", str(val).strip(),
+                               error=cls.__name__, status="error")
+                    if self._verbose > 1 :
+                        print("# error")
+                        for entry in traceback.format_exception(cls, val, tb) :
+                            for line in entry.splitlines() :
+                                print("## %s" % line)
+                if self._verbose :
+                    if self._verbose > 1 :
+                        print("# answer")
+                        print(res.to_pnml())
+                    elif res["status"] == "error" :
+                        print("# answer: %s: %s" % (res["error"], res.data))
+                    else :
+                        print("# answer: %s" % res["status"])
+                self.sendto(res.to_pnml(), address)
+    class TCPServer (UDPServer) :
+        def __init__ (self, port, size=2**20, verbose=0) :
+            self._size = size
+            self._verbose = verbose
+            self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self._sock.bind(("", port))
+            self._sock.listen(1)
+            self._env = imp.new_module("snk")
+            self._env.__dict__.update(__builtins__)
+            self._env.__dict__.update(operator.__dict__)
+            self._env.__dict__.update(module.__dict__)
+            self._connection = {}
+        def recvfrom (self) :
+            connection, address = self._sock.accept()
+            self._connection[address] = connection
+            parts = []
+            while True :
+                parts.append(connection.recv(self._size))
+                if len(parts[-1]) < self._size :
+                    break
+            return "".join(parts), address
+        def sendto (self, data, address) :
+            self._connection[address].send(data.rstrip() + "\n")
+            self._connection[address].close()
+            del self._connection[address]
+    return Query, UDPServer, TCPServer

+"""A plugin to add nodes status.
+
+Several status are defined by default: C{entry}, C{internal}, C{exit},
+C{buffer}, C{safebuffer} for places and {tick} for transitions.
+
+>>> import snakes.plugins
+>>> snakes.plugins.load('status', 'snakes.nets', 'nets')
+<module ...>
+>>> from nets import *
+>>> import snakes.plugins.status as status
+>>> n = PetriNet('N')
+>>> n.add_place(Place('p1'), status=status.entry)
+>>> n.place('p1')
+Place('p1', MultiSet([]), tAll, status=Status('entry'))
+"""
+
+import operator, weakref
+import snakes.plugins
+from snakes import ConstraintError
+from snakes.plugins import new_instance
+from snakes.compat import *
+from snakes.data import iterate
+from snakes.pnml import Tree
+
+class Status (object) :
+    "The status of a node"
+    def __init__ (self, name, value=None) :
+        """Initialize with a status name and an optional value
+
+        @param name: the name of the status
+        @type name: C{str}
+        @param value: an optional additional value to make a
+        difference between status with te same name
+        @type value: hashable
+        """
+        self._name = name
+        self._value = value
+    __pnmltag__ = "status"
+    def __pnmldump__ (self) :
+        """Dump a C{Status} as a PNML tree
+
+        @return: PNML tree
+        @rtype: C{pnml.Tree}
+
+        >>> Status('foo', 42).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>...
+         <status>
+          <name>
+           foo
+          </name>
+          <value>
+           <object type="int">
+            42
+           </object>
+          </value>
+         </status>
+        </pnml>
+        """
+        return Tree(self.__pnmltag__, None,
+                    Tree("name", self._name),
+                    Tree("value", None, Tree.from_obj(self._value)))
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Create a C{Status} from a PNML tree
+
+        @param tree: the tree to convert
+        @type tree: C{pnml.Tree}
+        @return: the status built
+        @rtype: C{Status}
+
+        >>> t = Status('foo', 42).__pnmldump__()
+        >>> Status.__pnmlload__(t)
+        Status('foo',42)
+        """
+        return cls(tree.child("name").data,
+                   tree.child("value").child().to_obj())
+    def copy (self) :
+        """Return a copy of the status
+
+        A status is normally never muted, so this may be useless,
+        unless the user decides to store additional data in status.
+
+        @return: a copy of the status
+        @rtype: C{Status}
+        """
+        return self.__class__(self._name, self._value)
+    def __str__ (self) :
+        """Short textual representation
+
+        >>> str(internal)
+        'internal'
+        >>> str(buffer('buf'))
+        'buffer(buf)'
+
+        @return: a textual representation
+        @rtype: C{str}
+        """
+        if self._value is None :
+            return str(self._name)
+        else :
+            return "%s(%s)" % (self._name, self._value)
+    def __repr__ (self) :
+        """Detailed textual representation
+
+        >>> repr(internal)
+        "Status('internal')"
+        >>> repr(buffer('buf'))
+        "Buffer('buffer','buf')"
+
+        @return: a textual representation suitable for C{eval}
+        @rtype: C{str}
+        """
+        if self._value is None :
+            return "%s(%s)" % (self.__class__.__name__, repr(self._name))
+        else :
+            return "%s(%s,%s)" % (self.__class__.__name__,
+                                  repr(self._name), repr(self._value))
+    def __hash__ (self) :
+        """Hash a status
+
+        @return: the hash value
+        @rtype: C{int}
+        """
+        return hash((self._name, self._value))
+    def __eq__ (self, other) :
+        """Compares two status for equality
+
+        They are equal if they have the same name and value
+
+        >>> internal == Status('internal')
+        True
+        >>> Status('a', 1) == Status('a', 2)
+        False
+        >>> Status('a', 1) == Status('b', 1)
+        False
+
+        @param other: a status
+        @type other: C{Status}
+        @return: C{True} is they are equal, C{False} otherwise
+        @rtype: C{bool}
+        """
+        try :
+            return (self._name, self._value) == (other._name, other._value)
+        except :
+            return False
+    def __ne__ (self, other) :
+        return not(self == other)
+    def __add__ (self, other) :
+        if self == other :
+            return self.copy()
+        else :
+            raise ConstraintError("incompatible status")
+    def name (self) :
+        return self._name
+    def value (self) :
+        return self._value
+    def merge (self, net, nodes, name=None) :
+        """Merge C{nodes} in C{net} into a new node called C{name}
+
+        This does nothing by default, other status will refine this
+        method. Merged nodes are removed, only the newly created one
+        remains.
+
+        @param net: the Petri net where nodes should be merged
+        @type net: C{PetriNet}
+        @param nodes: a collection of node names to be merged
+        @type nodes: iterable of C{str}
+        @param name: the name of the new node or C{Node} if it should
+          be generated
+        @type name: C{str}
+        """
+        pass
+
+entry = Status('entry')
+exit = Status('exit')
+internal = Status('internal')
+
+class Buffer (Status) :
+    "A status for buffer places"
+    def merge (self, net, nodes, name=None) :
+        """Merge C{nodes} in C{net}
+
+        Buffer places with the status status C{Buffer('buffer', None)}
+        are not merged. Other buffer places are merged exactly has
+        C{PetriNet.merge_places} does.
+
+        If C{name} is C{None} the name generated is a concatenation of
+        the nodes names separated by '+', with parenthesis outside.
+
+        >>> import snakes.plugins
+        >>> snakes.plugins.load('status', 'snakes.nets', 'nets')
+        <module ...>
+        >>> from nets import *
+        >>> n = PetriNet('N')
+        >>> import snakes.plugins.status as status
+        >>> buf = status.buffer('buf')
+        >>> n.add_place(Place('p3', range(2), status=buf))
+        >>> n.add_place(Place('p4', range(3), status=buf))
+        >>> n.status.merge(buf, 'b')
+        >>> p = n.place('b')
+        >>> p
+        Place('b', MultiSet([...]), tAll, status=Buffer('buffer','buf'))
+        >>> p.tokens == MultiSet([0, 0, 1, 1, 2])
+        True
+
+        @param net: the Petri net where places should be merged
+        @type net: C{PetriNet}
+        @param nodes: a collection of place names to be merged
+        @type nodes: iterable of C{str}
+        @param name: the name of the new place or C{Node} if it should
+          be generated
+        @type name: C{str}
+        """
+        if self._value is None :
+            return
+        if name is None :
+            name = "(%s)" % "+".join(sorted(nodes))
+        net.merge_places(name, nodes, status=self)
+        for src in nodes :
+            net.remove_place(src)
+
+def buffer (name) :
+    """Generate a buffer status called C{name}
+
+    @param name: the name of the buffer
+    @type name: C{str}
+    @return: C{Buffer('buffer', name)}
+    @rtype: C{Buffer}
+    """
+    return Buffer('buffer', name)
+
+class Safebuffer (Buffer) :
+    "A status for safe buffers (ie, variables) places"
+    def merge (self, net, nodes, name=None) :
+        """Merge C{nodes} in C{net}
+
+        Safe buffers places with the status C{Safebuffer('safebuffer',
+        None)} are not merged. Other safe buffers places are merged if
+        they all have the same marking, which becomes the marking of
+        the resulting place. Otherwise, C{ConstraintError} is raised.
+
+        If C{name} is C{None} the name generated is a concatenation of
+        the nodes names separated by '+', with parenthesis outside.
+
+        >>> import snakes.plugins
+        >>> snakes.plugins.load('status', 'snakes.nets', 'nets')
+        <module ...>
+        >>> from nets import *
+        >>> import snakes.plugins.status as status
+        >>> n = PetriNet('N')
+        >>> var = status.safebuffer('var')
+        >>> n.add_place(Place('p5', [1], status=var))
+        >>> n.add_place(Place('p6', [1], status=var))
+        >>> n.add_place(Place('p7', [1], status=var))
+        >>> n.status.merge(var, 'v')
+        >>> n.place('v')
+        Place('v', MultiSet([1]), tAll, status=Safebuffer('safebuffer','var'))
+        >>> n.add_place(Place('p8', [3], status=var))
+        >>> try : n.status.merge(var, 'vv')
+        ... except ConstraintError : print(sys.exc_info()[1])
+        incompatible markings
+
+        @param net: the Petri net where places should be merged
+        @type net: C{PetriNet}
+        @param nodes: a collection of place names to be merged
+        @type nodes: iterable of C{str}
+        @param name: the name of the new place or C{Node} if it should
+          be generated
+        @type name: C{str}
+        """
+        if self._value is None :
+            return
+        marking = net.place(nodes[0]).tokens
+        for node in nodes[1:] :
+            if net.place(node).tokens != marking :
+                raise ConstraintError("incompatible markings")
+        if name is None :
+            name = "(%s)" % "+".join(sorted(nodes))
+        net.merge_places(name, nodes, status=self)
+        for src in nodes :
+            net.remove_place(src)
+        net.set_status(name, self)
+        net.place(name).reset(marking)
+
+def safebuffer (name) :
+    """Generate a safebuffer status called C{name}
+
+    @param name: the name of the safebuffer
+    @type name: C{str}
+    @return: C{Safebuffer('safebuffer', name)}
+    @rtype: C{Safebuffer}
+    """
+    return Safebuffer('safebuffer', name)
+
+class Tick (Status) :
+    "A status for tick transition"
+    def merge (self, net, nodes, name=None) :
+        """Merge C{nodes} in C{net}
+
+        Tick transitions are merged exactly as
+        C{PetriNet.merge_transitions} does.
+
+        If C{name} is C{None} the name generated is a concatenation of
+        the nodes names separated by '+', with parenthesis outside.
+
+        >>> import snakes.plugins
+        >>> snakes.plugins.load('status', 'snakes.nets', 'nets')
+        <module ...>
+        >>> from nets import *
+        >>> import snakes.plugins.status as status
+        >>> n = PetriNet('N')
+        >>> tick = status.tick('tick')
+        >>> n.add_transition(Transition('t1', Expression('x==1'), status=tick))
+        >>> n.add_transition(Transition('t2', Expression('y==2'), status=tick))
+        >>> n.add_transition(Transition('t3', Expression('z==3'), status=tick))
+        >>> n.status.merge(tick, 't')
+        >>> n.transition('t')
+        Transition('t', Expression('((...) and (...)) and (...)'), status=Tick('tick','tick'))
+
+        @param net: the Petri net where transitions should be merged
+        @type net: C{PetriNet}
+        @param nodes: a collection of transition names to be merged
+        @type nodes: iterable of C{str}
+        @param name: the name of the new transition or C{Node} if it
+          should be generated
+        @type name: C{str}
+        """
+        if self._value is None :
+            return
+        if name is None :
+            name = "(%s)" % "+".join(nodes)
+        net.merge_transitions(name, nodes, status=self)
+        for src in nodes :
+            net.remove_transition(src)
+
+def tick (name) :
+    """Generate a tick status called C{name}
+
+    @param name: the name of the tick
+    @type name: C{str}
+    @return: C{Tick('tick', name)}
+    @rtype: C{Tick}
+    """
+    return Tick('tick', name)
+
+class StatusDict (object) :
+    "A container to access the nodes of a net by their status"
+    def __init__ (self, net) :
+        """
+        @param net: the Petri net for which nodes will be recorded
+        @type net: C{PetriNet}
+        """
+        self._nodes = {}
+        self._net = weakref.ref(net)
+    def copy (self, net=None) :
+        """
+        @param net: the Petri net for which nodes will be recorded
+          (C{None} if it is the same as the copied object)
+        @type net: C{PetriNet}
+        """
+        if net is None :
+            net = self._net()
+        result = self.__class__(net)
+        for status in self._nodes :
+            result._nodes[status.copy()] = self._nodes[status].copy()
+        return result
+    def __iter__ (self) :
+        return iter(self._nodes)
+    def record (self, node) :
+        """Called when C{node} is added to the net
+
+        @param node: the added node
+        @type node: C{Node}
+        """
+        if node.status not in self._nodes :
+            self._nodes[node.status] = set([node.name])
+        else :
+            self._nodes[node.status].add(node.name)
+    def remove (self, node) :
+        """Called when C{node} is removed from the net
+
+        @param node: the added node
+        @type node: C{Node}
+        """
+        if node.status in self._nodes :
+            self._nodes[node.status].discard(node.name)
+            if len(self._nodes[node.status]) == 0 :
+                del self._nodes[node.status]
+    def __call__ (self, status) :
+        """Return the nodes having C{status}
+
+        @param status: the searched status
+        @type status: C{Status}
+        @return: the node names in the net having this status
+        @rtype: C{tuple} of C{str}
+        """
+        return tuple(self._nodes.get(status, tuple()))
+    def merge (self, status, name=None) :
+        """Merge the nodes in the net having C{status}
+
+        This is a shortcut to call C{status.merge} with the right
+        parameters.
+
+        @param status: the status for which nodes have to be merged
+        """
+        if status :
+            nodes = self(status)
+            if len(nodes) > 1 :
+                status.merge(self._net(), nodes, name)
+
+@snakes.plugins.plugin("snakes.nets")
+def extend (module) :
+    "Build the extended module"
+    class Place (module.Place) :
+        def __init__ (self, name, tokens=[], check=None, **args) :
+            self.status = args.pop("status", Status(None))
+            module.Place.__init__(self, name, tokens, check, **args)
+        def copy (self, name=None, **args) :
+            result = module.Place.copy(self, name, **args)
+            result.status = self.status.copy()
+            return result
+        def __repr__ (self) :
+            if self.status == Status(None) :
+                return module.Place.__repr__(self)
+            else :
+                return "%s, status=%s)" % (module.Place.__repr__(self)[:-1],
+                                           repr(self.status))
+        def __pnmldump__ (self) :
+            """
+            >>> p = Place('p', status=Status('foo', 42))
+            >>> p.__pnmldump__()
+            <?xml version="1.0" encoding="utf-8"?>
+            <pnml>...
+             <place id="p">
+              <type domain="universal"/>
+              <initialMarking>
+               <multiset/>
+              </initialMarking>
+              <status>
+               <name>
+                foo
+               </name>
+               <value>
+                <object type="int">
+                 42
+                </object>
+               </value>
+              </status>
+             </place>
+            </pnml>
+            """
+            t = module.Place.__pnmldump__(self)
+            t.add_child(Tree.from_obj(self.status))
+            return t
+        @classmethod
+        def __pnmlload__ (cls, tree) :
+            """
+            >>> t = Place('p', status=Status('foo', 42)).__pnmldump__()
+            >>> Place.__pnmlload__(t).status
+            Status('foo',42)
+            """
+            result = new_instance(cls, module.Place.__pnmlload__(tree))
+            try :
+                result.status = tree.child("status").to_obj()
+            except SnakesError :
+                result.status = Status(None)
+            return result
+    class Transition (module.Transition) :
+        def __init__ (self, name, guard=None, **args) :
+            self.status = args.pop("status", Status(None)).copy()
+            module.Transition.__init__(self, name, guard, **args)
+        def __pnmldump__ (self) :
+            """
+            >>> p = Transition('p', status=Status('foo', 42))
+            >>> p.__pnmldump__()
+            <?xml version="1.0" encoding="utf-8"?>
+            <pnml>...
+             <transition id="p">
+              <status>
+               <name>
+                foo
+               </name>
+               <value>
+                <object type="int">
+                 42
+                </object>
+               </value>
+              </status>
+             </transition>
+            </pnml>
+            """
+            t = module.Transition.__pnmldump__(self)
+            t.add_child(Tree.from_obj(self.status))
+            return t
+        @classmethod
+        def __pnmlload__ (cls, tree) :
+            """
+            >>> t = Transition('p', status=Status('foo', 42)).__pnmldump__()
+            >>> Transition.__pnmlload__(t).status
+            Status('foo',42)
+            """
+            result = new_instance(cls, module.Transition.__pnmlload__(tree))
+            try :
+                result.status = tree.child("status").to_obj()
+            except SnakesError :
+                result.status = Status(None)
+            return result
+        def copy (self, name=None, **args) :
+            result = module.Transition.copy(self, name, **args)
+            result.status = self.status.copy()
+            return result
+        def __repr__ (self) :
+            if self.status == Status(None) :
+                return module.Transition.__repr__(self)
+            else :
+                return "%s, status=%s)" % (module.Transition.__repr__(self)[:-1],
+                                           repr(self.status))
+    class PetriNet (module.PetriNet) :
+        def __init__ (self, name, **args) :
+            module.PetriNet.__init__(self, name, **args)
+            self.status = StatusDict(self)
+        @classmethod
+        def __pnmlload__ (cls, tree) :
+            t = new_instance(cls, module.PetriNet.__pnmlload__(tree))
+            t.status = StatusDict(t)
+            return t
+        def copy (self, name=None, **args) :
+            result = module.PetriNet.copy(self, name, **args)
+            result.status = self.status.copy(result)
+            return result
+        def add_place (self, place, **args) :
+            place.status = args.pop("status", place.status)
+            module.PetriNet.add_place(self, place, **args)
+            self.status.record(place)
+        def remove_place (self, name, **args) :
+            place = self.place(name)
+            self.status.remove(place)
+            module.PetriNet.remove_place(self, name, **args)
+        def add_transition (self, trans, **args) :
+            trans.status = args.pop("status", trans.status)
+            module.PetriNet.add_transition(self, trans, **args)
+            self.status.record(trans)
+        def remove_transition (self, name, **args) :
+            trans = self.transition(name)
+            self.status.remove(trans)
+            module.PetriNet.remove_transition(self, name, **args)
+        def set_status (self, node, status) :
+            node = self.node(node)
+            self.status.remove(node)
+            node.status = status
+            self.status.record(node)
+        def rename_node (self, old, new, **args) :
+            old_node = self.node(old).copy()
+            module.PetriNet.rename_node(self, old, new, **args)
+            self.status.remove(old_node)
+            self.status.record(self.node(new))
+        def copy_place (self, source, targets, **args) :
+            status = args.pop("status", self.place(source).status)
+            module.PetriNet.copy_place(self, source, targets, **args)
+            for new in iterate(targets) :
+                self.set_status(new, status)
+        def copy_transition (self, source, targets, **args) :
+            status = args.pop("status", self.transition(source).status)
+            module.PetriNet.copy_transition(self, source, targets, **args)
+            for new in iterate(targets) :
+                self.set_status(new, status)
+        def merge_places (self, target, sources, **args) :
+            if "status" in args :
+                status = args.pop("status")
+            else :
+                status = reduce(operator.add,
+                                (self.place(s).status for s in sources))
+            module.PetriNet.merge_places(self, target, sources, **args)
+            self.set_status(target, status)
+        def merge_transitions (self, target, sources, **args) :
+            if "status" in args :
+                status = args.pop("status")
+            else :
+                status = reduce(operator.add,
+                                (self.place(s).status for s in sources))
+            module.PetriNet.merge_transitions(self, target, sources, **args)
+            self.set_status(target, status)
+    return Place, Transition, PetriNet, Status, \
+           ("entry", entry), ("exit", exit), ("internal", internal), \
+           Buffer,  buffer, Safebuffer, safebuffer, Tick, tick

+"""An implementation of the M-nets synchronisation.
+
+This plugins extends the basic Petri net model in order to provide an
+action-based synchronisation scheme that implements that of M-nets.
+The plugin proposes a generalisation of the M-nets synchronisation in
+that it does not impose a fixed correspondence between action names
+and action arities.
+
+ - class C{Action} corresponds to a synchronisable action, it has a
+   name, a send/receive flag and a list of parameters. Actions have no
+   predetermined arities, only conjugated actions with the same arity
+   will be able to synchronise.
+
+ - class C{MultiAction} corresponds to a multiset of actions. It is
+   forbidden to build a multiaction that holds a pair of conjugated
+   actions (this leads to infinite nets when synchronising).
+
+ - Transition.__init__ accepts a parameter C{actions} that is a
+   collection of instances of C{Action}, this multiaction is added in
+   the attribute C{actions} of the transition.
+
+ - PetriNet is given new methods: C{synchronise(action_name)} to
+   perform the M-net synchronisation, C{restrict(action_name)} to
+   perform the restriction and C{scope(action_name)} for the scoping.
+
+B{Remark:} the instances of C{Substitution} used in this plugins must
+map variable names to instances of C{Variable} or C{Value}, but not to
+other variable names.
+
+>>> import snakes.plugins
+>>> snakes.plugins.load('synchro', 'snakes.nets', 'nets')
+<module ...>
+>>> from nets import PetriNet, Place, Transition, Expression
+>>> n = PetriNet('N')
+>>> n.add_place(Place('e1'))
+>>> n.add_place(Place('x1'))
+>>> n.add_transition(Transition('t1', guard=Expression('x!=y'),
+...                             actions=[Action('a', True, [Variable('x'), Value(2)]),
+...                                      Action('a', True, [Value(3), Variable('y')]),
+...                                      Action('b', False, [Variable('x'), Variable('y')])]))
+>>> n.add_input('e1', 't1', Variable('x'))
+>>> n.add_output('x1', 't1', Variable('z'))
+>>> n.add_place(Place('e2'))
+>>> n.add_place(Place('x2'))
+>>> n.add_transition(Transition('t2', guard=Expression('z>0'),
+...                             actions=[Action('a', False, [Variable('w'), Variable('y')]),
+...                                      Action('c', False, [Variable('z')])]))
+>>> n.add_input('e2', 't2', Variable('w'))
+>>> n.add_output('x2', 't2', Variable('z'))
+>>> n.transition('t1').vars() == set(['x', 'y', 'z'])
+True
+>>> n.transition('t2').copy().vars() == set(['w', 'y', 'z'])
+True
+>>> n.synchronise('a')
+>>> for t in sorted(n.transition(), key=str) :
+...     print('%s %s' % (t, t.guard))
+...     for place, label in sorted(t.input(), key=str) :
+...         print('   %s >> %s' % (place, label))
+...     for place, label in sorted(t.output(), key=str) :
+...         print('   %s << %s' % (place, label))
+((t1{...}+t2{...})[a(...)]{...}+t2{...})[a(...)] (...)
+...
+t2 z>0
+   e2 >> w
+   x2 << z
+>>> n.restrict('a')
+>>> [t.name for t in sorted(n.transition(), key=str)]
+["((t1{...}+t2{...})[a(...)]{...}+t2{...})[a(...)]",
+ "((t1{...}+t2{...})[a(...)]{...}+t2{...})[a(...)]"]
+"""
+
+from snakes import ConstraintError
+from snakes.data import Substitution, WordSet, iterate
+from snakes.nets import Value, Variable
+from snakes.pnml import Tree
+import snakes.plugins
+from snakes.plugins import new_instance
+from snakes.compat import *
+
+class Action (object) :
+    def __init__ (self, name, send, params) :
+        """
+        @param name: the name of the action
+        @type name: C{str}
+        @param send: a flag indicating whether this is a send or
+           receive action
+        @type send: C{bool}
+        @param params: the list of parameters
+        @type params: C{list} of C{Variable} or C{Value}
+        """
+        self.name = name
+        self.send = send
+        self.params = list(params)
+    __pnmltag__ = "action"
+    def __pnmldump__ (self) :
+        """
+        >>> Action('a', True, [Value(1), Variable('x')]).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>...
+         <action name="a" send="True">
+          <value>
+           <object type="int">
+            1
+           </object>
+          </value>
+          <variable>
+           x
+          </variable>
+         </action>
+        </pnml>
+        """
+        result = Tree(self.__pnmltag__, None,
+                      name=self.name,
+                      send=str(self.send))
+        for param in self.params :
+            result.add_child(Tree.from_obj(param))
+        return result
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """
+        >>> t = Action('a', True, [Value(1), Variable('x')]).__pnmldump__()
+        >>> Action.__pnmlload__(t)
+        Action('a', True, [Value(1), Variable('x')])
+        """
+        params = [Tree.to_obj(child) for child in tree.children]
+        return cls(tree["name"], tree["send"] == "True", params)
+    def __str__ (self) :
+        """
+        >>> a = Action('a', True, [Value(1), Variable('x')])
+        >>> str(a)
+        'a!(1,x)'
+        >>> a.send = False
+        >>> str(a)
+        'a?(1,x)'
+        """
+        if self.send :
+            return "%s!(%s)" % (self.name, ",".join([str(p) for p in self]))
+        else :
+            return "%s?(%s)" % (self.name, ",".join([str(p) for p in self]))
+    def __repr__ (self) :
+        """
+        >>> a = Action('a', True, [Value(1), Variable('x')])
+        >>> repr(a)
+        "Action('a', True, [Value(1), Variable('x')])"
+        >>> a.send = False
+        >>> repr(a)
+        "Action('a', False, [Value(1), Variable('x')])"
+        """
+        return "%s(%s, %s, [%s])" % (self.__class__.__name__, repr(self.name),
+                                     str(self.send),
+                                     ", ".join([repr(p) for p in self]))
+    def __len__ (self) :
+        """Return the number of parameters, aka the arity of the
+        action.
+
+        >>> len(Action('a', True, [Value(1), Variable('x')]))
+        2
+
+        @return: the arity of the action
+        @rtype: non negative C{int}
+        """
+        return len(self.params)
+    def __iter__ (self) :
+        """Iterate on the parameters
+
+        >>> list(Action('a', True, [Value(1), Variable('x')]))
+        [Value(1), Variable('x')]
+        """
+        for action in self.params :
+            yield action
+    def __eq__ (self, other) :
+        """Two actions are equal if they have the same name, same send
+        flags and same parameters.
+
+        >>> Action('a', True, [Value(1), Variable('x')]) == Action('a', True, [Value(1), Variable('x')])
+        True
+        >>> Action('a', True, [Value(1), Variable('x')]) == Action('b', True, [Value(1), Variable('x')])
+        False
+        >>> Action('a', True, [Value(1), Variable('x')]) == Action('a', False, [Value(1), Variable('x')])
+        False
+        >>> Action('a', True, [Value(1), Variable('x')]) == Action('a', True, [Value(2), Variable('x')])
+        False
+        >>> Action('a', True, [Value(1), Variable('x')]) == Action('a', True, [Value(1)])
+        False
+
+        @param other: the action to compare
+        @type other: C{Action}
+        @return: C{True} if the two actions are equal, C{False}
+          otherwise
+        @rtype: C{bool}
+        """
+        if self.name != other.name :
+            return False
+        elif self.send != other.send :
+            return False
+        elif len(self.params) != len(other.params) :
+            return False
+        for p, q in zip(self.params, other.params) :
+            if p != q :
+                return False
+        return True
+    def __ne__ (self, other) :
+        return not (self == other)
+    def copy (self, subst=None) :
+        """Copy the action, optionally substituting its parameters.
+
+        >>> a = Action('a', True, [Variable('x'), Value(2)])
+        >>> a.copy()
+        Action('a', True, [Variable('x'), Value(2)])
+        >>> a = Action('a', True, [Variable('x'), Value(2)])
+        >>> a.copy(Substitution(x=Value(3)))
+        Action('a', True, [Value(3), Value(2)])
+
+        @param subst: if not C{None}, a substitution to apply to the
+          parameters of the copy
+        @type subst: C{None} or C{Substitution} mapping variables
+          names to C{Value} or C{Variable}
+        @return: a copy of the action, substituted by C{subst} if not
+          C{None}
+        @rtype: C{Action}
+        """
+        result = self.__class__(self.name, self.send,
+                                [p.copy() for p in self.params])
+        if subst is not None :
+            result.substitute(subst)
+        return result
+    def substitute (self, subst) :
+        """Substitute the parameters according to C{subst}
+
+        >>> a = Action('a', True, [Variable('x'), Value(2)])
+        >>> a.substitute(Substitution(x=Value(3)))
+        >>> a
+        Action('a', True, [Value(3), Value(2)])
+
+        @param subst: a substitution to apply to the parameters
+        @type subst: C{Substitution} mapping variables names to
+          C{Value} or C{Variable}
+        """
+        for i, p in enumerate(self.params) :
+            if isinstance(p, Variable) and p.name in subst :
+                self.params[i] = subst(p.name)
+    def vars (self) :
+        """
+        >>> Action('a', True, [Value(3), Variable('x'), Variable('y'), Variable('x')]).vars() == set(['x', 'y'])
+        True
+
+        @return: the set of variable names appearing in the parameters
+          of the action
+        @rtype: C{set} of C{str}
+        """
+        return set(p.name for p in self.params if isinstance(p, Variable))
+    def __and__ (self, other) :
+        """Compute an unification of two conjugated actions.
+
+        An unification is a C{Substitution} that maps variable names
+        to C{Variable} or C{Values}. If both actions are substituted
+        by this unification, their parameters lists become equal. If
+        no unification can be found, C{ConstraintError} is raised (or,
+        rarely, C{DomainError} depending on the cause of the failure).
+
+        >>> s = Action('a', True, [Value(3), Variable('x'), Variable('y'), Variable('x')])
+        >>> r = Action('a', False, [Value(3), Value(2), Variable('t'), Variable('z')])
+        >>> u = s & r
+        >>> u == Substitution(y=Variable('t'), x=Value(2), z=Value(2))
+        True
+        >>> s.substitute(u)
+        >>> r.substitute(u)
+        >>> s.params == r.params
+        True
+        >>> s.params
+        [Value(3), Value(2), Variable('t'), Value(2)]
+
+        >>> s = Action('a', True, [Value(2), Variable('x'), Variable('y'), Variable('x')])
+        >>> r = Action('a', False, [Value(3), Value(2), Variable('t'), Variable('z')])
+        >>> try : s & r
+        ... except ConstraintError : print(sys.exc_info()[1])
+        incompatible values
+        >>> r = Action('a', False, [Value(2), Value(2), Variable('t')])
+        >>> try : s & r
+        ... except ConstraintError : print(sys.exc_info()[1])
+        arities do not match
+        >>> r = Action('b', False, [Value(3), Value(2), Variable('t'), Variable('z')])
+        >>> try : s & r
+        ... except ConstraintError : print(sys.exc_info()[1])
+        actions not conjugated
+        >>> r = Action('a', True, [Value(3), Value(2), Variable('t'), Variable('z')])
+        >>> try : s & r
+        ... except ConstraintError : print(sys.exc_info()[1])
+        actions not conjugated
+
+        @param other: the other action to unify with
+        @type other: C{Action}
+        @return: a substitution that unify both actions
+        @rtype: C{Substitution}
+        """
+        if (self.name != other.name) or (self.send == other.send) :
+            raise ConstraintError("actions not conjugated")
+        elif len(self) != len(other) :
+            raise ConstraintError("arities do not match")
+        result = Substitution()
+        for x, y in zip(self.params, other.params) :
+            # apply the unifier already computed
+            if isinstance(x, Variable) and x.name in result :
+                x = result(x.name)
+            if isinstance(y, Variable) and y.name in result :
+                y = result(y.name)
+            # unify the current pair of parameters
+            if isinstance(x, Value) and isinstance(y, Value) :
+                if x.value != y.value :
+                    raise ConstraintError("incompatible values")
+            elif isinstance(x, Variable) and isinstance(y, Value) :
+                result += Substitution({x.name : y.copy()})
+            elif isinstance(x, Value) and isinstance(y, Variable) :
+                result += Substitution({y.name : x.copy()})
+            elif isinstance(x, Variable) and isinstance(y, Variable) :
+                if x.name != y.name :
+                    result += Substitution({x.name : y.copy()})
+            else :
+                raise ConstraintError("unexpected action parameter")
+        return result
+
+class MultiAction (object) :
+    def __init__ (self, actions) :
+        """
+        >>> try : MultiAction([Action('a', True, [Variable('x')]),
+        ...                    Action('a', False, [Value(2)])])
+        ... except ConstraintError : print(sys.exc_info()[1])
+        conjugated actions in the same multiaction
+
+        @param actions: a collection of actions with no conjugated
+          actions in it
+        @type actions: C{list} of C{Action}
+        """
+        self._actions = []
+        self._sndrcv = {}
+        self._count = {}
+        for act in actions :
+            self.add(act)
+    __pnmltag__ = "multiaction"
+    def __pnmldump__ (self) :
+        """
+        >>> MultiAction([Action('a', True, [Variable('x')]),
+        ...              Action('b', False, [Variable('y'), Value(2)])
+        ...             ]).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>...
+         <multiaction>
+          <action name="a" send="True">
+           <variable>
+            x
+           </variable>
+          </action>
+          <action name="b" send="False">
+           <variable>
+            y
+           </variable>
+           <value>
+            <object type="int">
+             2
+            </object>
+           </value>
+          </action>
+         </multiaction>
+        </pnml>
+        """
+        return Tree(self.__pnmltag__, None,
+                    *(Tree.from_obj(action) for action in self._actions))
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """
+        >>> t = MultiAction([Action('a', True, [Variable('x')]),
+        ...                  Action('b', False, [Variable('y'), Value(2)])
+        ...                 ]).__pnmldump__()
+        >>> MultiAction.__pnmlload__(t)
+        MultiAction([Action('a', True, [Variable('x')]),
+                     Action('b', False, [Variable('y'), Value(2)])])
+        """
+        return cls(child.to_obj() for child in tree.children)
+    def __repr__ (self) :
+        """
+        >>> MultiAction([Action('a', True, [Variable('x')]),
+        ...              Action('b', False, [Variable('y'), Value(2)])])
+        MultiAction([Action('a', True, [Variable('x')]),
+                     Action('b', False, [Variable('y'), Value(2)])])
+        """
+        return "%s([%s])" % (self.__class__.__name__,
+                             ", ".join(repr(act) for act in self._actions))
+    def __str__ (self) :
+        """
+        >>> str(MultiAction([Action('a', True, [Variable('x')]),
+        ...                  Action('b', False, [Variable('y'), Value(2)])]))
+        '[a!(x), b?(y,2)]'
+        """
+        return "[%s]" % ", ".join(str(act) for act in self._actions)
+    def send (self, name) :
+        """Returns the send flag of the action C{name} in this
+        multiaction.
+
+        This value is unique as conjugated actions are forbidden in
+        the same multiaction.
+
+        >>> m = MultiAction([Action('a', True, [Variable('x')]),
+        ...                  Action('b', False, [Variable('y'), Value(2)])])
+        >>> m.send('a'), m.send('b')
+        (True, False)
+        """
+        return self._sndrcv[name]
+    def add (self, action) :
+        """Add an action to the multiaction.
+
+        This may raise C{ConstraintError} if the added action is
+        conjugated to one that already belongs to the multiaction.
+
+        @param action: the action to add
+        @type action: C{Action}
+        """
+        if self._sndrcv.get(action.name, action.send) != action.send :
+            raise ConstraintError("conjugated actions in the same multiaction")
+        self._sndrcv[action.name] = action.send
+        self._count[action.name] = self._count.get(action.name, 0) + 1
+        self._actions.append(action)
+    def remove (self, action) :
+        """Remove an action from the multiaction.
+
+        This may raise C{ValueError} if the removed action does
+        belongs to the multiaction.
+
+        @param action: the action to remove
+        @type action: C{Action}
+        """
+        self._actions.remove(action)
+        self._count[action.name] -= 1
+        if self._count[action.name] == 0 :
+            del self._count[action.name]
+            del self._sndrcv[action.name]
+    def __iter__ (self) :
+        """Iterate over the actions in the multiaction.
+
+        >>> list(MultiAction([Action('a', True, [Variable('x')]),
+        ...                   Action('b', False, [Variable('y'), Value(2)])]))
+        [Action('a', True, [Variable('x')]),
+         Action('b', False, [Variable('y'), Value(2)])]
+        """
+        for action in self._actions :
+            yield action
+    def __len__ (self) :
+        """Return the number of actions in a multiaction.
+
+        >>> len(MultiAction([Action('a', True, [Variable('x')]),
+        ...                  Action('b', False, [Variable('y'), Value(2)])]))
+        2
+
+        @return: the number of contained actions
+        @rtype: non negative C{int}
+        """
+        return len(self._actions)
+    def substitute (self, subst) :
+        """Substitute bu C{subt} all the actions in the multiaction.
+
+        >>> m = MultiAction([Action('a', True, [Variable('x')]),
+        ...                  Action('b', False, [Variable('y'), Variable('x')])])
+        >>> m.substitute(Substitution(x=Value(4)))
+        >>> m
+        MultiAction([Action('a', True, [Value(4)]),
+                     Action('b', False, [Variable('y'), Value(4)])])
+        """
+        for action in self._actions :
+            action.substitute(subst)
+    def copy (self, subst=None) :
+        """ Copy the multiaction (and the actions is contains)
+        optionally substituting it.
+
+        @param subst: if not C{None}, the substitution to apply to the
+          copy.
+        @type subst: C{None} or C{Substitution}
+        @return: a copy of the multiaction, optionally substituted
+        @rtype: C{MultiAction}
+        """
+        result = self.__class__(act.copy() for act in self._actions)
+        if subst is not None :
+            result.substitute(subst)
+        return result
+    def __contains__ (self, action) :
+        """Search an action in the multiaction.
+
+        The searched action may be a complete C{Action}, just an
+        action name, or a pair C{(name, send_flag)}.
+
+        >>> m = MultiAction([Action('a', True, [Variable('x'), Value(2)]),
+        ...                  Action('a', True, [Value(3), Variable('y')]),
+        ...                  Action('b', False, [Variable('x'), Variable('y')])])
+        >>> 'a' in m, 'b' in m, 'c' in m
+        (True, True, False)
+        >>> ('a', True) in m, ('a', False) in m
+        (True, False)
+        >>> Action('a', True, [Variable('x'), Value(2)]) in m
+        True
+        >>> Action('a', True, [Variable('x')]) in m
+        False
+        >>> Action('a', False, [Variable('x'), Value(2)]) in m
+        False
+        >>> Action('c', True, [Variable('x'), Value(2)]) in m
+        False
+
+        @param action: an complete action, or its name or its name and
+          send flag
+        @type action: C{Action} or C{str} or C{tuple(str, bool)}
+        @return: C{True} if the specified action was found, C{False}
+          otherwise
+        @rtype: C{bool}
+        """
+        if isinstance(action, Action) :
+            return action in self._actions
+        elif isinstance(action, tuple) and len(action) == 2 :
+            return (action[0] in self._sndrcv
+                    and self._sndrcv[action[0]] == action[1])
+        elif isinstance(action, str) :
+            return action in self._count
+        else :
+            raise ValueError("invalid action specification")
+    def __add__ (self, other) :
+        """Create a multiaction by adding the actions of two others.
+
+        >>> m = MultiAction([Action('a', True, [Variable('x'), Value(2)]),
+        ...                  Action('a', True, [Value(3), Variable('y')]),
+        ...                  Action('b', False, [Variable('x'), Variable('y')])])
+        >>> m + m
+        MultiAction([Action('a', True, [Variable('x'), Value(2)]),
+                     Action('a', True, [Value(3), Variable('y')]),
+                     Action('b', False, [Variable('x'), Variable('y')]),
+                     Action('a', True, [Variable('x'), Value(2)]),
+                     Action('a', True, [Value(3), Variable('y')]),
+                     Action('b', False, [Variable('x'), Variable('y')])])
+        >>> m + Action('c', True, [])
+        MultiAction([Action('a', True, [Variable('x'), Value(2)]),
+                     Action('a', True, [Value(3), Variable('y')]),
+                     Action('b', False, [Variable('x'), Variable('y')]),
+                     Action('c', True, [])])
+
+        @param other: the other multiaction to combine or a single
+          action
+        @type other: C{MultiAction} or C{Action}
+        @return: the concatenated multiaction
+        @rtype: C{MultiAction}
+        """
+        if isinstance(other, Action) :
+            other = self.__class__([other])
+        result = self.copy()
+        for action in other._actions :
+            result.add(action)
+        return result
+    def __sub__ (self, other) :
+        """Create a multiaction by substracting the actions of two others.
+
+        >>> m = MultiAction([Action('a', True, [Variable('x'), Value(2)]),
+        ...                  Action('a', True, [Value(3), Variable('y')]),
+        ...                  Action('b', False, [Variable('x'), Variable('y')])])
+        >>> m - m
+        MultiAction([])
+        >>> m - Action('b', False, [Variable('x'), Variable('y')])
+        MultiAction([Action('a', True, [Variable('x'), Value(2)]),
+                     Action('a', True, [Value(3), Variable('y')])])
+
+        @param other: the other multiaction to combine or a single
+          action
+        @type other: C{MultiAction} or C{Action}
+        @return: the resulting multiaction
+        @rtype: C{MultiAction}
+        """
+        if isinstance(other, Action) :
+            other = self.__class__([other])
+        result = self.copy()
+        for action in other._actions :
+            result.remove(action)
+        return result
+    def vars (self) :
+        """Return the set of variable names used in all the actions of
+        the multiaction.
+
+        >>> MultiAction([Action('a', True, [Variable('x'), Value(2)]),
+        ...              Action('a', True, [Value(3), Variable('y')]),
+        ...              Action('b', False, [Variable('x'), Variable('z')])]).vars() == set(['x', 'y', 'z'])
+        True
+
+        @return: the set of variable names
+        @rtype: C{set} of C{str}
+        """
+        result = set()
+        for action in self._actions :
+            result.update(action.vars())
+        return result
+    def synchronise (self, other, name) :
+        """Search all the possible synchronisation on an action name
+        with another multiaction.
+
+        This method returns an iterator that yields for each possible
+        synchronisation a 4-tuple whose components are:
+
+        1. The sending action that did synchronise, it is already
+           unified, so the corresponding receiving action is just the
+           same with the reversed send flag.
+
+        2. The multiaction resulting from the synchronisation that is
+           also unified.
+
+        3. The substitution that must be applied to the transition
+           that provided the sending action.
+
+        4. The substitution that must be applied to the transition
+           that provided the receiving action.
+
+        >>> m = MultiAction([Action('a', True, [Variable('x'), Value(2)]),
+        ...                  Action('a', True, [Value(3), Variable('y')]),
+        ...                  Action('b', False, [Variable('x'), Variable('y')])])
+        >>> n = MultiAction([Action('a', False, [Variable('w'), Variable('y')]),
+        ...                  Action('c', False, [Variable('y')])])
+        >>> for a, x, u, v in m.synchronise(n, 'a') :
+        ...    print('%s %s %s %s' % (str(a), str(x), list(sorted(u.items())), list(sorted(v.items()))))
+        a!(w,2) [a!(3,y), b?(w,y), c?(a)] [('a', Value(2)), ('x', Variable('w'))] [('a', Value(2)), ('x', Variable('w')), ('y', Variable('a'))]
+        a!(3,a) [a!(x,2), b?(x,a), c?(a)] [('w', Value(3)), ('y', Variable('a'))] [('w', Value(3)), ('y', Variable('a'))]
+
+        @param other: the other multiaction to synchronise with
+        @type other: C{MultiAction}
+        @param name: the name of the action to synchronise on
+        @type name: C{str}
+        @return: an iterator over the possible synchronisations
+        @rtype: iterator of C{tuple(Action, MultiAction, Substitution, Substitution)}
+        """
+        renamer = Substitution()
+        common = self.vars() & other.vars()
+        if len(common) > 0 :
+            names = WordSet(common)
+            for var in common :
+                renamer += Substitution({var : Variable(names.fresh(add=True))})
+        for left in (act for act in self._actions if act.name == name) :
+            for right in (act for act in other._actions if act.name == name
+                          if act.send != left.send) :
+                _right = right.copy(renamer)
+                try :
+                    unifier = left & _right
+                except :
+                    continue
+                _unifier = unifier * renamer
+                _self = self - left
+                _self.substitute(unifier)
+                _other = other - right
+                _other.substitute(_unifier)
+                yield left.copy(unifier), _self + _other, unifier, _unifier
+
+@snakes.plugins.plugin("snakes.nets")
+def extend (module) :
+    class Transition (module.Transition) :
+        def __init__ (self, name, guard=None, **args) :
+            self.actions = MultiAction(args.pop("actions", []))
+            module.Transition.__init__(self, name, guard, **args)
+        def vars (self) :
+            return module.Transition.vars(self) | self.actions.vars()
+        def substitute (self, subst) :
+            module.Transition.substitute(self, subst)
+            self.actions.substitute(subst)
+        def copy (self, name=None, **args) :
+            actions = args.pop("actions", None)
+            result = module.Transition.copy(self, name, **args)
+            if actions is None :
+                result.actions = self.actions.copy()
+            else :
+                result.actions = MultiAction(actions)
+            return result
+        def __pnmldump__ (self) :
+            """
+            >>> m = MultiAction([Action('a', True, [Variable('x')]),
+            ...                  Action('b', False, [Variable('y'), Value(2)])])
+            >>> Transition('t', actions=m).__pnmldump__()
+            <?xml version="1.0" encoding="utf-8"?>
+            <pnml>...
+             <transition id="t">
+              <multiaction>
+               <action name="a" send="True">
+                <variable>
+                 x
+                </variable>
+               </action>
+               <action name="b" send="False">
+                <variable>
+                 y
+                </variable>
+                <value>
+                 <object type="int">
+                  2
+                 </object>
+                </value>
+               </action>
+              </multiaction>
+             </transition>
+            </pnml>
+            """
+            result = module.Transition.__pnmldump__(self)
+            result.add_child(Tree.from_obj(self.actions))
+            return result
+        @classmethod
+        def __pnmlload__ (cls, tree) :
+            """
+            >>> m = MultiAction([Action('a', True, [Variable('x')]),
+            ...                  Action('b', False, [Variable('y'), Value(2)])])
+            >>> t = Transition('t', actions=m).__pnmldump__()
+            >>> Transition.__pnmlload__(t).actions
+            MultiAction([Action('a', True, [Variable('x')]),
+                         Action('b', False, [Variable('y'), Value(2)])])
+            """
+            result = new_instance(cls, module.Transition.__pnmlload__(tree))
+            result.actions = Tree.to_obj(tree.child(MultiAction.__pnmltag__))
+            return result
+    class PetriNet (module.PetriNet) :
+        def synchronise (self, name) :
+            snd = []
+            rcv = []
+            for trans in self.transition() :
+                if (name, True) in trans.actions :
+                    snd.append(trans)
+                elif (name, False) in trans.actions :
+                    rcv.append(trans)
+            loop = True
+            done = set()
+            while loop :
+                loop = False
+                for _snd in snd :
+                    for _rcv in rcv :
+                        if (_snd.name, _rcv.name) in done :
+                            continue
+                        try :
+                            new = _snd.actions.synchronise(_rcv.actions, name)
+                        except ConstraintError :
+                            continue
+                        for a, m, s, r in new :
+                            t = self._synchronise(_snd, s, _rcv, r, m, a)
+                            if (name, True) in t.actions :
+                                snd.append(t)
+                                loop = True
+                            elif (name, False) in t.actions :
+                                rcv.append(t)
+                                loop = True
+                        done.add((_snd.name, _rcv.name))
+        def _synchronise (self, snd, s, rcv, r, actions, sync) :
+            collect = []
+            varset = WordSet()
+            for trans, subst in ((snd, s), (rcv, r)) :
+                new = "%s%s" % (trans.name, str(subst))
+                self.copy_transition(trans.name, new)
+                collect.append(new)
+                new = self.transition(new)
+                nv = new.vars()
+                for v in varset & nv :
+                    new.substitute(Substitution({v : varset.fresh(add=True)}))
+                varset.update(nv)
+                for var, val in subst.items() :
+                    if isinstance(val, Variable) :
+                        new.substitute(Substitution({var : val.name}))
+                    for place, label in new.input() :
+                        if var in label.vars() :
+                            self.remove_input(place.name, new.name)
+                            self.add_input(place.name, new.name,
+                                           label.replace(Variable(var), val))
+                    for place, label in new.output() :
+                        if var in label.vars() :
+                            self.remove_output(place.name, new.name)
+                            self.add_output(place.name, new.name,
+                                            label.replace(Variable(var), val))
+            merged = "(%s%s+%s%s)[%s]" % (snd.name, str(s), rcv.name, str(s),
+                                          str(sync).replace("?", "").replace("!", ""))
+            self.merge_transitions(merged, collect, actions=actions)
+            for name in collect :
+                self.remove_transition(name)
+            return self.transition(merged)
+        def restrict (self, action) :
+            removed = [trans.name for trans in self.transition()
+                       if action in trans.actions]
+            for trans in removed :
+                self.remove_transition(trans)
+        def scope (self, action) :
+            self.synchronise(action)
+            self.restrict(action)
+        def merge_transitions (self, target, sources, **args) :
+            actions = args.pop("actions", None)
+            module.PetriNet.merge_transitions(self, target, sources, **args)
+            if actions is None :
+                actions = MultiAction()
+                for src in sources :
+                    actions += self.transition(src).actions
+                self.transition(target).actions = actions
+            else :
+                self.transition(target).actions = MultiAction(actions)
+        def copy_transition (self, source, targets, **args) :
+            actions = args.pop("actions", None)
+            module.PetriNet.copy_transition(self, source, targets, **args)
+            if actions is None :
+                actions = self.transition(source).actions
+            else :
+                actions = MultiAction(actions)
+            old = self.transition(source)
+            for trans in iterate(targets) :
+                self.transition(trans).actions = actions.copy()
+    return PetriNet, Transition, Action, MultiAction

+"""A module to save and load objects in PNML.
+
+Petri nets objects are saved in PNML, other Python objects are saved
+in a readable format when possible and pickled as a last solution.
+This should result in a complete PNML serialization of any object.
+"""
+
+import xml.dom.minidom
+import pickle
+import sys, inspect, os, os.path, imp, pkgutil
+import snakes, snakes.plugins
+from snakes import SnakesError
+from snakes.compat import *
+if PY3 :
+    import ast
+
+try :
+    builtins = sys.modules["__builtin__"]
+except KeyError :
+    builtins = sys.modules["builtins"]
+
+def _snk_import (name) :
+    "Properly import a module, including a plugin"
+    if name.startswith("snakes.plugins.") :
+        return snakes.plugins.load(name, "snakes.nets")
+    else :
+        return __import__(name, fromlist=["__name__"])
+
+def _snk_modules () :
+    "List all SNAKES' modules"
+    queue = ["snakes"]
+    while len(queue) > 0 :
+        modname = queue.pop(0)
+        try :
+            mod = _snk_import(modname)
+        except :
+            continue
+        yield modname, mod
+        importer = pkgutil.ImpImporter(mod.__path__[0])
+        for name, ispkg in importer.iter_modules(prefix=mod.__name__ + ".") :
+            if ispkg :
+                queue.append(name)
+            else :
+                try :
+                    yield name, _snk_import(name)
+                except :
+                    pass
+
+def _snk_tags () :
+    "Lists all PNML tags found in SNAKES"
+    for modname, mod in _snk_modules() :
+        for clsname, cls in inspect.getmembers(mod, inspect.isclass) :
+            if cls.__module__ == modname and "__pnmltag__" in cls.__dict__ :
+                yield cls.__pnmltag__, modname, clsname
+
+class _set (object) :
+    """Set where items are iterated by order of insertion
+    """
+    def __init__ (self, elements=[]) :
+        """
+        >>> _set([4, 5, 1, 2, 4])
+        _set([4, 5, 1, 2])
+        """
+        self._data = {}
+        self._last = 0
+        for e in elements :
+            self.add(e)
+    def __repr__ (self) :
+        """
+        >>> _set([4, 5, 1, 2, 4])
+        _set([4, 5, 1, 2])
+        """
+        return "%s([%s])" % (self.__class__.__name__,
+                             ", ".join(repr(x) for x in self))
+    def add (self, element) :
+        """
+        >>> s = _set([4, 5, 1, 2, 4])
+        >>> s.add(0)
+        >>> s
+        _set([4, 5, 1, 2, 0])
+        >>> s.add(5)
+        >>> s
+        _set([4, 5, 1, 2, 0])
+        """
+        if element not in self._data :
+            self._data[element] = self._last
+            self._last += 1
+    def __contains__ (self, element) :
+        """
+        >>> 4 in _set([4, 5, 1, 2, 4])
+        True
+        >>> 0 in _set([4, 5, 1, 2, 4])
+        False
+        """
+        return element in self._data
+    def _2nd (self, pair) :
+        """
+        >>> _set()._2nd((1, 2))
+        2
+        """
+        return pair[1]
+    def __iter__ (self) :
+        """
+        >>> list(_set([4, 5, 1, 2, 4]))
+        [4, 5, 1, 2]
+        """
+        return (k for k, v in sorted(self._data.items(), key=self._2nd))
+    def discard (self, element) :
+        """
+        >>> s = _set([4, 5, 1, 2, 4])
+        >>> s.discard(0)
+        >>> s.discard(4)
+        >>> s
+        _set([5, 1, 2])
+        """
+        if element in self._data :
+            del self._data[element]
+    def remove (self, element) :
+        """
+        >>> s = _set([4, 5, 1, 2, 4])
+        >>> s.remove(0)
+        Traceback (most recent call last):
+         ...
+        KeyError: ...
+        >>> s.remove(4)
+        >>> s
+        _set([5, 1, 2])
+        """
+        del self._data[element]
+    def copy (self) :
+        """
+        >>> _set([4, 5, 1, 2, 4]).copy()
+        _set([4, 5, 1, 2])
+        """
+        return self.__class__(self)
+    def __iadd__ (self, other) :
+        """
+        >>> s = _set([4, 5, 1, 2, 4])
+        >>> s += range(7)
+        >>> s
+        _set([4, 5, 1, 2, 0, 3, 6])
+        """
+        for element in other :
+            self.add(element)
+        return self
+    def __add__ (self, other) :
+        """
+        >>> _set([4, 5, 1, 2, 4]) + range(7)
+        _set([4, 5, 1, 2, 0, 3, 6])
+        """
+        result = self.copy()
+        result += other
+        return result
+    def __len__ (self) :
+        """
+        >>> len(_set([4, 5, 1, 2, 4]))
+        4
+        """
+        return len(self._data)
+
+class Tree (object) :
+    """Abstraction of a PNML tree
+
+    >>> Tree('tag', 'data', Tree('child', None), attr='attribute value')
+    <?xml version="1.0" encoding="utf-8"?>
+    <pnml>
+     <tag attr="attribute value">
+      <child/>
+      data
+     </tag>
+    </pnml>
+    """
+    def __init__ (self, _name, _data, *_children, **_attributes) :
+        """Initialize a PNML tree
+
+        >>> Tree('tag', 'data',
+        ...      Tree('first_child', None),
+        ...      Tree('second_child', None),
+        ...      first_attr='attribute value',
+        ...      second_attr='another value')
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <tag first_attr="attribute value" second_attr="another value">
+          <first_child/>
+          <second_child/>
+          data
+         </tag>
+        </pnml>
+
+        Note: parameters names start with a '_' in order to allow for
+        using them as attributes.
+
+        @param _name: the name of the tag
+        @type _name: C{str}
+        @param _data: the text held by the tag or C{None}
+        @type _data: C{str} or C{None}
+        @param _children: children nodes
+        @type _children: C{Tree}
+        @param _attributes: attributes and values of the tag
+        @type _attributes: C{str}
+        """
+        self.name = _name
+        if _data is not None and _data.strip() == "" :
+            _data = None
+        self.data = _data
+        self.children = list(_children)
+        self.attributes = _attributes
+    @classmethod
+    def _load_tags (_class) :
+        if not hasattr(_class, "_tags") :
+            _class._tags = {}
+            for tag, mod, cls in _snk_tags() :
+                if tag not in _class._tags :
+                    _class._tags[tag] = (mod, cls)
+    def _update_node (self, doc, node) :
+        for key, val in self.attributes.items() :
+            node.setAttribute(key, val)
+        for child in self.children :
+            node.appendChild(child._to_dom(doc))
+        if self.data is not None :
+            node.appendChild(doc.createTextNode(self.data))
+    def _to_dom (self, doc) :
+        result = doc.createElement(self.name)
+        self._update_node(doc, result)
+        return result
+    def to_pnml (self) :
+        """Dumps a PNML tree to an XML string
+
+        >>> print(Tree('tag', 'data', Tree('child', None), attr='value').to_pnml())
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <tag attr="value">
+          <child/>
+          data
+         </tag>
+        </pnml>
+
+        @return: the XML string that represents the PNML tree
+        @rtype: C{str}
+        """
+        if self.name == "pnml" :
+            tree = self
+        else :
+            tree = self.__class__("pnml", None, self)
+        try :
+            plugins = _set(self.__plugins__)
+        except AttributeError :
+            plugins = _set()
+        for node in self.nodes() :
+            if hasattr(node, "_plugins") :
+                plugins += node._plugins
+        if len(plugins) > 0 :
+            tree.children.insert(0, Tree("snakes", None,
+                                         Tree("plugins", None,
+                                              Tree.from_obj(tuple(plugins))),
+                                         version=snakes.version))
+        impl = xml.dom.minidom.getDOMImplementation()
+        doc = impl.createDocument(None, "pnml", None)
+        node = tree._to_dom(doc)
+        tree._update_node(doc, doc.documentElement)
+        if len(plugins) > 0 :
+            del tree.children[0]
+        r = doc.toprettyxml(indent=" ",
+                            encoding=snakes.defaultencoding).strip()
+        if PY3 :
+            return r.decode()
+        else :
+            return r
+    @classmethod
+    def from_dom (cls, node) :
+        """Load a PNML tree from an XML DOM representation
+
+        >>> src = Tree('object', '42', type='int').to_pnml()
+        >>> dom = xml.dom.minidom.parseString(src)
+        >>> Tree.from_dom(dom.documentElement)
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <object type="int">
+          42
+         </object>
+        </pnml>
+
+        @param node: the DOM node to load
+        @type node: C{xml.dom.minidom.Element}
+        @return: the loaded PNML tree
+        @rtype: C{Tree}
+        """
+        result = cls(node.tagName, node.nodeValue)
+        for i in range(node.attributes.length) :
+            name = node.attributes.item(i).localName
+            result[name] = str(node.getAttribute(name))
+        if node.hasChildNodes() :
+            for child in node.childNodes :
+                if child.nodeType == child.TEXT_NODE :
+                    result.add_data(str(child.data))
+                elif child.nodeType == child.ELEMENT_NODE :
+                    result.add_child(cls.from_dom(child))
+        return result
+    @classmethod
+    def from_pnml (cls, source, plugins=[]) :
+        """Load a PNML tree from an XML string representation
+
+        >>> src = Tree('object', '42', type='int').to_pnml()
+        >>> Tree.from_pnml(src)
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <object type="int">
+          42
+         </object>
+        </pnml>
+
+        @param source: the XML string to load or an opened file that
+          contains it
+        @type source: C{str} or C{file}
+        @return: the loaded PNML tree
+        @rtype: C{Tree}
+        """
+        try :
+            doc = xml.dom.minidom.parse(source)
+        except :
+            doc = xml.dom.minidom.parseString(source)
+        result = cls.from_dom(doc.documentElement)
+        plugins = _set(plugins)
+        cls._load_tags()
+        tag2obj = {}
+        trash = []
+        for node in result.nodes() :
+            node._tag2obj = tag2obj
+            if node.has_child("snakes") :
+                snk = node.child("snakes")
+                trash.append((node, snk))
+                plugins += snk.child("plugins").child("object").to_obj()
+            if node.name in cls._tags :
+                modname, clsname = cls._tags[node.name]
+                if modname.startswith("snakes.plugins.") :
+                    plugins.add(modname)
+                elif node.name not in tag2obj :
+                    tag2obj[node.name] = getattr(_snk_import(modname), clsname)
+        for parent, child in trash :
+            parent.children.remove(child)
+        plugins.discard("snakes.nets")
+        nets = snakes.plugins.load(plugins, "snakes.nets")
+        for name, obj in inspect.getmembers(nets, inspect.isclass) :
+            # Skip classes that cannot be serialised to PNML
+            try :
+                tag = obj.__pnmltag__
+            except AttributeError :
+                continue
+            # Get the last class in the hierarchy that has the same
+            # "__pnmltag__" and is in the same module. This is useful
+            # for instance for snakes.typing.Type and its subclasses:
+            # the former should be called used of the laters because
+            # it dispatches the call to "__pnmlload__" according to
+            # "__pnmltype__".
+            bases = [obj] + [c for c in inspect.getmro(obj)
+                             if (c.__module__ == obj.__module__)
+                             and hasattr(c, "__pnmltag__")
+                             and c.__pnmltag__ == tag]
+            tag2obj[tag] = bases[-1]
+        return result
+    def nodes (self) :
+        """Iterate over all the nodes (top-down) in a tree
+
+        >>> t = Tree('foo', None,
+        ...          Tree('bar', None),
+        ...          Tree('egg', None,
+        ...               Tree('spam', None)))
+        >>> for node in t.nodes() :
+        ...     print(str(node))
+        <PNML tree 'foo'>
+        <PNML tree 'bar'>
+        <PNML tree 'egg'>
+        <PNML tree 'spam'>
+
+        @return: an iterator on all the nodes in the tree, including
+          this one
+        @rtype: C{generator}
+        """
+        yield self
+        for child in self.children :
+            for node in child.nodes() :
+                yield node
+    def update (self, other) :
+        """Incorporates children, attributes and data from another
+        PNML tree
+
+        >>> t = Tree('foo', 'hello',
+        ...          Tree('bar', None),
+        ...          Tree('egg', None,
+        ...               Tree('spam', None)))
+        >>> o = Tree('foo', 'world',
+        ...          Tree('python', None),
+        ...          attr='value')
+        >>> t.update(o)
+        >>> t
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <foo attr="value">
+          <bar/>
+          <egg>
+           <spam/>
+          </egg>
+          <python/>
+          hello
+          world
+         </foo>
+        </pnml>
+        >>> o = Tree('oops', None,
+        ...          Tree('hello', None),
+        ...          attr='value')
+        >>> try : t.update(o)
+        ... except SnakesError : print(sys.exc_info()[1])
+        tag mismatch 'foo', 'oops'
+
+        @param other: the other tree to get data from
+        @type other: C{Tree}
+        @raise SnakesError: when C{other} has not the same tag as C{self}
+        """
+        if self.name != other.name :
+            raise SnakesError("tag mismatch '%s', '%s'" % (self.name, other.name))
+        self.children.extend(other.children)
+        self.attributes.update(other.attributes)
+        self.add_data(other.data)
+    def add_child (self, child) :
+        """Add a child to a PNML tree
+
+        >>> t = Tree('foo', None)
+        >>> t.add_child(Tree('bar', None))
+        >>> t
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <foo>
+          <bar/>
+         </foo>
+        </pnml>
+
+        @param child: the PNML tree to append
+        @type child: C{Tree}
+        """
+        self.children.append(child)
+    def add_data (self, data, sep='\n') :
+        """Appends data to the current node
+
+        >>> t = Tree('foo', None)
+        >>> t.add_data('hello')
+        >>> t
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <foo>
+          hello
+         </foo>
+        </pnml>
+        >>> t.add_data('world')
+        >>> t
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <foo>
+          hello
+          world
+         </foo>
+        </pnml>
+        >>> t.add_data('!', '')
+        >>> t
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <foo>
+          hello
+          world!
+         </foo>
+        </pnml>
+
+        @param data: the data to add
+        @type data: C{str}
+        @param sep: separator to insert between pieces of data
+        @type sep: C{str}
+        """
+        try :
+            data = data.strip()
+            if data != "" :
+                if self.data is None :
+                    self.data = data
+                else :
+                    self.data += sep + data
+        except :
+            pass
+    def __getitem__ (self, name) :
+        """Returns one attribute
+
+        >>> Tree('foo', None, x='egg', y='spam')['x']
+        'egg'
+        >>> Tree('foo', None, x='egg', y='spam')['z']
+        Traceback (most recent call last):
+          ...
+        KeyError: 'z'
+
+        @param name: the name of the attribute
+        @type name: C{str}
+        @return: the value of the attribute
+        @rtype: C{str}
+        @raise KeyError: if no such attribute is found
+        """
+        return self.attributes[name]
+    def __setitem__ (self, name, value) :
+        """Sets an attribute
+
+        >>> t = Tree('foo', None)
+        >>> t['egg'] = 'spam'
+        >>> t
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <foo egg="spam"/>
+        </pnml>
+
+        @param name: the name of the attribute
+        @type name: C{str}
+        @param value: the value of the attribute
+        @type value: C{str}
+        """
+        self.attributes[name] = value
+    def __iter__ (self) :
+        """Iterate over children nodes
+
+        >>> [str(node) for node in Tree('foo', None,
+        ...                             Tree('egg', None),
+        ...                             Tree('spam', None,
+        ...                                  Tree('bar', None)))]
+        ["<PNML tree 'egg'>", "<PNML tree 'spam'>"]
+
+        @return: an iterator over direct children of the node
+        @rtype: C{generator}
+        """
+        return iter(self.children)
+    def has_child (self, name) :
+        """Test if the tree has the given tag as a direct child
+
+        >>> t = Tree('foo', None,
+        ...          Tree('egg', None),
+        ...          Tree('spam', None,
+        ...               Tree('bar', None)))
+        >>> t.has_child('egg')
+        True
+        >>> t.has_child('bar')
+        False
+        >>> t.has_child('python')
+        False
+
+        @param name: tag name to search for
+        @type name: C{str}
+        @return: a Boolean value indicating wether such a child was
+          found or not
+        @rtype: C{bool}
+        """
+        for child in self :
+            if child.name == name :
+                return True
+        return False
+    def child (self, name=None) :
+        """Return the direct child that as the given tag
+
+        >>> t = Tree('foo', None,
+        ...          Tree('egg', 'first'),
+        ...          Tree('egg', 'second'),
+        ...          Tree('spam', None,
+        ...               Tree('bar', None)))
+        >>> t.child('spam')
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <spam>
+          <bar/>
+         </spam>
+        </pnml>
+        >>> try : t.child('python')
+        ... except SnakesError : print(sys.exc_info()[1])
+        no child 'python'
+        >>> try : t.child('bar')
+        ... except SnakesError : print(sys.exc_info()[1])
+        no child 'bar'
+        >>> try : t.child('egg')
+        ... except SnakesError : print(sys.exc_info()[1])
+        multiple children 'egg'
+        >>> try : t.child()
+        ... except SnakesError : print(sys.exc_info()[1])
+        multiple children
+
+        @param name: name of the tag to search for, if C{None}, the
+          fisrt child is returned if it is the only child
+        @type name: C{str} or C{None}
+        @return: the only child with the given name, or the only child
+          if no name is given
+        @rtype: C{Tree}
+        @raise SnakesError: when no child or more than one child could
+          be returned
+        """
+        result = None
+        for child in self :
+            if name is None or child.name == name :
+                if result is None :
+                    result = child
+                elif name is None :
+                    raise SnakesError("multiple children")
+                else :
+                    raise SnakesError("multiple children '%s'" % name)
+        if result is None :
+            raise SnakesError("no child '%s'" % name)
+        return result
+    def get_children (self, name=None) :
+        """Iterates over direct children having the given tag
+
+        >>> t = Tree('foo', None,
+        ...          Tree('egg', 'first'),
+        ...          Tree('egg', 'second'),
+        ...          Tree('spam', None,
+        ...               Tree('bar', None)))
+        >>> [str(n) for n in t.get_children()]
+        ["<PNML tree 'egg'>", "<PNML tree 'egg'>", "<PNML tree 'spam'>"]
+        >>> [str(n) for n in t.get_children('egg')]
+        ["<PNML tree 'egg'>", "<PNML tree 'egg'>"]
+        >>> [str(n) for n in t.get_children('python')]
+        []
+        >>> [str(n) for n in t.get_children('bar')]
+        []
+
+        @param name: tag to search for or C{None}
+        @type name: C{str} or C{None}
+        @return: iterator over all the children if C{name} is C{None},
+          or over the children with tag C{name} otherwise
+        @rtype: C{generator}
+        """
+        for child in self :
+            if name is None or child.name == name :
+                yield child
+    def __str__ (self) :
+        """Return a simple string representation of the node
+
+        >>> str(Tree('foo', None, Tree('child', None)))
+        "<PNML tree 'foo'>"
+
+        @return: simple string representation of the node
+        @rtype: C{str}
+        """
+        return "<PNML tree %r>" % self.name
+    def __repr__ (self) :
+        """Return a detailed representation of the node.
+
+        This is actually the XML text that corresponds to the C{Tree},
+        as returned by C{Tree.to_pnml}.
+
+        >>> print(repr(Tree('foo', None, Tree('child', None))))
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <foo>
+          <child/>
+         </foo>
+        </pnml>
+
+        @return: XML string representation of the node
+        @rtype: C{str}
+        """
+        return self.to_pnml()
+    _elementary = set(("str", "int", "float", "bool"))
+    _collection = set(("list", "tuple", "set"))
+    @classmethod
+    def from_obj (cls, obj) :
+        """Builds a PNML tree from an object.
+
+        Objects defined in SNAKES usually have a method
+        C{__pnmldump__} that handles the conversion, for instance:
+
+        >>> import snakes.nets
+        >>> Tree.from_obj(snakes.nets.Place('p'))
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <place id="p">
+          <type domain="universal"/>
+          <initialMarking>
+           <multiset/>
+          </initialMarking>
+         </place>
+        </pnml>
+
+        Most basic Python classes are handled has readable XML:
+
+        >>> Tree.from_obj(42)
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <object type="int">
+          42
+         </object>
+        </pnml>
+        >>> Tree.from_obj([1, 2, 3])
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <object type="list">
+          <object type="int">
+           1
+          </object>
+          <object type="int">
+           2
+          </object>
+          <object type="int">
+           3
+          </object>
+         </object>
+        </pnml>
+
+        Otherwise, the object is serialised using module C{pickle},
+        which allows to embed almost anything into PNML.
+
+        >>> import re
+        >>> Tree.from_obj(re.compile('foo|bar')) # serialized data replaced with '...'
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <object type="pickle">
+          ...
+         </object>
+        </pnml>
+
+        @param obj: the object to convert to PNML
+        @type obj: C{object}
+        @return: the corresponding PNML tree
+        @rtype: C{Tree}
+        """
+        try :
+            result = obj.__pnmldump__()
+            result._tag2obj = {result.name : obj}
+            if hasattr(obj, "__plugins__") :
+                result._plugins = obj.__plugins__
+            return result
+        except AttributeError :
+            pass
+        result = Tree("object", None)
+        _type = type(obj)
+        _name = _type.__name__
+        if _name in cls._elementary :
+            handler = result._set_elementary
+        elif _name in cls._collection :
+            handler = result._set_collection
+        elif inspect.ismethod(obj) :
+            handler = result._set_method
+            _name = "method"
+        elif inspect.isclass(obj) :
+            handler = result._set_class
+            _name = "class"
+        elif inspect.isroutine(obj) :
+            handler = result._set_function
+            _name = "function"
+        elif inspect.ismodule(obj) :
+            handler = result._set_module
+            _name = "module"
+        else :
+            try :
+                handler = getattr(result, "_set_" + _name)
+            except AttributeError :
+                handler = result._set_pickle
+                _name = "pickle"
+        result["type"] = _name
+        handler(obj)
+        return result
+    def _set_NoneType (self, value) :
+        pass
+    def _get_NoneType (self) :
+        pass
+    def _set_elementary (self, value) :
+        self.data = str(value)
+    def _get_elementary (self) :
+        if self["type"] == "bool" :
+            return self.data.strip() == "True"
+        return getattr(builtins, self["type"])(self.data)
+    def _set_collection (self, value) :
+        for v in value :
+            self.add_child(self.from_obj(v))
+    def _get_collection (self) :
+        return getattr(builtins, self["type"])(child.to_obj()
+                                               for child in self)
+    def _set_dict (self, value) :
+        for k, v in value.items() :
+            self.add_child(Tree("item", None,
+                                Tree("key", None, self.from_obj(k)),
+                                Tree("value", None, self.from_obj(v))))
+    def _get_dict (self) :
+        return dict((child.child("key").child("object").to_obj(),
+                     child.child("value").child("object").to_obj())
+                    for child in self)
+    def _native (self, obj) :
+        try :
+            if (obj.__module__ in ("__builtin__", "__builtins__", "builtins")
+                or obj.__module__ == "snakes"
+                or obj.__module__.startswith("snakes")
+                or inspect.isbuiltin(obj)) :
+                return True
+        except :
+            pass
+        try :
+            lib = os.path.dirname(inspect.getfile(inspect.getfile))
+            if os.path.isfile(lib) :
+                lib = os.path.dirname(lib)
+            lib += os.sep
+            try :
+                path = inspect.getfile(obj)
+            except :
+                path = inspect.getmodule(obj).__file__
+            return path.startswith(lib)
+        except :
+            return False
+    def _name (self, obj) :
+        try :
+            name = obj.__module__
+        except :
+            name = inspect.getmodule(obj).__name__
+        if name in ("__builtin__", "__builtins__", "builtins") :
+            return obj.__name__
+        else :
+            return name + "." + obj.__name__
+    def _set_class (self, value) :
+        if self._native(value) :
+            self["name"] = self._name(value)
+        else :
+            self._set_pickle(value)
+    def _get_class (self) :
+        if self.data :
+            return self._get_pickle()
+        elif "." in self["name"] :
+            module, name = self["name"].rsplit(".", 1)
+            return getattr(__import__(module, fromlist=[name]), name)
+        else :
+            return getattr(builtins, self["name"])
+    def _set_function (self, value) :
+        self._set_class(value)
+    def _get_function (self) :
+        return self._get_class()
+    def _set_method (self, value) :
+        self._set_function(value)
+        self["name"] = "%s.%s" % (self["name"], value.__name__)
+    def _get_method (self) :
+        if self.data :
+            return self._get_pickle()
+        module, cls, name = self["name"].rsplit(".", 2)
+        cls = getattr(__import__(module, fromlist=[name]), name)
+        return getattr(cls, name)
+    def _set_module (self, value) :
+        self["name"] = value.__name__
+    def _get_module (self) :
+        return __import__(self["name"], fromlist=["__name__"])
+    def _set_pickle (self, value) :
+        self["type"] = "pickle"
+        self.data = pickle.dumps(value)
+        if PY3 :
+            self.data = repr(self.data)
+    def _get_pickle (self) :
+        if PY3 :
+            return pickle.loads(ast.literal_eval(self.data))
+        else :
+            return pickle.loads(self.data)
+    def to_obj (self) :
+        """Build an object from its PNML representation
+
+        This is just the reverse as C{Tree.from_obj}, objects that
+        have a C{__pnmldump__} method should also have a
+        C{__pnmlload__} class method to perform the reverse operation,
+        together with an attribute C{__pnmltag__}. Indeed, when a PNML
+        node with tag name 'foo' has to be converted to an object, a
+        class C{C} such that C{C.__pnmltag__ == 'foo'} is searched in
+        module C{snakes.nets} and C{C.__pnmlload__(tree)} is called to
+        rebuild the object.
+
+        Standard Python objects and pickled ones are also recognised
+        and correctly rebuilt.
+
+        >>> import snakes.nets
+        >>> Tree.from_obj(snakes.nets.Place('p')).to_obj()
+        Place('p', MultiSet([]), tAll)
+        >>> Tree.from_obj(42).to_obj()
+        42
+        >>> Tree.from_obj([1, 2, 3]).to_obj()
+        [1, 2, 3]
+        >>> import re
+        >>> Tree.from_obj(re.compile('foo|bar')).to_obj()
+        <... object at ...>
+
+        @return: the Python object encoded by the PNML tree
+        @rtype: C{object}
+        """
+        if self.name == "pnml" :
+            if len(self.children) == 0 :
+                raise SnakesError("empty PNML content")
+            elif len(self.children) == 1 :
+                return self.child().to_obj()
+            else :
+                return tuple(child.to_obj() for child in self.children
+                             if child.name != "snakes")
+        elif self.name == "object" :
+            if self["type"] in self._elementary :
+                handler = self._get_elementary
+            elif self["type"] in self._collection :
+                handler = self._get_collection
+            else :
+                try :
+                    handler = getattr(self, "_get_" + self["type"])
+                except AttributeError :
+                    handler = self._get_pickle
+            return handler()
+        elif self.name != "snakes" :
+            try :
+                if self.name in self._tag2obj :
+                    return self._tag2obj[self.name].__pnmlload__(self)
+            except AttributeError :
+                pass
+        raise SnakesError("unsupported PNML tag '%s'" % self.name)
+
+def dumps (obj) :
+    """Dump an object to a PNML string
+
+    >>> print(dumps(42))
+    <?xml version="1.0" encoding="utf-8"?>
+    <pnml>
+     <object type="int">
+      42
+     </object>
+    </pnml>
+
+    @param obj: the object to dump
+    @type obj: C{object}
+    @return: the PNML that represents the object
+    @rtype: C{str}
+    """
+    return Tree.from_obj(obj).to_pnml()
+
+def loads (source, plugins=[]) :
+    """Load an object from a PNML string
+
+    >>> loads(dumps(42))
+    42
+
+    @param source: the data to parse
+    @type source: C{str}
+    @return: the object represented by the source
+    @rtype: C{object}
+    """
+    return Tree.from_pnml(source, plugins).to_obj()

+"""Typing system for places (and transitions guards).
+
+Types are contraint checkers to verify whether a value is in the type
+or not. For instance:
+
+>>> 5 in tInteger
+True
+>>> 4.3 in tInteger
+False
+
+The typechecking of several values is possible using the type as a
+function. It fails if one value is not in the type.
+
+>>> tInteger(5, 4, 6)
+True
+>>> tInteger(5, 4, 6.0)
+False
+
+Types can be composed in order to build more complexe types. For
+example:
+
+>>> 8 in (tInteger & ~Range(1, 5))
+True
+>>> 3 in (tInteger & ~Range(1, 5))
+False
+
+The various compositions are the same as sets operations, plus the
+complement: C{&}, C{|}, C{-}, C{^} and C{~} (complement).
+
+Various types are predefined (like C{tInteger}) the others can be
+constructed using the various classes in the module. Prefefined types
+are:
+
+ - C{tAll}: any value is in the type
+ - C{tNothing}: empty type
+ - C{tString}: string values
+ - C{tList}: lists values
+ - C{tInteger}: integer values
+ - C{tNatural}: non-negative integers
+ - C{tPositive}: strictly positive integers
+ - C{tFloat}: float values
+ - C{tNumber}: integers or float values
+ - C{tDict}: Python's C{dict} values
+ - C{tNone}: the single value C{None}
+ - C{tBoolean}: C{True} or C{False}
+ - C{tTuple}: tuple values
+ - C{tPair}: tuples of length two
+
+Types with finitely many elements can be iterated:
+
+>>> list(sorted(iter(CrossProduct(Range(0, 10, 2), tBoolean) & ~OneOf((4, True), (6, False)))))
+[(0, False), (0, True), (2, False), (2, True), (4, False), (6, True), (8, False), (8, True)]
+>>> list(iter(OneOf(1, 2, 3)))
+[1, 2, 3]
+>>> iter(tInteger)
+Traceback (most recent call last):
+...
+TypeError: ...
+>>> iter(~OneOf(1, 2, 3))
+Traceback (most recent call last):
+...
+TypeError: ...
+"""
+
+import inspect, sys
+from snakes.compat import *
+from snakes.data import cross
+from snakes.pnml import Tree
+
+def _iterable (obj, *types) :
+    for t in types :
+        try :
+            iter(t)
+        except :
+            def __iterable__ () :
+                raise ValueError("iteration over non-sequence")
+            obj.__iterable__ = __iterable__
+            break
+
+class Type (object) :
+    """Base class for all types.
+
+    Implement operations C{&}, C{|}, C{-}, C{^} and C{~} to build new
+    types. Also implement the typechecking of several values. All the
+    subclasses should implement the method C{__contains__} to
+    typecheck a single object.
+    """
+    def __init__ (self) :
+        """Abstract method
+
+        >>> Type()
+        Traceback (most recent call last):
+         ...
+        NotImplementedError: abstract class
+
+        @raise NotImplementedError: when called
+        """
+        raise NotImplementedError("abstract class")
+    def __eq__ (self, other) :
+        return (self.__class__ == other.__class__
+                and self.__dict__ == other.__dict__)
+    def __hash__ (self) :
+        return hash(repr(self))
+    def __and__ (self, other) :
+        """Intersection type.
+
+        >>> Instance(int) & Greater(0)
+        (Instance(int) & Greater(0))
+
+        @param other: the other type in the intersection
+        @type other: C{Type}
+        @return: the intersection of both types
+        @rtype: C{Type}
+        """
+        if other is self :
+            return self
+        else :
+            return _And(self, other)
+    def __or__ (self, other) :
+        """Union type.
+
+        >>> Instance(int) | Instance(bool)
+        (Instance(int) | Instance(bool))
+
+        @param other: the other type in the union
+        @type other: C{Type}
+        @return: the union of both types
+        @rtype: C{Type}
+        """
+        if other is self :
+            return self
+        else :
+            return _Or(self, other)
+    def __sub__ (self, other) :
+        """Substraction type.
+
+        >>> Instance(int) - OneOf([0, 1, 2])
+        (Instance(int) - OneOf([0, 1, 2]))
+
+        @param other: the other type in the substraction
+        @type other: C{Type}
+        @return: the type C{self} minus the type C{other}
+        @rtype: C{Type}
+        """
+        if other is self :
+            return tNothing
+        else :
+            return _Sub(self, other)
+    def __xor__ (self, other) :
+        """Disjoint union type.
+
+        >>> Greater(0) ^ Instance(float)
+        (Greater(0) ^ Instance(float))
+
+        @param other: the other type in the disjoint union
+        @type other: C{Type}
+        @return: the disjoint union of both types
+        @rtype: C{Type}
+        """
+        if other is self :
+            return tNothing
+        else :
+            return _Xor(self, other)
+    def __invert__ (self) :
+        """Complementary type.
+
+        >>> ~ Instance(int)
+        (~Instance(int))
+
+        @return: the complementary type
+        @rtype: C{Type}
+        """
+        return _Invert(self)
+    def __iterable__ (self) :
+        """Called to test if a type is iterable
+
+        Should be replaced in subclasses that are not iterable
+
+        @raise ValueError: if not iterable
+        """
+        pass
+    def __call__ (self, *values) :
+        """Typecheck values.
+
+        >>> Instance(int)(3, 4, 5)
+        True
+        >>> Instance(int)(3, 4, 5.0)
+        False
+
+        @param values: values that have to be checked
+        @type values: C{object}
+        @return: C{True} if all the values are in the types, C{False}
+          otherwise
+        @rtype: C{bool}
+        """
+        for v in values :
+            if v not in self :
+                return False
+        return True
+    __pnmltag__ = "type"
+    _typemap = None
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Load a C{Type} from a PNML tree
+
+        Uses the attribute C{__pnmltype__} to know which type
+        corresponds to a tag "<type domain='xxx'>"
+
+        >>> s = List(tNatural | tBoolean).__pnmldump__()
+        >>> Type.__pnmlload__(s)
+        Collection(Instance(list),
+                   ((Instance(int) & GreaterOrEqual(0))
+                    | OneOf(True, False)))
+
+        @param tree: the PNML tree to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: the loaded type
+        @rtype: C{Type}
+        """
+        if cls._typemap is None :
+            cls._typemap = {}
+            for n, c in inspect.getmembers(sys.modules[cls.__module__],
+                                           inspect.isclass) :
+                try :
+                    cls._typemap[c.__pnmltype__] = c
+                except AttributeError :
+                    pass
+        return cls._typemap[tree["domain"]].__pnmlload__(tree)
+
+class _BinaryType (Type) :
+    """A type build from two other ones
+
+    This class allows to factorize the PNML related code for various
+    binary types.
+    """
+    def __pnmldump__ (self) :
+        return Tree(self.__pnmltag__, None,
+                    Tree("left", None, Tree.from_obj(self._left)),
+                    Tree("right", None, Tree.from_obj(self._right)),
+                    domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        return cls(tree.child("left").child().to_obj(),
+                   tree.child("right").child().to_obj())
+
+class _And (_BinaryType) :
+    "Intersection of two types"
+    __pnmltype__ = "intersection"
+    def __init__ (self, left, right) :
+        self._left = left
+        self._right = right
+        _iterable(self, left)
+    def __repr__ (self) :
+        return "(%s & %s)" % (repr(self._left), repr(self._right))
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        return (value in self._left) and (value in self._right)
+    def __iter__ (self) :
+        self.__iterable__()
+        for value in self._left :
+            if value in self._right :
+                yield value
+
+class _Or (_BinaryType) :
+    "Union of two types"
+    __pnmltype__ = "union"
+    def __init__ (self, left, right) :
+        self._left = left
+        self._right = right
+        _iterable(self, left, right)
+    def __repr__ (self) :
+        return "(%s | %s)" % (repr(self._left), repr(self._right))
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        return (value in self._left) or (value in self._right)
+    def __iter__ (self) :
+        self.__iterable__()
+        for value in (self._left & self._right) :
+            yield value
+        for value in (self._left ^ self._right) :
+            yield value
+
+class _Sub (_BinaryType) :
+    "Subtyping by difference"
+    __pnmltype__ = "difference"
+    def __init__ (self, left, right)  :
+        self._left = left
+        self._right = right
+        _iterable(self, left)
+    def __repr__ (self) :
+        return "(%s - %s)" % (repr(self._left), repr(self._right))
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        return (value in self._left) and (value not in self._right)
+    def __iter__ (self) :
+        self.__iterable__()
+        for value in self._left :
+            if value not in self._right :
+                yield value
+
+class _Xor (_BinaryType) :
+    "Exclusive union of two types"
+    __pnmltype__ = "xor"
+    def __init__ (self, left, right) :
+        self._left = left
+        self._right = right
+        _iterable(self, left, right)
+    def __repr__ (self) :
+        return "(%s ^ %s)" % (repr(self._left), repr(self._right))
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        if value in self._left :
+            return value not in self._right
+        else :
+            return value in self._right
+    def __iter__ (self) :
+        self.__iterable__()
+        for value in self._left :
+            if value not in self._right :
+                yield value
+        for value in self._right :
+            if value not in self._left :
+                yield value
+
+class _Invert (Type) :
+    "Complement of a type"
+    def __init__ (self, base) :
+        self._base = base
+        _iterable(self, None)
+    def __repr__ (self) :
+        return "(~%s)" % repr(self._base)
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        return (value not in self._base)
+    __pnmltype__ = "complement"
+    def __pnmldump__ (self) :
+        return Tree(self.__pnmltag__, None,
+                    Tree.from_obj(self._base),
+                    domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        return cls(tree.child().to_obj())
+
+class _All (Type) :
+    "A type allowing for any value"
+    def __init__ (self) :
+        pass
+    def __and__ (self, other) :
+        return other
+    def __or__ (self, other) :
+        return self
+    def __sub__ (self, other) :
+        return ~other
+    def __xor__ (self, other) :
+        return ~other
+    def __invert__ (self) :
+        return tNothing
+    def __repr__ (self) :
+        return "tAll"
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True}
+        @rtype: C{bool}
+        """
+        return True
+    def __call__ (self, *values) :
+        """Typecheck values.
+
+        @param values: values that have to be checked
+        @type values: any objet
+        @return: C{True}
+        """
+        return True
+    __pnmltype__ = "universal"
+    def __pnmldump__ (self) :
+        """
+        >>> tAll.__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="universal"/>
+        </pnml>
+        """
+        return Tree(self.__pnmltag__, None, domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """
+        >>> Type.__pnmlload__(tAll.__pnmldump__())
+        tAll
+        """
+        return cls()
+
+class _Nothing (Type) :
+    "A types with no value"
+    def __init__ (self) :
+        pass
+    def __and__ (self, other) :
+        return self
+    def __or__ (self, other) :
+        return other
+    def __sub__ (self, other) :
+        return self
+    def __xor__ (self, other) :
+        return other
+    def __invert__ (self) :
+        return tAll
+    def __repr__ (self) :
+        return "tNothing"
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{False}
+        @rtype: C{bool}
+        """
+        return False
+    def __call__ (self, *values) :
+        """Typecheck values.
+
+        @param values: values that have to be checked
+        @type values: any objet
+        @return: C{False}
+        """
+        return False
+    def __iter__ (self) :
+        pass
+    __pnmltype__ = "empty"
+    def __pnmldump__ (self) :
+        return Tree(self.__pnmltag__, None, domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        return cls()
+
+class Instance (Type) :
+    """A type whose values are all instances of one class.
+
+    >>> [1, 2] in Instance(list)
+    True
+    >>> (1, 2) in Instance(list)
+    False
+    """
+    def __init__ (self, _class) :
+        """Initialize the type
+
+        >>> Instance(int)
+        Instance(int)
+
+        @param _class: the class of instance
+        @type _class: any class
+        @return: initialized object
+        @rtype: C{Instance}
+        """
+        self._class = _class
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        >>> 5 in Instance(int)
+        True
+        >>> 5.0 in Instance(int)
+        False
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        return isinstance(value, self._class)
+    def __repr__ (self) :
+        """String representation of the type, suitable for C{eval}
+
+        >>> repr(Instance(str))
+        'Instance(str)'
+
+        @return: precise string representation
+        @rtype: C{str}
+        """
+        return "Instance(%s)" % self._class.__name__
+    __pnmltype__ = "instance"
+    def __pnmldump__ (self) :
+        """Dump a type to a PNML tree
+
+        >>> Instance(int).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="instance">
+          <object name="int" type="class"/>
+         </type>
+        </pnml>
+
+        @return: the PNML representation of the type
+        @rtype: C{str}
+        """
+        return Tree(self.__pnmltag__, None,
+                    Tree.from_obj(self._class),
+                    domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Builds a type from its PNML representation
+
+        >>> t = Instance(int).__pnmldump__()
+        >>> Instance.__pnmlload__(t)
+        Instance(int)
+
+        @param tree: the PNML tree to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: the loaded type
+        @rtype: C{Instance}
+        """
+        return cls(tree.child().to_obj())
+
+def _full_name (fun) :
+    if fun.__module__ is None :
+        funname = fun.__name__
+        for modname in sys.modules :
+            try :
+                if sys.modules[modname].__dict__.get(funname, None) is fun :
+                    return ".".join([modname, funname])
+            except :
+                pass
+        return funname
+    else :
+        return ".".join([fun.__module__, fun.__name__])
+
+class TypeCheck (Type) :
+    """A type whose values are accepted by a given function.
+
+    >>> def odd (val) :
+    ...     return type(val) is int and (val % 2) == 1
+    >>> 3 in TypeCheck(odd)
+    True
+    >>> 4 in TypeCheck(odd)
+    False
+    >>> 3.0 in TypeCheck(odd)
+    False
+    """
+    def __init__ (self, checker, iterate=None) :
+        """Initialize the type
+
+        >>> import operator
+        >>> TypeCheck(operator.truth)
+        TypeCheck(...truth)
+        >>> def true_values () : # enumerates only choosen values
+        ...     yield True
+        ...     yield 42
+        ...     yield '42'
+        ...     yield [42]
+        ...     yield (42,)
+        ...     yield {True: 42}
+        >>> TypeCheck(operator.truth, true_values)
+        TypeCheck(...truth, snakes.typing.true_values)
+
+        @param checker: a function that checks one value and returns
+          C{True} if it is in te type and C{False} otherwise
+        @type checker: C{function(value)->bool}
+        @param iterate: C{None} or an iterator over the values of the
+          type
+        @type iterate: C{None} or C{iterator}
+        """
+        self._check = checker
+        self._iterate = iterate
+    def __iter__ (self) :
+        """
+        >>> def odd (val) :
+        ...     return type(val) is int and (val % 2) == 1
+        >>> i = iter(TypeCheck(odd))
+        Traceback (most recent call last):
+          ...
+        ValueError: type not iterable
+        >>> def odd_iter () :
+        ...     i = 1
+        ...     while True :
+        ...         yield i
+        ...         yield -i
+        ...         i += 2
+        >>> i = iter(TypeCheck(odd, odd_iter))
+        >>> next(i), next(i), next(i)
+        (1, -1, 3)
+        """
+        try :
+            return iter(self._iterate())
+        except TypeError :
+            raise ValueError("type not iterable")
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        >>> def odd (val) :
+        ...     return type(val) is int and (val % 2) == 1
+        >>> 3 in TypeCheck(odd)
+        True
+        >>> 4 in TypeCheck(odd)
+        False
+        >>> 3.0 in TypeCheck(odd)
+        False
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        return self._check(value)
+    def __repr__ (self) :
+        """
+        >>> def odd (val) :
+        ...     return type(val) is int and (val % 2) == 1
+        >>> repr(TypeCheck(odd))
+        'TypeCheck(snakes.typing.odd)'
+        >>> def odd_iter () :
+        ...     i = 1
+        ...     while True :
+        ...         yield i
+        ...         yield -i
+        ...         i += 2
+        >>> repr(TypeCheck(odd, odd_iter))
+        'TypeCheck(snakes.typing.odd, snakes.typing.odd_iter)'
+        """
+        if self._iterate is None :
+            return "%s(%s)" % (self.__class__.__name__,
+                               _full_name(self._check))
+        else :
+            return "%s(%s, %s)" % (self.__class__.__name__,
+                                   _full_name(self._check),
+                                   _full_name(self._iterate))
+    __pnmltype__ = "checker"
+    def __pnmldump__ (self) :
+        """Dump type to a PNML tree
+
+        >>> import operator
+        >>> TypeCheck(operator.truth).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="checker">
+          <checker>
+           ...
+          </checker>
+          <iterator>
+           <object type="NoneType"/>
+          </iterator>
+         </type>
+        </pnml>
+        >>> def true_values () : # enumerates only choosen values
+        ...     yield True
+        ...     yield 42
+        ...     yield '42'
+        ...     yield [42]
+        ...     yield (42,)
+        ...     yield {True: 42}
+        >>> TypeCheck(operator.truth, true_values).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="checker">
+          <checker>
+           ...
+          </checker>
+          <iterator>
+           <object name="snakes.typing.true_values" type="function"/>
+          </iterator>
+         </type>
+        </pnml>
+
+        Note that this last example would not work as C{true_value} as
+        been defined inside a docstring. In order to allow it to be
+        re-loaded from PNML, it should be defined at module level.
+
+        @return: the type serialized to PNML
+        @rtype: C{snakes.pnml.Tree}
+        """
+        return Tree(self.__pnmltag__, None,
+                    Tree("checker", None, Tree.from_obj(self._check)),
+                    Tree("iterator", None, Tree.from_obj(self._iterate)),
+                    domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Build type from a PNML tree
+
+        >>> import operator
+        >>> TypeCheck.__pnmlload__(TypeCheck(operator.truth).__pnmldump__())
+        TypeCheck(....truth)
+        >>> def true_values () : # enumerates only choosen values
+        ...     yield True
+        ...     yield 42
+        ...     yield '42'
+        ...     yield [42]
+        ...     yield (42,)
+        ...     yield {True: 42}
+
+        @param tree: the PNML tree to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: the loaded type
+        @rtype: C{TypeChecker}
+        """
+        return cls(tree.child("checker").child().to_obj(),
+                   tree.child("iterator").child().to_obj())
+
+class OneOf (Type) :
+    """A type whose values are explicitely enumerated.
+
+    >>> 3 in OneOf(1, 2, 3, 4, 5)
+    True
+    >>> 0 in OneOf(1, 2, 3, 4, 5)
+    False
+    """
+    def __init__ (self, *values) :
+        """
+        @param values: the enumeration of the values in the type
+        @type values: any objects
+        """
+        self._values = values
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        >>> 3 in OneOf(1, 2, 3, 4, 5)
+        True
+        >>> 0 in OneOf(1, 2, 3, 4, 5)
+        False
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        return value in self._values
+    def __repr__ (self) :
+        """
+        >>> repr(OneOf(1, 2, 3, 4, 5))
+        'OneOf(1, 2, 3, 4, 5)'
+        """
+        return "OneOf(%s)" % ", ".join([repr(val) for val in self._values])
+    def __iter__ (self) :
+        """
+        >>> list(iter(OneOf(1, 2, 3, 4, 5)))
+        [1, 2, 3, 4, 5]
+        """
+        return iter(self._values)
+    __pnmltype__ = "enum"
+    def __pnmldump__ (self) :
+        """Dump type to its PNML representation
+
+        >>> OneOf(1, 2, 3, 4, 5).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="enum">
+          <object type="int">
+           1
+          </object>
+          <object type="int">
+           2
+          </object>
+          <object type="int">
+           3
+          </object>
+          <object type="int">
+           4
+          </object>
+          <object type="int">
+           5
+          </object>
+         </type>
+        </pnml>
+
+        @return: PNML representation of the type
+        @rtype: C{snakes.pnml.Tree}
+        """
+        return Tree(self.__pnmltag__, None,
+                    *(Tree.from_obj(val) for val in self._values),
+                    **dict(domain=self.__pnmltype__))
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Build type from its PNML representation
+
+        >>> OneOf.__pnmlload__(OneOf(1, 2, 3, 4, 5).__pnmldump__())
+        OneOf(1, 2, 3, 4, 5)
+
+        @param tree: PNML tree to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: loaded type
+        @rtype: C{OneOf}
+        """
+        return cls(*(child.to_obj() for child in tree.children))
+
+class Collection (Type) :
+    """A type whose values are a given container, holding items of a
+    given type and ranging in a given interval.
+
+    >>> [0, 1.1, 2, 3.3, 4] in Collection(Instance(list), tNumber, 3, 10)
+    True
+    >>> [0, 1.1] in Collection(Instance(list), tNumber, 3, 10) #too short
+    False
+    >>> [0, '1.1', 2, 3.3, 4] in Collection(Instance(list), tNumber, 3, 10) #wrong item
+    False
+    """
+    def __init__ (self, collection, items, min=None, max=None) :
+        """Initialise the type
+
+        >>> Collection(Instance(list), tNumber, 3, 10)
+        Collection(Instance(list), (Instance(int) | Instance(float)), min=3, max=10)
+
+        @param collection: the collection type
+        @type collection: any container type
+        @param items: the type of the items
+        @type items: any type
+        @param min: the smallest allowed value
+        @type min: any value in C{items}
+        @param max: the greatest allowed value
+        @type max: any value in C{items}
+        """
+        self._collection = collection
+        self._class = collection._class
+        self._items = items
+        self._max = max
+        self._min = min
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        >>> [0, 1.1, 2, 3.3, 4] in Collection(Instance(list), tNumber, 3, 10)
+        True
+        >>> [0, 1.1] in Collection(Instance(list), tNumber, 3, 10) #too short
+        False
+        >>> [0, '1.1', 2, 3.3, 4] in Collection(Instance(list), tNumber, 3, 10) #wrong item
+        False
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        if value not in self._collection :
+            return False
+        try :
+            len(value)
+            iter(value)
+        except TypeError :
+            return False
+        if (self._min is not None) and (len(value) < self._min) :
+            return False
+        if (self._max is not None) and (len(value) > self._max) :
+            return False
+        for item in value :
+            if item not in self._items :
+                return False
+        return True
+    def __repr__ (self) :
+        """
+        >>> repr(Collection(Instance(list), tNumber, 3, 10))
+        'Collection(Instance(list), (Instance(int) | Instance(float)), min=3, max=10)'
+        """
+        if (self._min is None) and (self._max is None) :
+            return "Collection(%s, %s)" % (repr(self._collection),
+                                           repr(self._items))
+        elif self._min is None :
+            return "Collection(%s, %s, max=%s)" % (repr(self._collection),
+                                                   repr(self._items),
+                                                   repr(self._max))
+        elif self._max is None :
+            return "Collection(%s, %s, min=%s)" % (repr(self._collection),
+                                                   repr(self._items),
+                                                   repr(self._min))
+        else :
+            return "Collection(%s, %s, min=%s, max=%s)" % (repr(self._collection),
+                                                           repr(self._items),
+                                                           repr(self._min),
+                                                           repr(self._max))
+    __pnmltype__ = "collection"
+    def __pnmldump__ (self) :
+        """Dump type to a PNML tree
+
+        >>> Collection(Instance(list), tNumber, 3, 10).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="collection">
+          <container>
+           <type domain="instance">
+            <object name="list" type="class"/>
+           </type>
+          </container>
+          <items>
+           <type domain="union">
+            <left>
+             <type domain="instance">
+              <object name="int" type="class"/>
+             </type>
+            </left>
+            <right>
+             <type domain="instance">
+              <object name="float" type="class"/>
+             </type>
+            </right>
+           </type>
+          </items>
+          <min>
+           <object type="int">
+            3
+           </object>
+          </min>
+          <max>
+           <object type="int">
+            10
+           </object>
+          </max>
+         </type>
+        </pnml>
+
+        @return: the PNML representation of the type
+        @rtype: C{snakes.pnml.Tree}
+        """
+        return Tree(self.__pnmltag__, None,
+                    Tree("container", None, Tree.from_obj(self._collection)),
+                    Tree("items", None, Tree.from_obj(self._items)),
+                    Tree("min", None, Tree.from_obj(self._min)),
+                    Tree("max", None, Tree.from_obj(self._max)),
+                    domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Load type from its PNML representation
+
+        >>> t = Collection(Instance(list), tNumber, 3, 10).__pnmldump__()
+        >>> Collection.__pnmlload__(t)
+        Collection(Instance(list), (Instance(int) | Instance(float)),
+                   min=3, max=10)
+
+        @param tree: the PNML tree to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: the loaded type
+        @rtype: C{Collection}
+        """
+        return cls(tree.child("container").child().to_obj(),
+                   tree.child("items").child().to_obj(),
+                   tree.child("min").child().to_obj(),
+                   tree.child("max").child().to_obj())
+
+def List (items, min=None, max=None) :
+    """Shorthand for instantiating C{Collection}
+
+    >>> List(tNumber, min=3, max=10)
+    Collection(Instance(list), (Instance(int) | Instance(float)), min=3, max=10)
+
+    @param items: the type of the elements in the collection
+    @type items: C{Type}
+    @param min: the minimum number of elements in the collection
+    @type min: C{int} or C{None}
+    @param max: the maximum number of elements in the collection
+    @type max: C{int} or C{None}
+    @return: a type that checks the given constraints
+    @rtype: C{Collection}
+    """
+    return Collection(Instance(list), items, min, max)
+
+def Tuple (items, min=None, max=None) :
+    """Shorthand for instantiating C{Collection}
+
+    >>> Tuple(tNumber, min=3, max=10)
+    Collection(Instance(tuple), (Instance(int) | Instance(float)), min=3, max=10)
+
+    @param items: the type of the elements in the collection
+    @type items: C{Type}
+    @param min: the minimum number of elements in the collection
+    @type min: C{int} or C{None}
+    @param max: the maximum number of elements in the collection
+    @type max: C{int} or C{None}
+    @return: a type that checks the given constraints
+    @rtype: C{Collection}
+    """
+    return Collection(Instance(tuple), items, min, max)
+
+def Set (items, min=None, max=None) :
+    """Shorthand for instantiating C{Collection}
+
+    >>> Set(tNumber, min=3, max=10)
+    Collection(Instance(set), (Instance(int) | Instance(float)), min=3, max=10)
+
+    @param items: the type of the elements in the collection
+    @type items: C{Type}
+    @param min: the minimum number of elements in the collection
+    @type min: C{int} or C{None}
+    @param max: the maximum number of elements in the collection
+    @type max: C{int} or C{None}
+    @return: a type that checks the given constraints
+    @rtype: C{Collection}
+    """
+    return Collection(Instance(set), items, min, max)
+
+class Mapping (Type) :
+    """A type whose values are mapping (eg, C{dict})
+
+    >>> {'Yes': True, 'No': False} in Mapping(tString, tAll)
+    True
+    >>> {True: 1, False: 0} in Mapping(tString, tAll)
+    False
+    """
+    def __init__ (self, keys, items, _dict=Instance(dict)) :
+        """Initialise a mapping type
+
+        >>> Mapping(tInteger, tFloat)
+        Mapping(Instance(int), Instance(float), Instance(dict))
+        >>> from snakes.data import hdict
+        >>> Mapping(tInteger, tFloat, Instance(hdict))
+        Mapping(Instance(int), Instance(float), Instance(hdict))
+
+        @param keys: the type for the keys
+        @type keys: any type
+        @param items: the type for the items
+        @type items: any type
+        @param _dict: the class that mapping must be instances of
+        @type _dict: any C{dict} like class
+        """
+        self._keys = keys
+        self._items = items
+        self._dict = _dict
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        >>> {'Yes': True, 'No': False} in Mapping(tString, tAll)
+        True
+        >>> {True: 1, False: 0} in Mapping(tString, tAll)
+        False
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        if not self._dict(value) :
+            return False
+        for key, item in value.items() :
+            if key not in self._keys :
+                return False
+            if item not in self._items :
+                return True
+        return True
+    def __repr__ (self) :
+        """Return a string representation of the type suitable for C{eval}
+
+        >>> repr(Mapping(tString, tAll))
+        'Mapping(Instance(str), tAll, Instance(dict))'
+
+        @return: precise string representation
+        @rtype: C{str}
+        """
+        return "Mapping(%s, %s, %s)" % (repr(self._keys),
+                                        repr(self._items),
+                                        repr(self._dict))
+    __pnmltype__ = "mapping"
+    def __pnmldump__ (self) :
+        """Dump type to a PNML tree
+
+        >>> from snakes.hashables import hdict
+        >>> Mapping(tString, tAll, Instance(hdict)).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="mapping">
+          <keys>
+           <type domain="instance">
+            <object name="str" type="class"/>
+           </type>
+          </keys>
+          <items>
+           <type domain="universal"/>
+          </items>
+          <container>
+           <type domain="instance">
+            <object name="snakes.hashables.hdict" type="class"/>
+           </type>
+          </container>
+         </type>
+        </pnml>
+
+        @return: PNML representation of the type
+        @rtype: C{snakes.pnml.Tree}
+        """
+        return Tree(self.__pnmltag__, None,
+                    Tree("keys", None, Tree.from_obj(self._keys)),
+                    Tree("items", None, Tree.from_obj(self._items)),
+                    Tree("container", None, Tree.from_obj(self._dict)),
+                    domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Load type from its PNML representation
+
+        >>> from snakes.hashables import hdict
+        >>> t = Mapping(tString, tAll, Instance(hdict)).__pnmldump__()
+        >>> Mapping.__pnmlload__(t)
+        Mapping(Instance(str), tAll, Instance(hdict))
+
+        @param tree: PNML representation of the type
+        @type tree: C{snakes.pnml.Tree}
+        @return: the loaded type
+        @rtype: C{Mapping}
+        """
+        return cls(tree.child("keys").child().to_obj(),
+                   tree.child("items").child().to_obj(),
+                   tree.child("container").child().to_obj())
+
+class Range (Type) :
+    """A type whose values are in a given range
+
+    Notice that ranges are not built into the memory so that huge
+    values can be used.
+
+    >>> 3 in Range(1, 2**128, 2)
+    True
+    >>> 4 in Range(1, 2**128, 2)
+    False
+    """
+    def __init__ (self, first, last, step=1) :
+        """The values are those that the builtin C{range(first, last, step)}
+        would return.
+
+        >>> Range(1, 10)
+        Range(1, 10)
+        >>> Range(1, 10, 2)
+        Range(1, 10, 2)
+
+        @param first: first element in the range
+        @type first: C{int}
+        @param last: upper bound of the range, not belonging to it
+        @type last: C{int}
+        @param step: step between elements in the range
+        @type step: C{int}
+        """
+        self._first, self._last, self._step = first, last, step
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        >>> 1 in Range(1, 10, 2)
+        True
+        >>> 2 in Range(1, 10, 2)
+        False
+        >>> 9 in Range(1, 10, 2)
+        True
+        >>> 10 in Range(1, 10, 2)
+        False
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        return ((self._first <= value < self._last)
+                and ((value - self._first) % self._step == 0))
+    def __repr__ (self) :
+        """Return a string representation of the type suitable for C{eval}
+
+        >>> repr(Range(1, 2**128, 2))
+        'Range(1, 340282366920938463463374607431768211456, 2)'
+
+        @return: precise string representation
+        @rtype: C{str}
+        """
+        if self._step == 1 :
+            return "Range(%s, %s)" % (self._first, self._last)
+        else :
+            return "Range(%s, %s, %s)" % (self._first, self._last, self._step)
+    def __iter__ (self) :
+        """Iterate over the elements of the type
+
+        >>> list(iter(Range(1, 10, 3)))
+        [1, 4, 7]
+
+        @return: an iterator over the values belonging to the range
+        @rtype: C{generator}
+        """
+        return iter(xrange(self._first, self._last, self._step))
+    __pnmltype__ = "range"
+    def __pnmldump__ (self) :
+        """Dump type to a PNML tree
+
+        >>> Range(1, 10, 2).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="range">
+          <first>
+           <object type="int">
+            1
+           </object>
+          </first>
+          <last>
+           <object type="int">
+            10
+           </object>
+          </last>
+          <step>
+           <object type="int">
+            2
+           </object>
+          </step>
+         </type>
+        </pnml>
+
+        @return: PNML representation of the type
+        @rtype: C{snakes.pnml.Tree}
+        """
+        return Tree(self.__pnmltag__, None,
+                    Tree("first", None, Tree.from_obj(self._first)),
+                    Tree("last", None, Tree.from_obj(self._last)),
+                    Tree("step", None, Tree.from_obj(self._step)),
+                    domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Build type from its PNML representation
+
+        >>> Range.__pnmlload__(Range(1, 10, 2).__pnmldump__())
+        Range(1, 10, 2)
+
+        @param tree: PNML tree to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: the loaded type
+        @rtype: C{Range}
+        """
+        return cls(tree.child("first").child().to_obj(),
+                   tree.child("last").child().to_obj(),
+                   tree.child("step").child().to_obj())
+
+class Greater (Type) :
+    """A type whose values are greater than a minimum.
+
+    The minimum and the checked values can be of any type as soon as
+    they can be compared with C{>}.
+
+    >>> 6 in Greater(3)
+    True
+    >>> 3 in Greater(3)
+    False
+    """
+    def __init__ (self, min) :
+        """Initialises the type
+
+        >>> Greater(5)
+        Greater(5)
+
+        @param min: the greatest value not included in the type
+        @type min: any C{object} that support comparison
+        """
+        self._min = min
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        >>> 5 in Greater(3)
+        True
+        >>> 5 in Greater(3.0)
+        True
+        >>> 3 in Greater(3.0)
+        False
+        >>> 1.0 in Greater(5)
+        False
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        try :
+            return value > self._min
+        except :
+            return False
+    def __repr__ (self) :
+        """Return a string representation of the type suitable for C{eval}
+
+        >>> repr(Greater(3))
+        'Greater(3)'
+
+        @return: precise string representation
+        @rtype: C{str}
+        """
+        return "Greater(%s)" % repr(self._min)
+    __pnmltype__ = "greater"
+    def __pnmldump__ (self) :
+        """Dump type to its PNML representation
+
+        >>> Greater(42).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="greater">
+          <object type="int">
+           42
+          </object>
+         </type>
+        </pnml>
+
+        @return: PNML representation of the type
+        @rtype: C{snakes.pnml.Tree}
+        """
+        return Tree(self.__pnmltag__, None,
+                    Tree.from_obj(self._min),
+                    domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Build type from its PNLM representation
+
+        >>> Greater.__pnmlload__(Greater(42).__pnmldump__())
+        Greater(42)
+
+        @param tree: PNML representation to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: loaded type
+        @rtype: C{Greater}
+        """
+        return cls(tree.child().to_obj())
+
+class GreaterOrEqual (Type) :
+    """A type whose values are greater or equal than a minimum.
+
+    See the description of C{Greater}
+    """
+    def __init__ (self, min) :
+        """Initialises the type
+
+        >>> GreaterOrEqual(5)
+        GreaterOrEqual(5)
+
+        @param min: the minimal allowed value
+        @type min: any C{object} that support comparison
+        """
+        self._min = min
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        >>> 5 in GreaterOrEqual(3)
+        True
+        >>> 5 in GreaterOrEqual(3.0)
+        True
+        >>> 3 in GreaterOrEqual(3.0)
+        True
+        >>> 1.0 in GreaterOrEqual(5)
+        False
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        try :
+            return value >= self._min
+        except :
+            False
+    def __repr__ (self) :
+        """Return a strign representation of the type suitable for C{eval}
+
+        >>> repr(GreaterOrEqual(3))
+        'GreaterOrEqual(3)'
+
+        @return: precise string representation
+        @rtype: C{str}
+        """
+        return "GreaterOrEqual(%s)" % repr(self._min)
+    __pnmltype__ = "greatereq"
+    def __pnmldump__ (self) :
+        """Dump type to its PNML representation
+
+        >>> GreaterOrEqual(42).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="greatereq">
+          <object type="int">
+           42
+          </object>
+         </type>
+        </pnml>
+
+        @return: PNML representation of the type
+        @rtype: C{snakes.pnml.Tree}
+        """
+        return Tree(self.__pnmltag__, None,
+                    Tree.from_obj(self._min),
+                    domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Build type from its PNLM representation
+
+        >>> GreaterOrEqual.__pnmlload__(GreaterOrEqual(42).__pnmldump__())
+        GreaterOrEqual(42)
+
+        @param tree: PNML representation to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: loaded type
+        @rtype: C{GreaterOrEqual}
+        """
+        return cls(tree.child().to_obj())
+
+class Less (Type) :
+    """A type whose values are less than a maximum.
+
+    See the description of C{Greater}
+    """
+    def __init__ (self, max) :
+        """Initialises the type
+
+        >>> Less(5)
+        Less(5)
+
+        @param min: the smallest value not included in the type
+        @type min: any C{object} that support comparison
+        """
+        self._max = max
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        >>> 5.0 in Less(5)
+        False
+        >>> 4.9 in Less(5)
+        True
+        >>> 4 in Less(5.0)
+        True
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        return value < self._max
+    def __repr__ (self) :
+        """Return a string representation of the type suitable for C{eval}
+
+        >>> repr(Less(3))
+        'Less(3)'
+
+        @return: precise string representation
+        @rtype: C{str}
+        """
+        return "Less(%s)" % repr(self._max)
+    __pnmltype__ = "less"
+    def __pnmldump__ (self) :
+        """Dump type to its PNML representation
+
+        >>> Less(3).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="less">
+          <object type="int">
+           3
+          </object>
+         </type>
+        </pnml>
+
+        @return: PNML representation of the type
+        @rtype: C{snakes.pnml.Tree}
+        """
+        return Tree(self.__pnmltag__, None,
+                    Tree.from_obj(self._max),
+                    domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Build type from its PNML representation
+
+        >>> Less.__pnmlload__(Less(3).__pnmldump__())
+        Less(3)
+
+        @param tree: PNML tree to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: loaded type
+        @rtype: C{Less}
+        """
+        return cls(tree.child().to_obj())
+
+class LessOrEqual (Type) :
+    """A type whose values are less than or equal to a maximum.
+
+    See the description of C{Greater}
+    """
+    def __init__ (self, max) :
+        """Initialises the type
+
+        >>> LessOrEqual(5)
+        LessOrEqual(5)
+
+        @param min: the greatest value the type
+        @type min: any C{object} that support comparison
+        """
+
+        self._max = max
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        >>> 5 in LessOrEqual(5.0)
+        True
+        >>> 5.1 in LessOrEqual(5)
+        False
+        >>> 1.0 in LessOrEqual(5)
+        True
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        return value <= self._max
+    def __repr__ (self) :
+        """Return a string representation of the type suitable for C{eval}
+
+        >>> repr(LessOrEqual(3))
+        'LessOrEqual(3)'
+
+        @return: precise string representation
+        @rtype: C{str}
+        """
+        return "LessOrEqual(%s)" % repr(self._max)
+    __pnmltype__ = "lesseq"
+    def __pnmldump__ (self) :
+        """Dump type to its PNML representation
+
+        >>> LessOrEqual(4).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="lesseq">
+          <object type="int">
+           4
+          </object>
+         </type>
+        </pnml>
+
+        @return: PNML representation of the type
+        @rtype: C{snakes.pnml.Tree}
+        """
+        return Tree(self.__pnmltag__, None,
+                    Tree.from_obj(self._max),
+                    domain=self.__pnmltype__)
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Build type from its PNML representation
+
+        >>> LessOrEqual.__pnmlload__(LessOrEqual(4).__pnmldump__())
+        LessOrEqual(4)
+
+        @param tree: PNML tree to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: loaded type
+        @rtype: C{LessOrEqual}
+        """
+        return cls(tree.child().to_obj())
+
+class CrossProduct (Type) :
+    """A type whose values are tuples, each component of them being in
+    given types. The resulting type is the cartesian cross product of
+    the compound types.
+
+    >>> (1, 3, 5) in CrossProduct(Range(1, 10), Range(1, 10, 2), Range(1, 10))
+    True
+    >>> (2, 4, 6) in CrossProduct(Range(1, 10), Range(1, 10, 2), Range(1, 10))
+    False
+    """
+    def __init__ (self, *types) :
+        """Initialise the type
+
+        >>> CrossProduct(Instance(int), Instance(float))
+        CrossProduct(Instance(int), Instance(float))
+
+        @param types: the types of each component of the allowed tuples
+        @type types: C{Type}
+        """
+        self._types = types
+        _iterable(self, *types)
+    def __repr__ (self) :
+        """Return a string representation of the type suitable for C{eval}
+
+        >>> repr(CrossProduct(Range(1, 10), Range(1, 10, 2), Range(1, 10)))
+        'CrossProduct(Range(1, 10), Range(1, 10, 2), Range(1, 10))'
+
+        @return: precise string representation
+        @rtype: C{str}
+        """
+        return "CrossProduct(%s)" % ", ".join([repr(t) for t in self._types])
+    def __contains__ (self, value) :
+        """Check wether a value is in the type.
+
+        >>> (1, 3, 5) in CrossProduct(Range(1, 10), Range(1, 10, 2), Range(1, 10))
+        True
+        >>> (2, 4, 6) in CrossProduct(Range(1, 10), Range(1, 10, 2), Range(1, 10))
+        False
+
+        @param value: the value to check
+        @type value: C{object}
+        @return: C{True} if C{value} is in the type, C{False} otherwise
+        @rtype: C{bool}
+        """
+        if not isinstance(value, tuple) :
+            return False
+        elif len(self._types) != len(value) :
+            return False
+        for item, t in zip(value, self._types) :
+            if not item in t :
+                return False
+        return True
+    def __iter__ (self) :
+        """A cross product is iterable if so are all its components.
+
+        >>> list(iter(CrossProduct(Range(1, 3), Range(3, 5))))
+        [(1, 3), (1, 4), (2, 3), (2, 4)]
+        >>> iter(CrossProduct(Range(1, 100), tAll))
+        Traceback (most recent call last):
+        ...
+        ValueError: iteration over non-sequence
+
+        @return: an iterator over the values in the type
+        @rtype: C{generator}
+        @raise ValueError: when one component is not iterable
+        """
+        self.__iterable__()
+        return cross(self._types)
+    __pnmltype__ = "crossproduct"
+    def __pnmldump__ (self) :
+        """Dumps type to its PNML representation
+
+        >>> CrossProduct(Instance(int), Instance(float)).__pnmldump__()
+        <?xml version="1.0" encoding="utf-8"?>
+        <pnml>
+         <type domain="crossproduct">
+          <type domain="instance">
+           <object name="int" type="class"/>
+          </type>
+          <type domain="instance">
+           <object name="float" type="class"/>
+          </type>
+         </type>
+        </pnml>
+
+        @return: PNML representation of the type
+        @rtype: C{snakes.pnml.Tree}
+        """
+        return Tree(self.__pnmltag__, None,
+                    *(Tree.from_obj(t) for t in self._types),
+                    **dict(domain=self.__pnmltype__))
+    @classmethod
+    def __pnmlload__ (cls, tree) :
+        """Build type from its PNML representation
+
+        >>> t = CrossProduct(Instance(int), Instance(float)).__pnmldump__()
+        >>> CrossProduct.__pnmlload__(t)
+        CrossProduct(Instance(int), Instance(float))
+
+        @param tree: PNML tree to load
+        @type tree: C{snakes.pnml.Tree}
+        @return: loaded type
+        @rtype: C{CrossProduct}
+        """
+        return cls(*(child.to_obj() for child in tree.children))
+
+tAll        = _All()
+tNothing    = _Nothing()
+tString     = Instance(str)
+tList       = List(tAll)
+tInteger    = Instance(int)
+tNatural    = tInteger & GreaterOrEqual(0)
+tPositive   = tInteger & Greater(0)
+tFloat      = Instance(float)
+tNumber     = tInteger|tFloat
+tDict       = Instance(dict)
+tNone       = OneOf(None)
+tBoolean    = OneOf(True, False)
+tTuple      = Tuple(tAll)
+tPair       = Tuple(tAll, min=2, max=2)

+from snakes import SnakesError
+
+class CompilationError (SnakesError) :
+    pass
+
+class DeclarationError (SnakesError) :
+    pass

+import sys, operator, inspect, re, collections
+from snakes.utils.abcd import CompilationError, DeclarationError
+from snakes.lang.abcd.parser import ast
+from snakes.lang import unparse
+import snakes.utils.abcd.transform as transform
+from snakes.data import MultiSet
+from snakes import *
+
+class Decl (object) :
+    OBJECT = "object"
+    TYPE = "type"
+    BUFFER = "buffer"
+    SYMBOL = "symbol"
+    CONST = "const"
+    NET = "net"
+    TASK = "task"
+    IMPORT = "import"
+    def __init__ (self, node, kind=None, **data) :
+        self.node = node
+        classname = node.__class__.__name__
+        if kind is not None :
+            self.kind = kind
+        elif classname == "AbcdTypedef" :
+            self.kind = self.TYPE
+        elif classname == "AbcdBuffer" :
+            self.kind = self.BUFFER
+        elif classname == "AbcdSymbol" :
+            self.kind = self.SYMBOL
+        elif classname == "AbcdConst" :
+            self.kind = self.CONST
+        elif classname == "AbcdNet" :
+            self.kind = self.NET
+        elif classname == "AbcdTask" :
+            self.kind = self.TASK
+        elif classname in ("Import", "ImportFrom") :
+            self.kind = self.IMPORT
+        else :
+            self.kind = self.OBJECT
+        for key, val in data.items() :
+            setattr(self, key, val)
+
+class GetInstanceArgs (object) :
+    """Bind arguments for a net instance"""
+    def __init__ (self, node) :
+        self.argspec = []
+        self.arg = {}
+        self.buffer = {}
+        self.net = {}
+        self.task = {}
+        seen = set()
+        for a in node.args.args + node.args.kwonlyargs :
+            if a.arg in seen :
+                self._raise(CompilationError,
+                            "duplicate argument %r" % a.arg)
+            seen.add(a.arg)
+            if a.annotation is None :
+                self.argspec.append((a.arg, "arg"))
+            else :
+                self.argspec.append((a.arg, a.annotation.id))
+    def __call__ (self, *args) :
+        self.arg.clear()
+        self.buffer.clear()
+        self.net.clear()
+        self.task.clear()
+        for (name, kind), value in zip(self.argspec, args) :
+            getattr(self, kind)[name] = value
+        return self.arg, self.buffer, self.net, self.task
+
+class Builder (object) :
+    def __init__ (self, snk, path=[], up=None) :
+        self.snk = snk
+        self.path = path
+        self.up = up
+        self.env = {"True": Decl(None, kind=Decl.CONST, value=True),
+                    "False": Decl(None, kind=Decl.CONST, value=False),
+                    "None": Decl(None, kind=Decl.CONST, value=None),
+                    "dot": Decl(None, kind=Decl.CONST, value=self.snk.dot),
+                    "BlackToken": Decl(None, kind=Decl.TYPE,
+                                       type=self.snk.Instance(self.snk.BlackToken))}
+        self.stack = []
+        if up :
+            self.globals = up.globals
+        else :
+            self.globals = snk.Evaluator(dot=self.snk.dot,
+                                         BlackToken=self.snk.BlackToken)
+        self.instances = MultiSet()
+    # utilities
+    def _raise (self, error, message) :
+        """raise an exception with appropriate location
+        """
+        if self.stack :
+            pos = "[%s:%s]: " % (self.stack[-1].lineno,
+                                 self.stack[-1].col_offset)
+        else :
+            pos = ""
+        raise error(pos+message)
+    def _eval (self, expr, *largs, **kwargs) :
+        env = self.globals.copy()
+        if isinstance(expr, ast.AST) :
+            expr = unparse(expr)
+        return env(expr, dict(*largs, **kwargs))
+    # declarations management
+    def __setitem__ (self, name, value) :
+        if name in self.env :
+            self._raise(DeclarationError, "duplicated declaration of %r" % name)
+        self.env[name] = value
+    def __getitem__ (self, name) :
+        if name in self.env :
+            return self.env[name]
+        elif self.up is None :
+            self._raise(DeclarationError, "%r not declared" % name)
+        else :
+            return self.up[name]
+    def __contains__ (self, name) :
+        if name in self.env :
+            return True
+        elif self.up is None :
+            return False
+        else :
+            return name in self.up
+    def goto (self, name) :
+        if name in self.env :
+            return self
+        elif self.up is None :
+            self._raise(DeclarationError, "%r not declared" % name)
+        else :
+            return self.up.goto(name)
+    def get_buffer (self, name) :
+        if name not in self :
+            self._raise(DeclarationError,
+                        "buffer %r not declared" % name)
+        decl = self[name]
+        if decl.kind != Decl.BUFFER :
+            self._raise(DeclarationError,
+                        "%r declared as %s but used as buffer"
+                        % (name, decl.kind))
+        elif decl.capacity is not None :
+            pass
+            #self._raise(NotImplementedError, "capacities not (yet) supported")
+        return decl
+    def get_net (self, name) :
+        if name not in self :
+            self._raise(DeclarationError,
+                        "net %r not declared" % name)
+        decl = self[name]
+        if decl.kind != Decl.NET :
+            self._raise(DeclarationError,
+                        "%r declared as %s but used as net"
+                        % (name, decl.kind))
+        return decl
+    def get_task (self, name) :
+        if name not in self :
+            self._raise(DeclarationError,
+                        "task %r not declared" % name)
+        decl = self[name]
+        if decl.kind != Decl.TASK :
+            self._raise(DeclarationError,
+                        "%r declared as %s but used as task"
+                        % (name, decl.kind))
+        return decl
+    # main compiler entry point
+    def build (self, node, prefix="", fallback=None) :
+        self.stack.append(node)
+        if prefix :
+            prefix += "_"
+        method = "build_" + prefix + node.__class__.__name__
+        visitor = getattr(self, method, fallback or self.build_fail)
+        try :
+            return visitor(node)
+        finally :
+            self.stack.pop(-1)
+    def build_fail (self, node) :
+        self._raise(CompilationError, "do not know how to compile %s"
+                    % node.__class__.__name__)
+    def build_arc (self, node) :
+        return self.build(node, "arc", self.build_arc_expr)
+    # specification
+    def build_AbcdSpec (self, node) :
+        for decl in node.context :
+            self.build(decl)
+        tasks = [self._build_TaskNet(decl.node)
+                 for name, decl in self.env.items()
+                 if decl.kind == Decl.TASK and decl.used]
+        net = reduce(operator.or_, tasks, self.build(node.body))
+        # set local buffers marking, and hide them
+        for name, decl in ((n, d) for n, d in self.env.items()
+                           if d.kind == Decl.BUFFER) :
+            status = self.snk.buffer(name)
+            for place in net.status(status) :
+                place = net.place(place)
+                try :
+                    place.reset(decl.marking)
+                except ValueError as err :
+                    self._raise(CompilationError,
+                                "invalid initial marking (%s)" % err)
+                if decl.capacity is None :
+                    cap = None
+                else :
+                    #cap = [c.n if c else None for c in decl.capacity]
+                    # TODO: accept more than integers as capacities
+                    cap = []
+                    for c in decl.capacity :
+                        if c is None :
+                            cap.append(None)
+                        else :
+                            try :
+                                cap.append(self._eval(c))
+                            except :
+                                err = sys.exc_info()[1]
+                                self._raise(CompilationError,
+                                            "could not evaluate %r, %s"
+                                            % (unparse(c), err))
+                place.label(path=self.path,
+                            capacity=cap)
+                # TODO: check capacity
+            net.hide(status)
+        if self.up is None :
+            # set entry marking
+            for place in net.status(self.snk.entry) :
+                net.place(place).reset(self.snk.dot)
+            # rename nodes
+            self._rename_nodes(net)
+            # copy global declarations
+            net.globals.update(self.globals)
+            # add info about source file
+            net.label(srcfile=str(node.st.text.filename))
+            # add assertions
+            net.label(asserts=node.asserts)
+        return net
+    def _build_TaskNet (self, node) :
+        self._raise(NotImplementedError, "tasks not (yet) supported")
+    def _rename_nodes (self, net) :
+        # generate unique names
+        total = collections.defaultdict(int)
+        count = collections.defaultdict(int)
+        def ren (node) :
+            if net.has_transition(node.name) :
+                status = node.label("srctext")
+            else :
+                if node.status == self.snk.entry :
+                    status = "e"
+                elif node.status == self.snk.internal :
+                    status = "i"
+                elif node.status == self.snk.exit :
+                    status = "x"
+                else :
+                    status = node.label("buffer")
+            name = ".".join(node.label("path") + [status])
+            if total[name] > 1 :
+                count[name] += 1
+                name = "%s#%s" % (name, count[name])
+            return name
+        # count occurrences of each name base
+        _total = collections.defaultdict(int)
+        for node in net.node() :
+            _total[ren(node)] += 1
+        total = _total
+        # rename nodes using a depth-first traversal
+        done = set(net.status(self.snk.entry))
+        todo = [net.node(n) for n in done]
+        while todo :
+            node = todo.pop(-1)
+            new = ren(node)
+            if new != node.name :
+                net.rename_node(node.name, new)
+            done.add(new)
+            for n in net.post(new) - done :
+                todo.append(net.node(n))
+                done.add(n)
+        # rename isolated nodes
+        for letter, method in (("p", net.place), ("t", net.transition)) :
+            for node in method() :
+                if node.name not in done :
+                    net.rename_node(node.name, ren(node))
+    # declarations
+    def build_AbcdTypedef (self, node) :
+        """
+        >>> import snakes.nets
+        >>> b = Builder(snakes.nets)
+        >>> b.build(ast.AbcdTypedef(name='number', type=ast.UnionType(types=[ast.NamedType(name='int'), ast.NamedType(name='float')])))
+        >>> b.env['number'].type
+        (Instance(int) | Instance(float))
+        >>> b.build(ast.ImportFrom(module='inspect', names=[ast.alias(name='isbuiltin')]))
+        >>> b.build(ast.AbcdTypedef(name='builtin', type=ast.NamedType(name='isbuiltin')))
+        >>> b.env['builtin'].type
+        TypeCheck(inspect.isbuiltin)
+        """
+        self[node.name] = Decl(node, type=self.build(node.type))
+    def build_AbcdBuffer (self, node) :
+        self[node.name] = Decl(node,
+                               type=self.build(node.type),
+                               capacity=node.capacity,
+                               marking=self._eval(node.content))
+    def build_AbcdSymbol (self, node) :
+        for name in node.symbols :
+            value = self.snk.Symbol(name, False)
+            self[name] = Decl(node, value=value)
+            self.globals[name] = value
+    def build_AbcdConst (self, node) :
+        value = self._eval(node.value)
+        self[node.name] = Decl(node, value=value)
+        self.globals[node.name] = value
+    def build_AbcdNet (self, node) :
+        self[node.name] = Decl(node, getargs=GetInstanceArgs(node))
+    def build_AbcdTask (self, node) :
+        self._raise(NotImplementedError, "tasks not (yet) supported")
+        self[node.name] = Decl(node, used=False)
+    def build_Import (self, node) :
+        for alias in node.names :
+            self[alias.asname or alias.name] = Decl(node)
+        self.globals.declare(unparse(node))
+    def build_ImportFrom (self, node) :
+        self.build_Import(node)
+    # processes
+    def build_AbcdAction (self, node) :
+        if node.guard is True :
+            return self._build_True(node)
+        elif node.guard is False :
+            return self._build_False(node)
+        else :
+            return self._build_action(node)
+    def _build_True (self, node) :
+        net = self.snk.PetriNet("true")
+        e = self.snk.Place("e", [], self.snk.tBlackToken,
+                           status=self.snk.entry)
+        e.label(path=self.path)
+        net.add_place(e)
+        x = self.snk.Place("x", [], self.snk.tBlackToken,
+                           status=self.snk.exit)
+        x.label(path=self.path)
+        net.add_place(x)
+        t = self.snk.Transition("t")
+        t.label(srctext=node.st.source(),
+                srcloc=(node.st.srow, node.st.scol,
+                        node.st.erow, node.st.ecol),
+                path=self.path)
+        net.add_transition(t)
+        net.add_input("e", "t", self.snk.Value(self.snk.dot))
+        net.add_output("x", "t", self.snk.Value(self.snk.dot))
+        return net
+    def _build_False (self, node) :
+        net = self.snk.PetriNet("false")
+        e = self.snk.Place("e", [], self.snk.tBlackToken,
+                           status=self.snk.entry)
+        e.label(path=self.path)
+        net.add_place(e)
+        x = self.snk.Place("x", [], self.snk.tBlackToken,
+                           status=self.snk.exit)
+        x.label(path=self.path)
+        net.add_place(x)
+        return net
+    def _build_action (self, node) :
+        net = self.snk.PetriNet("flow")
+        e = self.snk.Place("e", [], self.snk.tBlackToken,
+                           status=self.snk.entry)
+        e.label(path=self.path)
+        net.add_place(e)
+        x = self.snk.Place("x", [], self.snk.tBlackToken,
+                           status=self.snk.exit)
+        x.label(path=self.path)
+        net.add_place(x)
+        t = self.snk.Transition("t", self.snk.Expression(unparse(node.guard)),
+                                status=self.snk.tick("action"))
+        t.label(srctext=node.st.source(),
+                srcloc=(node.st.srow, node.st.scol,
+                        node.st.erow, node.st.ecol),
+                path=self.path)
+        net.add_transition(t)
+        net.add_input("e", "t", self.snk.Value(self.snk.dot))
+        net.add_output("x", "t", self.snk.Value(self.snk.dot))
+        net = reduce(operator.or_, [self.build(a) for a in node.accesses],
+                     net)
+        net.hide(self.snk.tick("action"))
+        return net
+    def build_AbcdFlowOp (self, node) :
+        return self.build(node.op)(self.build(node.left),
+                                   self.build(node.right))
+    def _get_instance_arg (self, arg) :
+        if arg.__class__.__name__ == "Name" and arg.id in self :
+            return self[arg.id]
+        else :
+            try :
+                self._eval(arg)
+            except :
+                self._raise(CompilationError,
+                            "could not evaluate argument %r"
+                            % arg.st.source())
+            return arg
+    def build_AbcdInstance (self, node) :
+        if node.net not in self :
+            self._raise(DeclarationError, "%r not declared" % node.net)
+        elif node.starargs :
+            self._raise(CompilationError, "* argument not allowed here")
+        elif node.kwargs :
+            self._raise(CompilationError, "** argument not allowed here")
+        decl = self[node.net]
+        if decl.kind != Decl.NET :
+            self._raise(DeclarationError,
+                        "%r declared as %s but used as net"
+                        % (name, decl.kind))
+        # unpack args
+        posargs, kwargs = [], {}
+        for arg in node.args :
+            posargs.append(self._get_instance_arg(arg))
+        for kw in node.keywords :
+            kwargs[kw.arg] = self._get_instance_arg(kw.value)
+        # bind args
+        try :
+            args, buffers, nets, tasks = decl.getargs(*posargs, **kwargs)
+        except TypeError :
+            c, v, t = sys.exc_info()
+            self._raise(CompilationError, str(v))
+        for d, kind in ((buffers, Decl.BUFFER),
+                        (nets, Decl.NET),
+                        (tasks, Decl.TASK)) :
+            for k, v in d.items() :
+                if v.kind != kind :
+                    self._raise(DeclarationError,
+                                "%r declared as %s but used as %s"
+                                % (k, v.kind, kind))
+                d[k] = v.node.name
+        # build sub-net
+        binder = transform.ArgsBinder(args, buffers, nets, tasks)
+        spec = binder.visit(decl.node.body)
+        if node.asname :
+            name = str(node.asname)
+        else :
+            name = node.st.source()
+        if name in self.instances :
+            name = "%s#%s" % (name, self.instances(name))
+        self.instances.add(name)
+        path = self.path + [name]
+        builder = self.__class__(self.snk, path, self)
+        return builder.build(spec)
+    # control flow operations
+    def build_Sequence (self, node) :
+        return self.snk.PetriNet.__and__
+    def build_Choice (self, node) :
+        return self.snk.PetriNet.__add__
+    def build_Parallel (self, node) :
+        return self.snk.PetriNet.__or__
+    def build_Loop (self, node) :
+        return self.snk.PetriNet.__mul__
+    # accesses :
+    def build_SimpleAccess (self, node) :
+        decl = self.get_buffer(node.buffer)
+        net = self.snk.PetriNet("access")
+        net.add_transition(self.snk.Transition("t", status=self.snk.tick("action")))
+        b = self.snk.Place(str(node.buffer), [], decl.type,
+                           status=self.snk.buffer(node.buffer))
+        b.label(path=self.path,
+                buffer=str(node.buffer),
+                srctext=decl.node.st.source(),
+                srcloc=(decl.node.st.srow, decl.node.st.scol,
+                        decl.node.st.erow, decl.node.st.ecol))
+        net.add_place(b)
+        self.build(node.arc)(net, node.buffer, "t", self.build_arc(node.tokens))
+        return net
+    def build_FlushAccess (self, node) :
+        decl = self.get_buffer(node.buffer)
+        net = self.snk.PetriNet("access")
+        net.add_transition(self.snk.Transition("t", status=self.snk.tick("action")))
+        b = self.snk.Place(str(node.buffer), [], decl.type,
+                           status=self.snk.buffer(node.buffer))
+        b.label(path=self.path,
+                buffer=str(node.buffer),
+                srctext=decl.node.st.source(),
+                srcloc=(decl.node.st.srow, decl.node.st.scol,
+                        decl.node.st.erow, decl.node.st.ecol))
+        net.add_place(b)
+        net.add_input(node.buffer, "t", self.snk.Flush(node.target))
+        return net
+    def build_SwapAccess (self, node) :
+        decl = self.get_buffer(node.buffer)
+        net = self.snk.PetriNet("access")
+        net.add_transition(self.snk.Transition("t", status=self.snk.tick("action")))
+        b = self.snk.Place(node.buffer, [], decl.type,
+                           status=self.snk.buffer(node.buffer))
+        b.label(path=self.path,
+                buffer=str(node.buffer),
+                srctext=decl.node.st.source(),
+                srcloc=(decl.node.st.srow, decl.node.st.scol,
+                        decl.node.st.erow, decl.node.st.ecol))
+        net.add_place(b)
+        net.add_input(node.buffer, "t", self.build_arc(node.target))
+        net.add_output(node.buffer, "t", self.build_arc(node.tokens))
+        return net
+    def build_Spawn (self, node) :
+        self._raise(NotImplementedError, "tasks not (yet) supported")
+    def build_Wait (self, node) :
+        self._raise(NotImplementedError, "tasks not (yet) supported")
+    def build_Suspend (self, node) :
+        self._raise(NotImplementedError, "tasks not (yet) supported")
+    def build_Resume (self, node) :
+        self._raise(NotImplementedError, "tasks not (yet) supported")
+    # arc labels
+    def build_arc_Name (self, node) :
+        if node.id in self :
+            decl = self[node.id]
+            if decl.kind in (Decl.CONST, Decl.SYMBOL) :
+                return self.snk.Value(decl.value)
+        return self.snk.Variable(node.id)
+    def build_arc_Num (self, node) :
+        return self.snk.Value(node.n)
+    def build_arc_Str (self, node) :
+        return self.snk.Value(node.s)
+    def build_arc_Tuple (self, node) :
+        return self.snk.Tuple([self.build_arc(elt) for elt in node.elts])
+    def build_arc_expr (self, node) :
+        return self.snk.Expression(unparse(node))
+    # arcs
+    def build_Produce (self, node) :
+        def arc (net, place, trans, label) :
+            net.add_output(place, trans, label)
+        return arc
+    def build_Test (self, node) :
+        def arc (net, place, trans, label) :
+            net.add_input(place, trans, self.snk.Test(label))
+        return arc
+    def build_Consume (self, node) :
+        def arc (net, place, trans, label) :
+            net.add_input(place, trans, label)
+        return arc
+    def build_Fill (self, node) :
+        def arc (net, place, trans, label) :
+            net.add_output(place, trans, self.snk.Flush(str(label)))
+        return arc
+    # types
+    def build_UnionType (self, node) :
+        return reduce(operator.or_, (self.build(child)
+                                     for child in node.types))
+    def build_IntersectionType (self, node) :
+        return reduce(operator.and_, (self.build(child)
+                                      for child in node.types))
+    def build_CrossType (self, node) :
+        return self.snk.CrossProduct(*(self.build(child)
+                                       for child in node.types))
+    def build_ListType (self, node) :
+        return self.snk.List(self.build(node.items))
+    def build_TupleType (self, node) :
+        return self.snk.Collection(self.snk.Instance(tuple),
+                                   (self.build(node.items)))
+    def build_SetType (self, node) :
+        return self.snk.Set(self.build(node.items))
+    def build_DictType (self, node) :
+        return self.snk.Mapping(keys=self.build(node.keys),
+                                items=self.build(node.items),
+                                _dict=self.snk.Instance(self.snk.hdict))
+    def build_EnumType (self, node) :
+        return self.snk.OneOf(*(self._eval(child) for child in node.items))
+    def build_NamedType (self, node) :
+        name = node.name
+        if name in self and self[name].kind == Decl.TYPE :
+            return self[name].type
+        elif name in self.globals :
+            obj = self.globals[name]
+            if inspect.isclass(obj) :
+                return self.snk.Instance(obj)
+            elif inspect.isroutine(obj) :
+                return self.snk.TypeCheck(obj)
+        elif hasattr(sys.modules["__builtin__"], name) :
+            obj = getattr(sys.modules["__builtin__"], name)
+            if inspect.isclass(obj) :
+                return self.snk.Instance(obj)
+            elif inspect.isroutine(obj) :
+                return self.snk.TypeCheck(obj)
+        self._raise(CompilationError,
+                    "invalid type %r" % name)
+
+if __name__ == "__main__" :
+    import doctest
+    doctest.testmod(optionflags=doctest.NORMALIZE_WHITESPACE
+                    | doctest.REPORT_ONLY_FIRST_FAILURE
+                    | doctest.ELLIPSIS)
+    from snakes.lang.abcd.parser import parse
+    node = parse(open(sys.argv[1]).read())
+    import snakes.plugins
+    snk = snakes.plugins.load(["ops", "gv", "labels"], "snakes.nets", "snk")
+    build = Builder(snk)
+    net = build.build(node)
+    net.draw(sys.argv[1] + ".png")

+import heapq
+from snakes.nets import StateGraph
+import snakes.lang
+import snkast as ast
+
+class Checker (object) :
+    def __init__ (self, net) :
+        self.g = StateGraph(net)
+        self.f = [self.build(f) for f in net.label("asserts")]
+    def build (self, tree) :
+        src = """
+def check (_) :
+    return %s
+""" % tree.st.source()[7:]
+        ctx = dict(self.g.net.globals)
+        ctx["bounded"] = self.bounded
+        exec(src, ctx)
+        fun = ctx["check"]
+        fun.lineno = tree.lineno
+        return fun
+    def bounded (self, marking, max) :
+        return all(len(marking(p)) == 1 for p in marking)
+    def run (self) :
+        for state in self.g :
+            marking = self.g.net.get_marking()
+            for place in marking :
+                if max(marking(place).values()) > 1 :
+                    return None, self.trace(state)
+            for check in self.f :
+                try :
+                    if not check(marking) :
+                        return check.lineno, self.trace(state)
+                except :
+                    pass
+        return None, None
+    def path (self, tgt, src=0) :
+        q = [(0, src, ())]
+        visited = set()
+        while True :
+            (c, v1, path) = heapq.heappop(q)
+            if v1 not in visited :
+                path = path + (v1,)
+                if v1 == tgt :
+                    return path
+                visited.add(v1)
+                for v2 in self.g.successors(v1) :
+                    if v2 not in visited :
+                        heapq.heappush(q, (c+1, v2, path))
+    def trace (self, state) :
+        path = self.path(state)
+        return tuple(self.g.successors(i)[j]
+                     for i, j in zip(path[:-1], path[1:]))

+import sys, optparse, os.path
+import pdb, traceback
+import snakes.plugins
+from snakes.utils.abcd.build import Builder
+from snakes.lang.abcd.parser import parse
+from snakes.lang.pgen import ParseError
+from snakes.utils.abcd import CompilationError, DeclarationError
+from snakes.utils.abcd.simul import Simulator
+from snakes.utils.abcd.checker import Checker
+
+##
+## error messages
+##
+
+ERR_ARG = 1
+ERR_OPT = 2
+ERR_IO = 3
+ERR_PARSE = 4
+ERR_PLUGIN = 5
+ERR_COMPILE = 6
+ERR_OUTPUT = 7
+ERR_BUG = 255
+
+def err (message) :
+    sys.stderr.write("abcd: %s\n" % message.strip())
+
+def die (code, message=None) :
+    if message :
+        err(message)
+    if options.debug :
+        pdb.post_mortem(sys.exc_info()[2])
+    else :
+        sys.exit(code)
+
+def bug () :
+    sys.stderr.write("""
+    ********************************************************************
+    *** An unexpected error ocurred. Please report this bug to       ***
+    *** <franck.pommereau@gmail.com>, together with the execution    ***
+    *** trace below and, if possible, a stripped-down version of the ***
+    *** ABCD source code that caused this bug. Thank you for your    ***
+    *** help in improving SNAKES!                                    ***
+    ********************************************************************
+
+""")
+    traceback.print_exc()
+    if options.debug :
+        pdb.post_mortem(sys.exc_info()[2])
+    else :
+        sys.exit(ERR_BUG)
+
+##
+## options parsing
+##
+
+gv_engines = ("dot", "neato", "twopi", "circo", "fdp")
+
+opt = optparse.OptionParser(prog="abcd",
+                            usage="%prog [OPTION]... FILE")
+opt.add_option("-l", "--load",
+               dest="plugins", action="append", default=[],
+               help="load plugin (this option can be repeated)",
+               metavar="PLUGIN")
+opt.add_option("-p", "--pnml",
+               dest="pnml", action="store", default=None,
+               help="save net as PNML",
+               metavar="OUTFILE")
+for engine in gv_engines :
+    opt.add_option("-" + engine[0], "--" + engine,
+                   dest="gv" + engine, action="store", default=None,
+                   help="draw net using '%s' (from GraphViz)" % engine,
+                   metavar="OUTFILE")
+opt.add_option("-a", "--all-names",
+               dest="allnames", action="store_true", default=False,
+               help="draw control-flow places names (default: hide)")
+opt.add_option("--debug",
+               dest="debug", action="store_true", default=False,
+               help="launch debugger on compiler error (default: no)")
+opt.add_option("-s", "--simul",
+               dest="simul", action="store_true", default=False,
+               help="launch interactive code simulator")
+opt.add_option("--check",
+               dest="check", action="store_true", default=False,
+               help="check assertions")
+
+def getopts (args) :
+    global options, abcd
+    (options, args) = opt.parse_args(args)
+    plugins = []
+    for p in options.plugins :
+        plugins.extend(t.strip() for t in p.split(","))
+    if "ops" not in options.plugins :
+        plugins.append("ops")
+    if "labels" not in plugins :
+        plugins.append("labels")
+    for engine in gv_engines :
+        gvopt = getattr(options, "gv%s" % engine)
+        if gvopt and "gv" not in plugins :
+            plugins.append("gv")
+            break
+    options.plugins = plugins
+    if len(args) < 1 :
+        err("no input file provided")
+        opt.print_help()
+        die(ERR_ARG)
+    elif len(args) > 1 :
+        err("more than one input file provided")
+        opt.print_help()
+        die(ERR_ARG)
+    abcd = args[0]
+    if options.pnml == abcd :
+        err("input file also used as output (--pnml)")
+        opt.print_help()
+        die(ERR_ARG)
+    for engine in gv_engines :
+        if getattr(options, "gv%s" % engine) == abcd :
+            err("input file also used as output (--%s)" % engine)
+            opt.print_help()
+            die(ERR_ARG)
+
+##
+## drawing nets
+##
+
+def place_attr (place, attr) :
+    # fix color
+    if place.status == snk.entry :
+        attr["fillcolor"] = "green"
+    elif place.status == snk.internal :
+        pass
+    elif place.status == snk.exit :
+        attr["fillcolor"] = "yellow"
+    else :
+        attr["fillcolor"] = "lightblue"
+    # fix shape
+    if (not options.allnames
+        and place.status in (snk.entry, snk.internal, snk.exit)) :
+        attr["shape"] = "circle"
+    # render marking
+    if place._check == snk.tBlackToken :
+        count = len(place.tokens)
+        if count == 0 :
+            marking = " "
+        elif count == 1 :
+            marking = "@"
+        else :
+            marking = "%s@" % count
+    else :
+        marking = str(place.tokens)
+    # node label
+    if (options.allnames
+        or place.status not in (snk.entry, snk.internal, snk.exit)) :
+        attr["label"] = "%s\\n%s" % (place.name, marking)
+    else :
+        attr["label"] = "%s" % marking
+
+def trans_attr (trans, attr) :
+    pass
+
+def arc_attr (label, attr) :
+    if label == snk.Value(snk.dot) :
+        del attr["label"]
+    elif isinstance(label, snk.Test) :
+        attr["arrowhead"] = "none"
+        attr["label"] = " %s " % label._annotation
+    elif isinstance(label, snk.Flush) :
+        attr["arrowhead"] = "box"
+        attr["label"] = " %s " % label._annotation
+
+def draw (net, engine, target) :
+    try :
+        net.draw(target, engine=engine,
+                 place_attr=place_attr,
+                 trans_attr=trans_attr,
+                 arc_attr=arc_attr)
+    except :
+        die(ERR_OUTPUT, str(sys.exc_info()[1]))
+
+##
+## save pnml
+##
+
+def save_pnml (net, target) :
+    try :
+        out = open(target, "w")
+        out.write(snk.dumps(net))
+        out.close()
+    except :
+        die(ERR_OUTPUT, str(sys.exc_info()[1]))
+
+##
+## main
+##
+
+def main (args=sys.argv[1:], src=None) :
+    global snk
+    # get options
+    try:
+        if src is None :
+            getopts(args)
+        else :
+            getopts(list(args) + ["<string>"])
+    except SystemExit :
+        raise
+    except :
+        die(ERR_OPT, str(sys.exc_info()[1]))
+    # read source
+    if src is not None :
+        source = src
+    else :
+        try :
+            source = open(abcd).read()
+        except :
+            die(ERR_IO, "could not read input file %r" % abcd)
+    # parse
+    try :
+        node = parse(source, filename=abcd)
+    except ParseError :
+        die(ERR_PARSE, str(sys.exc_info()[1]))
+    except :
+        bug()
+    # compile
+    dirname = os.path.dirname(abcd)
+    if dirname and dirname not in sys.path :
+        sys.path.append(dirname)
+    elif "." not in sys.path :
+        sys.path.append(".")
+    try :
+        snk = snakes.plugins.load(options.plugins, "snakes.nets", "snk")
+    except :
+        die(ERR_PLUGIN, str(sys.exc_info()[1]))
+    build = Builder(snk)
+    try :
+        net = build.build(node)
+        net.label(srcfile=abcd)
+    except (CompilationError, DeclarationError) :
+        die(ERR_COMPILE, str(sys.exc_info()[1]))
+    except :
+        bug()
+    # output
+    if options.pnml :
+        save_pnml(net, options.pnml)
+    for engine in gv_engines :
+        target = getattr(options, "gv%s" % engine)
+        if target :
+            draw(net, engine, target)
+    trace, lineno = [], None
+    if options.check :
+        lineno, trace = Checker(net).run()
+    if options.simul :
+        Simulator(snk, source, net, trace, lineno).run()
+    elif trace :
+        if lineno is None :
+            print("unsafe execution:")
+        else :
+            asserts = dict((a.lineno, a) for a in net.label("asserts"))
+            print("line %s, %r failed:"
+                  % (lineno, asserts[lineno].st.source()))
+        for trans, mode in trace :
+            print("  %s %s" % (trans, mode))
+    return net
+
+if __name__ == "__main__" :
+    main()

+import math, operator, collections
+import Tkinter as tk
+import tkMessageBox as popup
+try :
+    import Tkinter.scrolledtext as ScrolledText
+except ImportError :
+    import ScrolledText
+
+class Action (object) :
+    def __init__ (self, trans, mode, shift) :
+        self.trans = trans
+        self.mode = mode
+        self.net = trans.net
+        self.pre = self.net.get_marking()
+        self.post = None
+        srow, scol, erow, ecol = trans.label("srcloc")
+        self.start = "%s.%s" % (srow, scol + shift)
+        self.stop = "%s.%s" % (erow, ecol + shift)
+        self.line = srow
+    def fire (self) :
+        self.trans.fire(self.mode)
+        self.post = self.net.get_marking()
+    def __eq__ (self, other) :
+        try :
+            return (self.trans == other.trans and self.mode == other.mode
+                    and self.net == other.net)
+        except AttributeError :
+            return False
+
+class Trace (object) :
+    def __init__ (self, net) :
+        self.net = net
+        self.actions = []
+    def add (self, action) :
+        self.actions.append(action)
+    def back (self) :
+        self.net.set_marking(self.actions[-1].pre)
+        self.actions.pop()
+    def empty (self) :
+        return not self.actions
+    def __getitem__ (self, idx) :
+        return self.actions[idx]
+    def __len__ (self) :
+        return len(self.actions)
+
+class Simulator (object) :
+    def __init__ (self, snk, src, net, trace=None, errline=None) :
+        self.snk = snk
+        self.src = src
+        self.net = net
+        self.srclength = len(src.splitlines())
+        self.width = int(math.ceil(math.log10(self.srclength)))
+        self.shift = self.width + 2
+        self.modes = []
+        self.trans2modes = collections.defaultdict(set)
+        self.trace = Trace(self.net)
+        self.build_gui(errline)
+        if trace is not None :
+            for trans, mode in trace :
+                trans = self.net.transition(trans.name)
+                action = Action(trans, mode, self.shift)
+                action.fire()
+                self.extend_trace(action)
+                self.trace.add(action)
+        self.update()
+        if trace :
+            self._back.configure(state=tk.NORMAL)
+    def update (self) :
+        self.update_modes()
+        self.update_state()
+    def build_gui (self, errline) :
+        self._win = tk.Tk()
+        self._win.title("ABCD simulator")
+        self._win.bind("<Return>", self.fire)
+        self._win.bind("<BackSpace>", self.back)
+        self._win.bind("<Escape>", self.quit)
+        # paned windows and frames
+        self._pan_main = tk.PanedWindow(self._win, orient=tk.HORIZONTAL)
+        self._pan_main.grid(row=0, column=0, sticky=tk.N+tk.S+tk.E+tk.W)
+        self.__pan_left = tk.PanedWindow(self._pan_main, orient=tk.VERTICAL)
+        self._pan_main.add(self.__pan_left)
+        self._pan_right = tk.PanedWindow(self._pan_main, orient=tk.VERTICAL)
+        self._pan_main.add(self._pan_right)
+        self._modes_frame = tk.Frame(self.__pan_left)
+        self.__pan_left.add(self._modes_frame)
+        self._trace_frame = tk.Frame(self.__pan_left)
+        self.__pan_left.add(self._trace_frame)
+        self._state_frame = tk.Frame(self._pan_right)
+        self._pan_right.add(self._state_frame)
+        # modes
+        self._modes_x = tk.Scrollbar (self._modes_frame,
+                                      orient=tk.HORIZONTAL)
+        self._modes_x.grid(row=1, column=0, sticky=tk.W+tk.E)
+        self._modes_y = tk.Scrollbar (self._modes_frame, orient=tk.VERTICAL)
+        self._modes_y.grid(row=0, column=1, sticky=tk.N+tk.S)
+        self._modes = tk.Listbox(self._modes_frame,
+                                 xscrollcommand=self._modes_x.set,
+                                 yscrollcommand=self._modes_y.set,
+                                 width=50,
+                                 font="monospace",
+                                 activestyle="none",
+                                 selectbackground="green",
+                                 selectborderwidth=0,
+                                 highlightthickness=0,
+                                 selectmode=tk.SINGLE,
+                                 disabledforeground="black")
+        self._modes.grid(row=0, column=0, sticky=tk.N+tk.S+tk.E+tk.W)
+        self._modes_x["command"] = self._modes.xview
+        self._modes_y["command"] = self._modes.yview
+        self._modes.bind("<Button-1>", self.select_mode)
+        self._modes.bind("<Double-Button-1>", self.select_mode_fire)
+        # fire button
+        self._fire = tk.Button(self._modes_frame,
+                               text="Fire",
+                               command=self.fire,
+                               state=tk.DISABLED)
+        self._fire.grid(row=2, column=0, columnspan=2, sticky=tk.W+tk.E)
+        # back button
+        self._back = tk.Button(self._modes_frame,
+                               text="Undo last action",
+                               command=self.back,
+                               state=tk.DISABLED)
+        self._back.grid(row=3, column=0, columnspan=2, sticky=tk.W+tk.E)
+        # resume button
+        self._resume = tk.Button(self._modes_frame,
+                                 text="Resume simulation",
+                                 command=self.resume,
+                                 state=tk.DISABLED)
+        self._resume.grid(row=4, column=0, columnspan=2, sticky=tk.W+tk.E)
+        # traces
+        self._trace_x = tk.Scrollbar (self._trace_frame,
+                                      orient=tk.HORIZONTAL)
+        self._trace_x.grid(row=1, column=0, sticky=tk.W+tk.E)
+        self._trace_y = tk.Scrollbar (self._trace_frame, orient=tk.VERTICAL)
+        self._trace_y.grid(row=0, column=1, sticky=tk.N+tk.S)
+        self._trace = tk.Listbox(self._trace_frame,
+                                 font="monospace",
+                                 width=50,
+                                 activestyle="none",
+                                 selectbackground="blue",
+                                 xscrollcommand=self._trace_x.set,
+                                 yscrollcommand=self._trace_y.set,
+                                 disabledforeground="black")
+        self._trace.grid(row=0, column=0, sticky=tk.N+tk.S+tk.E+tk.W)
+        self._trace_x["command"] = self._trace.xview
+        self._trace_y["command"] = self._trace.yview
+        self._trace.bind("<Button-1>", self.select_trace)
+        self._trace.insert(tk.END, "<init>")
+        # save trace button
+        # self._save = tk.Button(self._trace_frame,
+        #                        text="Save trace",
+        #                        command=self.save)
+        # self._save.grid(row=2, column=0, columnspan=2, sticky=tk.W+tk.E)
+        # source
+        self._source = ScrolledText.ScrolledText(self._pan_right,
+                                                 font="monospace",
+                                                 width=70,
+                                                 height=min([self.srclength,
+                                                             25]))
+        self._pan_right.add(self._source)
+        self._source.tag_config("linenum",
+                                background="#eee",
+                                foreground="#222")
+        for num, line in enumerate(self.src.splitlines()) :
+            if num :
+                self._source.insert(tk.END, "\n")
+            self._source.insert(tk.END, "%s: %s"
+                                % (str(num+1).rjust(self.width), line))
+            self._source.tag_add("linenum",
+                                 "%s.0" % (num+1),
+                                 "%s.%s" % (num+1, self.width+1))
+        self._source.configure(state=tk.DISABLED)
+        if errline is not None :
+            self._source.tag_add("error",
+                                "%s.%s" % (errline, self.shift),
+                                "%s.end" % errline)
+            self._source.tag_config("error", background="red")
+        # states
+        self._state = ScrolledText.ScrolledText(self._pan_right,
+                                                font="monospace",
+                                                width=70,
+                                                state=tk.DISABLED,
+                                                height=10)
+        self._pan_right.add(self._state)
+        # setup cells expansion
+        for widget in (self._win.winfo_toplevel(), self._win,
+                       self._modes_frame, self._trace_frame) :
+            widget.rowconfigure(0, weight=1)
+            widget.columnconfigure(0, weight=1)
+        # tag places and transitions
+        for place in self.net.place() :
+            if place.status not in (self.snk.entry, self.snk.internal,
+                                    self.snk.exit) :
+                srow, scol, erow, ecol = place.label("srcloc")
+                self._source.tag_add(place.name,
+                                     "%s.%s" % (srow, scol + self.shift),
+                                     "%s.%s" % (erow, ecol + self.shift))
+                self.buffer_bind(self._source, place.name)
+        for trans in self.net.transition() :
+            srow, scol, erow, ecol = trans.label("srcloc")
+            self._source.tag_add(trans.name,
+                                 "%s.%s" % (srow, scol + self.shift),
+                                 "%s.%s" % (erow, ecol + self.shift))
+            self.trans_bind(trans.name)
+    def trans_bind (self, tag) :
+        def trans_enter (evt) :
+            self.trans_enter(tag)
+        self._source.tag_bind(tag, "<Enter>", trans_enter)
+        def trans_leave (evt) :
+            self.trans_leave(tag)
+        self._source.tag_bind(tag, "<Leave>", trans_leave)
+    def buffer_bind (self, widget, tag) :
+        def buffer_enter (evt) :
+            self.buffer_enter(tag)
+        widget.tag_bind(tag, "<Enter>", buffer_enter)
+        def buffer_leave (evt) :
+            self.buffer_leave(tag)
+        widget.tag_bind(tag, "<Leave>", buffer_leave)
+    def run (self) :
+        self._win.mainloop()
+    def update_modes (self) :
+        self._modes.delete(0, tk.END)
+        self.modes = []
+        self.selected_mode = None
+        self.trans2modes = collections.defaultdict(set)
+        for trans in self.net.transition() :
+            self._source.tag_config(trans.name, background="white")
+            for mode in trans.modes() :
+                self.modes.append(Action(trans, mode, self.shift))
+        self.modes.sort(key=operator.attrgetter("line"))
+        for idx, action in enumerate(self.modes) :
+            self.trans2modes[action.trans.name].add(idx)
+            self._modes.insert(tk.END, "%s @ %s"
+                               % (action.mode, action.trans.name))
+            self._source.tag_config(action.trans.name, background="yellow")
+            self._source.tag_raise(action.trans.name)
+        if not self.modes :
+            self._fire.configure(state=tk.DISABLED)
+    def fire (self, evt=None) :
+        if evt is not None :
+            self._fire.flash()
+        action = self.modes[self.selected_mode]
+        action.fire()
+        self.trace.add(action)
+        self.extend_trace(action)
+        self.update()
+        self._fire.configure(state=tk.DISABLED)
+        self._back.configure(state=tk.NORMAL)
+    def extend_trace (self, action) :
+        self._trace.insert(tk.END, "%s @ %s"
+                           % (action.mode, action.trans.name))
+        self._trace.see(self._trace.size()-1)
+    def trans_enter (self, trans) :
+        if trans in self.trans2modes :
+            state = self._modes["state"]
+            self._modes.configure(state=tk.NORMAL)
+            for idx in self.trans2modes[trans] :
+                self._modes.itemconfig(idx,
+                                       background="orange",
+                                       selectbackground="orange")
+                self._modes.see(idx)
+            self._source.tag_config(trans, background="orange")
+            self._modes.configure(state=state)
+    def trans_leave (self, trans) :
+        if trans in self.trans2modes :
+            state = self._modes["state"]
+            self._modes.configure(state=tk.NORMAL)
+            for idx in self.trans2modes[trans] :
+                self._modes.itemconfig(idx,
+                                       background="white",
+                                       selectbackground="green")
+            if self.selected_mode in self.trans2modes[trans] :
+                self._source.tag_config(trans, background="green")
+            else :
+                self._source.tag_config(trans, background="yellow")
+            self._modes.configure(state=state)
+    def select_mode (self, evt) :
+        if not self.modes or self._modes["state"] == "disabled" :
+            return
+        if isinstance(evt, int) :
+            idx = evt
+        else :
+            idx = self._modes.nearest(evt.y)
+        for num in range(len(self.modes)) :
+            self._source.tag_config(self.modes[num].trans.name,
+                                    background="yellow")
+        self._source.tag_config(self.modes[idx].trans.name,
+                                background="green")
+        self.selected_mode = idx
+        self._fire.configure(state=tk.NORMAL)
+    def select_mode_fire (self, evt) :
+        if self.modes  or self._modes["state"] == "disabled" :
+            self.select_mode(evt)
+            self.fire(evt)
+    def back (self, evt=None) :
+        if evt is not None :
+            self._back.flash()
+        self.trace.back()
+        self._trace.delete(self._trace.size()-1)
+        if self._trace.curselection() :
+            last = self._trace.size() - 1
+            self._trace.selection_clear(0, last)
+            self._trace.see(last)
+        self.update()
+        if self.trace.empty() :
+            self._back.configure(state=tk.DISABLED)
+    def save (self, evt=None) :
+        if evt is not None :
+            self._save.flash()
+    def update_state (self) :
+        self._state.configure(state=tk.NORMAL)
+        self._state.delete("1.0", tk.END)
+        pos = 1
+        for place in self.net.place() :
+            if place.status not in (self.snk.entry, self.snk.internal,
+                                    self.snk.exit) :
+                self._state.insert(tk.END, "%s = %s\n"
+                                   % (place.name, place.tokens))
+                self._state.tag_add(place.name,
+                                    "%s.0" % pos, "%s.end" % pos)
+                pos += 1
+                self.buffer_bind(self._state, place.name)
+        self._state.configure(state=tk.DISABLED)
+    def buffer_enter (self, tag) :
+        self._state.tag_configure(tag, background="#cff")
+        self._source.tag_configure(tag, background="#cff")
+    def buffer_leave (self, tag) :
+        self._state.tag_configure(tag, background="white")
+        self._source.tag_configure(tag, background="white")
+    def quit (self, evt=None) :
+        if popup.askokcancel("Really quit?", "Are you sure you want to"
+                             " quit the simulator?") :
+            self._win.quit()
+    def select_trace (self, evt) :
+        idx = self._trace.nearest(evt.y)
+        if idx == 0 :
+            self.net.set_marking(self.trace[0].pre)
+        else :
+            self.net.set_marking(self.trace[idx-1].post)
+        self._modes.configure(state=tk.NORMAL)
+        self.update()
+        if idx < len(self.trace) :
+            self._modes.selection_set(self.modes.index(self.trace[idx]))
+            self.select_mode(idx)
+        self._fire.configure(state=tk.DISABLED)
+        self._modes.configure(state=tk.DISABLED)
+        self._resume.configure(state=tk.NORMAL)
+    def resume (self) :
+        if self._trace.curselection() :
+            last = self._trace.size() - 1
+            self._trace.selection_clear(0, last)
+            self._trace.see(last)
+            self.net.set_marking(self.trace[-1].post)
+            self.update_state()
+        self._resume.configure(state=tk.DISABLED)
+        self._modes.configure(state=tk.NORMAL)

+from snakes.lang.abcd.parser import ast
+
+class NodeCopier (ast.NodeTransformer) :
+    def copy (self, node, **replace) :
+        args = {}
+        for name in node._fields + node._attributes :
+            old = getattr(node, name, None)
+            if name in replace :
+                new = replace[name]
+            elif isinstance(old, list):
+                new = []
+                for val in old :
+                    if isinstance(val, ast.AST) :
+                        new.append(self.visit(val))
+                    else :
+                        new.append(val)
+            elif isinstance(old, ast.AST):
+                new = self.visit(old)
+            else :
+                new = old
+            args[name] = new
+        if hasattr(node, "st") :
+            args["st"] = node.st
+        return node.__class__(**args)
+    def generic_visit (self, node) :
+        return self.copy(node)
+
+class ArgsBinder (NodeCopier) :
+    def __init__ (self, args, buffers, nets, tasks) :
+        NodeCopier.__init__(self)
+        self.args = args
+        self.buffers = buffers
+        self.nets = nets
+        self.tasks = tasks
+    def visit_Name (self, node) :
+        if node.id in self.args :
+            return self.copy(self.args[node.id])
+        else :
+            return self.copy(node)
+    def visit_Instance (self, node) :
+        if node.net in self.nets :
+            return self.copy(node, net=self.nets[node.net])
+        else :
+            return self.copy(node)
+    def _visit_access (self, node) :
+        if node.buffer in self.buffers :
+            return self.copy(node, buffer=self.buffers[node.buffer])
+        else :
+            return self.copy(node)
+    def visit_SimpleAccess (self, node) :
+        return self._visit_access(node)
+    def visit_FlushAccess (self, node) :
+        return self._visit_access(node)
+    def visit_SwapAccess (self, node) :
+        return self._visit_access(node)
+    def _visit_task (self, node) :
+        if node.net in self.tasks :
+            return self.copy(node, net=self.tasks[node.net])
+        else :
+            return self.copy(node)
+    def visit_Spawn (self, node) :
+        return self._visit_task(node)
+    def visit_Wait (self, node) :
+        return self._visit_task(node)
+    def visit_Suspend (self, node) :
+        return self._visit_task(node)
+    def visit_Resume (self, node) :
+        return self._visit_task(node)
+    def visit_AbcdNet (self, node) :
+        args = self.args.copy()
+        buffers = self.buffers.copy()
+        nets = self.nets.copy()
+        tasks = self.tasks.copy()
+        netargs = ([a.arg for a in node.args.args + node.args.kwonlyargs]
+                   + [node.args.vararg, node.args.kwarg])
+        copy = True
+        for a in netargs :
+            for d in (args, buffers, nets, tasks) :
+                if a in d :
+                    del d[a]
+                    copy = False
+        if copy :
+            return self.copy(node)
+        else :
+            return self.__class__(args, buffers, nets, tasks).visit(node)
+
+if __name__ == "__main__" :
+    import doctest
+    doctest.testmod()

+import sys, os, os.path
+import inspect, fnmatch, collections
+import textwrap, doctest, ast
+import snakes
+from snakes.lang import unparse
+
+##
+## console messages
+##
+
+CLEAR = "\033[0m"
+BLUE = "\033[1;34m"
+BOLD = "\033[1;38m"
+GRAY = "\033[1;30m"
+LIGHTGRAY = "\033[0;30m"
+GREEN = "\033[1;32m"
+CYAN = "\033[1;36m"
+MAGENTA = "\033[1;35m"
+RED = "\033[1;31m"
+YELLOW = "\033[1;33m"
+
+def log (message, color=None, eol=True) :
+    if color :
+        sys.stderr.write(color)
+    if isinstance(message, (list, tuple)) :
+        message = " ".join(str(m) for m in message)
+    sys.stderr.write(message)
+    if color :
+        sys.stderr.write(CLEAR)
+    if eol :
+        sys.stderr.write("\n")
+    sys.stderr.flush()
+
+def debug (message, eol=True) :
+    log("[debug] ", GRAY, eol=False)
+    log(message, LIGHTGRAY, eol=eol)
+
+def info (message, eol=True) :
+    log("[info] ", BLUE, False)
+    log(message, eol=eol)
+
+def warn (message, eol=True) :
+    log("[warn] ", YELLOW, False)
+    log(message, eol=eol)
+
+def err (message, eol=True) :
+    log("[error] ", RED, False)
+    log(message, eol=eol)
+
+def die (message, code=1) :
+    err(message)
+    sys.exit(code)
+
+##
+## extract doc
+##
+
+class DocExtract (object) :
+    def __init__ (self, inpath, outpath, exclude=[]) :
+        self.path = inpath.rstrip(os.sep)
+        self.outpath = outpath
+        self.out = None
+        self.exclude = exclude
+        self._last = "\n\n"
+    def openout (self, path) :
+        if self.out is not None :
+            self.out.close()
+        relpath = path[len(os.path.dirname(self.path)):].strip(os.sep)
+        parts = relpath.split(os.sep)
+        relpath = os.path.dirname(relpath.split(os.sep, 1)[-1])
+        self.package = (parts[-1] == "__init__.py")
+        if self.package :
+            self.module = ".".join(parts[:-1])
+            target = "index.md"
+        else :
+            parts[-1] = os.path.splitext(parts[-1])[0]
+            self.module = ".".join(parts)
+            target =  parts[-1] + ".md"
+        if any(fnmatch.fnmatch(self.module, glob) for glob in self.exclude) :
+            warn("skip %s" % self.module)
+            return False
+        outdir = os.path.join(self.outpath, relpath)
+        outpath = os.path.join(outdir, target)
+        info("%s -> %r" % (self.module, outpath))
+        if not os.path.exists(outdir) :
+            os.makedirs(outdir)
+        self.out = open(outpath, "w")
+        self.classname = None
+        return True
+    def write (self, text) :
+        if len(text) > 1 :
+            self._last = text[-2:]
+        elif len(text) > 0 :
+            self._last = self._last[-1] + text[-1]
+        else :
+            return
+        self.out.write(text)
+    def newline (self) :
+        if self._last != "\n\n" :
+            self.write("\n")
+    def writeline (self, text="") :
+        self.write(text.rstrip() + "\n")
+    def writetext (self, text, **args) :
+        br = args.pop("break_on_hyphens", False)
+        for line in textwrap.wrap(text, break_on_hyphens=br, **args) :
+            self.writeline(line)
+    def writelist (self, text, bullet="  * ", **args) :
+        br = args.pop("break_on_hyphens", False)
+        for line in textwrap.wrap(text, break_on_hyphens=br,
+                                  initial_indent=bullet,
+                                  subsequent_indent=" "*len(bullet),
+                                  **args) :
+            self.writeline(line)
+    def process (self) :
+        for dirpath, dirnames, filenames in os.walk(self.path) :
+            for name in sorted(filenames) :
+                if not name.endswith(".py") :
+                    continue
+                path = os.path.join(dirpath, name)
+                if not self.openout(path) :
+                    continue
+                node = ast.parse(open(path).read())
+                if ".plugins." in self.module :
+                    self.visit_plugin(node)
+                else :
+                    self.visit_module(node)
+    def _pass (self, node) :
+        pass
+    def visit (self, node) :
+        name = getattr(node, "name", "__")
+        if (name.startswith("_") and not (name.startswith("__")
+                                          and name.endswith("__"))) :
+            return
+        try :
+            getattr(self, "visit_" + node.__class__.__name__, self._pass)(node)
+        except :
+            src = unparse(node)
+            if len(src) > 40 :
+                src = src[:40] + "..."
+            err("line %s source %r" % (node.lineno, src))
+            raise
+    def visit_module (self, node) :
+        doc = ast.get_docstring(node)
+        self.write_module()
+        for child in ast.iter_child_nodes(node) :
+            self.visit(child)
+    def visit_plugin (self, node) :
+        doc = ast.get_docstring(node)
+        self.write_module()
+        extend = None
+        for child in ast.iter_child_nodes(node) :
+            if (getattr(child, "name", None) == "extend"
+                and isinstance(child, ast.FunctionDef)) :
+                extend = child
+            else :
+                self.visit(child)
+        doc = ast.get_docstring(extend)
+        self.write_plugin()
+        for child in ast.iter_child_nodes(extend) :
+            self.visit(child)
+    def visit_ClassDef (self, node) :
+        doc = ast.get_docstring(node)
+        self.write_class(node)
+        self.classname = node.name
+        for child in ast.iter_child_nodes(node) :
+            self.visit(child)
+        self.classname = None
+    def visit_FunctionDef (self, node) :
+        self.write_function(node)
+        self.args = [n.id for n in node.args.args]
+        if self.args and self.args[0] == "self" :
+            del self.args[0]
+        if node.args.vararg :
+            self.args.append(node.args.vararg)
+        if node.args.kwarg :
+            self.args.append(node.args.kwarg)
+        self.visit(node.body[0])
+        self.args = []
+    def visit_Expr (self, node) :
+        self.visit(node.value)
+    def visit_Str (self, node) :
+        self.write_doc(inspect.cleandoc(node.s))
+    def write_module (self) :
+        if self.package :
+            self.writeline("# Package `%s` #" % self.module)
+        else :
+            self.writeline("# Module `%s` #" % self.module)
+        self.newline()
+    def write_plugin (self) :
+        self.writeline("## Extensions ##")
+        self.newline()
+    def write_function (self, node) :
+        self.newline()
+        if self.classname :
+            self.writeline("#### Method `%s.%s` ####"
+                           % (self.classname, node.name))
+        else :
+            self.writeline("### Function `%s` ###" % node.name)
+        self.newline()
+        self.writeline("    :::python")
+        for line in unparse(node).splitlines() :
+            if line.startswith("def") :
+                self.writeline("    %s ..." % line)
+                break
+            else :
+                self.writeline("    " + line)
+        self.newline
+    def write_class (self, node) :
+        self.newline()
+        self.writeline("### Class `%s` ###" % node.name)
+        self.newline()
+        self.writeline("    :::python")
+        for line in unparse(node).splitlines() :
+            if line.startswith("class") :
+                self.writeline("    %s ..." % line)
+                break
+            else :
+                self.writeline("    " + line)
+        self.newline
+    parse = doctest.DocTestParser().parse
+    def write_doc (self, doc) :
+        if doc is None :
+            return
+        docs = self.parse(doc)
+        test, skip = False, False
+        for doc in docs :
+            if isinstance(doc, str) :
+                doc = doc.strip()
+                if test :
+                    if not doc :
+                        continue
+                    test, skip = False, False
+                self.newline()
+                lines = doc.strip().splitlines()
+                for num, line in enumerate(lines) :
+                    if line.startswith("@") :
+                        self.write_epydoc("\n".join(lines[num:]))
+                        break
+                    self.writeline(line)
+            elif not skip :
+                if doc.source.strip() == "pass" :
+                    skip = True
+                else :
+                    if not test :
+                        test = True
+                        self.newline()
+                        self.writeline("    :::python")
+                    for i, line in enumerate(doc.source.splitlines()) :
+                        if i > 0 :
+                            self.writeline("    ... %s" % line)
+                        else :
+                            self.writeline("    >>> %s" % line)
+                    for line in doc.want.splitlines() :
+                        self.writeline("    %s" % line)
+    def write_epydoc (self, doc) :
+        info = {"param" : {},
+                "type" : {},
+                "keyword" : {},
+                "raise" : {},
+                "todo" : [],
+                "note" : [],
+                "attention": [],
+                "bug" : [],
+                "warning" : [],
+                }
+        for item in doc.lstrip("@").split("\n@") :
+            left, text = item.split(":", 1)
+            left = left.split()
+            assert 1 <= len(left) <= 2, "unsupported item %r" % item
+            if len(left) == 1 :
+                left.append(None)
+            tag, name = [x.strip() if x else x for x in left]
+            text = " ".join(text.strip().split())
+            if isinstance(info.get(tag, None), list) :
+                assert name is None, "unsupported item %r" % item
+                info[tag].append(text)
+            elif isinstance(info.get(tag, None), dict) :
+                assert name is not None, "unsupported item %r" % item
+                assert name not in info[tag], "duplicated item %r" % item
+                info[tag][name] = text
+            else :
+                assert name is None, "unsupported item %r" % item
+                assert tag not in info, "duplicated tag %r" % item
+                info[tag] = text
+        if any(k in info for k in ("author", "organization", "copyright",
+                                   "license", "contact")) :
+            self.newline()
+            self.writeline('<div class="api-info">')
+            for tag in ("author", "organization", "copyright",
+                        "license", "contact") :
+                if tag in info :
+                    self.writeline('<div class="api-%s">' % tag)
+                    self.writetext('<span class="api-title">%s:</span> %s'
+                                   % (tag.capitalize(), info[tag]),
+                                   subsequent_indent="  ")
+                    self.writeline('</div>')
+            self.writeline('</div>')
+        if any(info[k] for k in
+               ("todo", "note", "attention", "bug", "warning")) :
+            self.newline()
+            self.writeline('<div class="api-remarks">')
+            self.writeline("##### Remarks #####")
+            self.newline()
+            for tag in ("note", "todo", "attention", "bug", "warning") :
+                for text in info[tag] :
+                    self.writeline('<div class="api-%s">' % tag)
+                    self.writetext('<span class="api-title">%s:</span> %s'
+                                   % (tag.capitalize(), text),
+                                   subsequent_indent="  ")
+                    self.writeline('</div>')
+            self.writeline('</div>')
+        if (any(info[k] for k in ("param", "type", "keyword"))
+            or any(k in info for k in ("return", "rtype"))) :
+            self.newline()
+            self.writeline('<div class="api-call">')
+            self.writeline("##### Call API #####")
+            self.newline()
+            for arg in self.args :
+                if arg in info["param"] :
+                    self.writelist("`%s` (%s): %s"
+                                   % (arg,
+                                      info["type"].get(arg, "`object`"),
+                                      info["param"][arg]))
+                else :
+                    self.writelist("`%s` (%s)"
+                                   % (arg,
+                                      info["type"].get(arg, "`object`")))
+            for kw, text in sorted(info["keyword"].items()) :
+                self.writelist("`%s`: %s" % (kw, text))
+            if any(k in info for k in ("return", "rtype")) :
+                if "return" in info :
+                    self.writelist("return %s: %s"
+                                   % (info.get("rtype", "`object`"),
+                                      info["return"]))
+                else :
+                    self.writelist("return %s"
+                                   % (info.get("rtype", "`object`")))
+            self.writeline('</div>')
+        if info["raise"] :
+            self.newline()
+            self.writeline('<div class="api-errors">')
+            self.writeline("##### Exceptions #####")
+            self.newline()
+            for exc, reason in sorted(info["raise"].items()) :
+                self.writelist("`%s`: %s" % (exc, reason))
+            self.writeline('</div>')
+
+def main (finder, args) :
+    try :
+        source = os.path.dirname(snakes.__file__)
+        target = args[0]
+        exclude = args[1:]
+        if not os.path.isdir(source) :
+            raise Exception("could not find SNAKES sources")
+        elif not os.path.isdir(target) :
+            raise Exception("no directory %r" % target)
+    except ValueError :
+        die("""Usage: python %s TARGET [EXCLUDE...]
+        TARGET   target directory to write files
+        EXCLUDE  pattern to exclude modules (not file names)
+        """ % __file__)
+    except Exception as error :
+        die(str(error))
+    finder(source, target, exclude).process()
+
+if __name__ == "__main__" :
+    main(DocExtract, sys.argv[1:])

+from snakes.lang.ctlstar.parser import parse
+from snakes.lang.ctlstar import asdl as ast
+from snakes.lang import getvars, bind
+import _ast
+
+class SpecError (Exception) :
+    def __init__ (self, node, reason) :
+        Exception.__init__(self, "[line %s] %s" % (node.lineno, reason))
+
+def astcopy (node) :
+    if not isinstance(node, _ast.AST) :
+        return node
+    attr = {}
+    for name in node._fields + node._attributes :
+        value = getattr(node, name)
+        if isinstance(value, list) :
+            attr[name] = [astcopy(child) for child in value]
+        else :
+            attr[name] = astcopy(value)
+    return node.__class__(**attr)
+
+class Builder (object) :
+    def __init__ (self, spec) :
+        self.spec = spec
+        self.decl = {}
+        for node in spec.atoms + spec.properties :
+            if node.name in self.decl :
+                raise SpecError(node, "%r already declare line %s"
+                                % (name.name, self.decl[name.name].lineno))
+            self.decl[node.name] = node
+        self.main = spec.main
+    def build (self, node) :
+        node = astcopy(node)
+        return self._build(node, {})
+    def _build (self, node, ctx) :
+        if isinstance(node, ast.atom) :
+            try :
+                builder = getattr(self, "_build_%s" % node.__class__.__name__)
+            except AttributeError :
+                node.atomic = True
+            else :
+                node = builder(node, ctx)
+                node.atomic = True
+        elif isinstance(node, ast.CtlBinary) :
+            node.left = self._build(node.left, ctx)
+            node.right = self._build(node.right, ctx)
+            node.atomic = (isinstance(node.op, (ast.boolop, ast.Imply,
+                                                ast.Iff))
+                           and node.left.atomic
+                           and node.right.atomic)
+        elif isinstance(node, ast.CtlUnary) :
+            node.child = self._build(node.child, ctx)
+            node.atomic = (isinstance(node.op, ast.Not)
+                           and node.child.atomic)
+        else :
+            assert False, "how did we get there?"
+        return node
+    def _build_place (self, param, ctx) :
+        if isinstance(param, ast.Parameter) :
+            if param.name not in ctx :
+                raise SpecError(param, "place %r should be instantiated"
+                                % param.name)
+            return ctx[param.name]
+        else :
+            return param
+    def _build_InPlace (self, node, ctx) :
+        node.data = [bind(child, ctx) for child in node.data]
+        node.place = self._build_place(node.place, ctx)
+        return node
+    def _build_NotInPlace (self, node, ctx) :
+        return self._build_InPlace(node, ctx)
+    def _build_EmptyPlace (self, node, ctx) :
+        node.place = self._build_place(node.place, ctx)
+        return node
+    def _build_MarkedPlace (self, node, ctx) :
+        return self._build_EmptyPlace(node, ctx)
+    # skip Deadlock and Boolean: nothing to do
+    def _build_Quantifier (self, node, ctx) :
+        node.place = self._build_place(node.place, ctx)
+        ctx = ctx.copy()
+        for name in node.vars :
+            ctx[name] = ast.Token(name, node.place.place)
+        node.child = self._build(node.child, ctx)
+        return node
+    def _build_Instance (self, node, ctx) :
+        if node.name not in self.decl :
+            raise SpecError(node, "undeclared object %r" % node.name)
+        ctx = ctx.copy()
+        decl = self.decl[node.name]
+        for arg in decl.args :
+            ctx[arg.name] = arg
+        if isinstance(decl, ast.Property) :
+            return self._build_Instance_Property(node, decl, ctx)
+        else :
+            return self._build_Instance_Atom(node, decl, ctx)
+    def _build_Instance_Property (self, node, prop, ctx) :
+        bound = set(a.name for a in prop.args)
+        args = dict((a.arg, a.annotation) for a in node.args)
+        for param in prop.params :
+            if param.name in bound :
+                raise SpecError(node, "argument %r already bound"
+                                % param.name)
+            elif param.name in args :
+                arg = args.pop(param.name)
+                bound.add(param.name)
+            else :
+                raise SpecError(node, "missing argument %r" % param.name)
+            if param.type == "place" :
+                if not isinstance(arg, ast.Place) :
+                    raise SpecError(node, "expected place for %r"
+                                    % param.name)
+                arg.name = param.name
+            ctx[param.name] = arg
+        if args :
+            raise SpecError(node, "too many arguments (%s)"
+                            % ", ".join(repr(a) for a in args))
+        return self._build(astcopy(prop.body), ctx)
+    def _build_Instance_Atom (self, node, atom, ctx) :
+        bound = set(a.name for a in atom.args)
+        args = dict((a.arg, a.annotation) for a in node.args)
+        new = astcopy(atom)
+        for param in atom.params :
+            if param.name in bound :
+                raise SpecError(node, "argument %r already bound"
+                                % param.name)
+            elif param.name in args :
+                arg = args.pop(param.name)
+                bound.add(param.name)
+            else :
+                raise SpecError(node, "missing argument %r" % param.name)
+            if param.type == "place" :
+                if not isinstance(arg, ast.Place) :
+                    raise SpecError(node, "expected place for %r"
+                                    % param.name)
+                arg.name = param.name
+            else :
+                arg = ast.Argument(name=param.name,
+                                   value=arg,
+                                   type=param.type)
+            new.args.append(arg)
+        if args :
+            raise SpecError(node, "too many arguments (%s)"
+                            % ", ".join(repr(a) for a in args))
+        del new.params[:]
+        return new
+
+def build (spec, main=None) :
+    b = Builder(spec)
+    if main is None :
+        return b.build(spec.main)
+    else :
+        return b.build(main)

+#!/bin/sh
+exec python bin/abcd --dot ,railroad.png \
+                     --pnml ,railroad.pnml \
+                     doc/examples/abcd/railroad.abcd
\ No newline at end of file

+import doctest, sys, os, glob
+
+retcode = 0
+
+import snakes
+version = open("VERSION").read().strip()
+if snakes.version != version :
+    print("Mismatched versions:")
+    print("  snakes.version = %r" % snakes.version)
+    print("  VERSION = %r" % version)
+    sys.exit(1)
+
+def test (module) :
+    print("  Testing '%s'" % module.__name__)
+    f, t = doctest.testmod(module, #verbose=True,
+                           optionflags=doctest.NORMALIZE_WHITESPACE
+                           | doctest.REPORT_ONLY_FIRST_FAILURE
+                           | doctest.ELLIPSIS)
+    return f
+
+modules = ["snakes",
+           "snakes.hashables",
+           "snakes.lang",
+           "snakes.lang.python.parser",
+           "snakes.lang.abcd.parser",
+           "snakes.lang.ctlstar.parser",
+           "snakes.data",
+           "snakes.typing",
+           "snakes.nets",
+           "snakes.pnml",
+           "snakes.plugins",
+           "snakes.plugins.pos",
+           "snakes.plugins.status",
+           "snakes.plugins.ops",
+           "snakes.plugins.synchro",
+           "snakes.plugins.hello",
+           "snakes.plugins.gv",
+           "snakes.plugins.clusters",
+           "snakes.plugins.labels",
+           "snakes.utils.abcd.build",
+           ]
+
+stop = False
+if len(sys.argv) > 1 :
+    if sys.argv[1] == "--stop" :
+        stop = True
+        del sys.argv[1]
+
+doscripts = True
+if len(sys.argv) > 1 :
+    modules = sys.argv[1:]
+    doscripts = False
+
+for modname in modules :
+    try :
+        __import__(modname)
+        retcode = max(retcode, test(sys.modules[modname]))
+        if retcode and stop :
+            break
+    except :
+        print("  Could not test %r:" % modname)
+        c, e, t = sys.exc_info()
+        print("    %s: %s" % (c.__name__, e))
+
+if doscripts :
+    for script in (glob.glob("test-scripts/test*.sh")
+                   + glob.glob("test-scripts/test*.py")) :
+        print("  Running '%s'" % script)
+        retcode = max(retcode, os.system(script))
+        if retcode and stop :
+            break
+
+sys.exit(retcode)

+(provide 'abcd-mode)
+
+(define-derived-mode abcd-mode python-mode "ABCD"
+  (font-lock-add-keywords
+   nil
+   `((,(concat "\\<\\(buffer\\|typedef\\|net\\|enum\\|task\\|const\\|symbol\\)\\>")
+      1 font-lock-keyword-face t))))

+"""Draws a dependency graph of non-terminals in a pgen grammar
+(pygraphviz required).
+
+Usage: python pgen2dot.py INFILE OUTFILE [ENGINE [OPTION=VAL]...]
+"""
+
+import sys, string, os.path
+import pygraphviz as gv
+import snakes.lang.pgen as pgen
+
+if len(sys.argv) < 3 :
+    print("Usage: python pgen2dot.py INFILE OUTFILE [ENGINE [OPTION=VAL]...]")
+    sys.exit(1)
+elif len(sys.argv) >= 4 :
+    engine = sys.argv[3]
+else :
+    engine = "dot"
+
+nodes = set()
+edges = set()
+
+def walk (st, lex, rule=None) :
+    tok, children = st
+    if tok == pgen.PgenParser.RULE :
+        rule = children[0][0]
+        nodes.add(rule)
+        for child in children[1:] :
+            walk(child, lex, rule)
+    elif isinstance(tok, str) and tok.strip() and tok[0] in string.ascii_lowercase :
+        nodes.add(tok)
+        if rule is not None :
+            edges.add((rule, tok))
+    else :
+        for child in children :
+            walk(child, lex, rule)
+
+st, lex = pgen.PgenParser.parse(sys.argv[1])
+walk(st, lex)
+
+g = gv.AGraph(directed=True)
+g.add_edges_from(edges)
+g.graph_attr["overlap"] = "false"
+g.graph_attr["splines"] = "true"
+for arg in sys.argv[4:] :
+    key, val = arg.split("=", 1)
+    g.graph_attr[key] = val
+g.draw(sys.argv[2], prog=engine)

+"""Lists unreachable non-terminals in a pgen grammar
+
+Usage: python pgen2min.py INFILE
+"""
+
+import sys, string, os.path
+import snakes.lang.pgen as pgen
+import collections
+
+if len(sys.argv) < 2 :
+    print("Usage: python pgen2dot.py INFILE")
+    sys.exit(1)
+
+root = None
+nodes = set()
+edges = collections.defaultdict(set)
+
+def walk (st, lex, rule=None) :
+    global root
+    tok, children = st
+    if tok == pgen.PgenParser.RULE :
+        rule = children[0][0]
+        if root is None :
+            root = rule
+        nodes.add(rule)
+        for child in children[1:] :
+            walk(child, lex, rule)
+    elif isinstance(tok, str) and tok.strip() and tok[0] in string.ascii_lowercase :
+        nodes.add(tok)
+        if rule is not None :
+            edges[rule].add(tok)
+    else :
+        for child in children :
+            walk(child, lex, rule)
+
+st, lex = pgen.PgenParser.parse(sys.argv[1])
+walk(st, lex)
+
+reached = set()
+next = set([root])
+while not next.issubset(reached) :
+    reached.update(next)
+    prev = next
+    next = set()
+    for n in prev :
+        next.update(edges[n])
+
+for node in sorted(nodes - reached) :
+    print(node)