--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Demo/pdist/cmdfw.py	Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,144 @@
+"Framework for command line interfaces like CVS.  See class CmdFrameWork."
+
+
+class CommandFrameWork:
+
+    """Framework class for command line interfaces like CVS.
+
+    The general command line structure is
+
+            command [flags] subcommand [subflags] [argument] ...
+
+    There's a class variable GlobalFlags which specifies the
+    global flags options.  Subcommands are defined by defining
+    methods named do_<subcommand>.  Flags for the subcommand are
+    defined by defining class or instance variables named
+    flags_<subcommand>.  If there's no command, method default()
+    is called.  The __doc__ strings for the do_ methods are used
+    for the usage message, printed after the general usage message
+    which is the class variable UsageMessage.  The class variable
+    PostUsageMessage is printed after all the do_ methods' __doc__
+    strings.  The method's return value can be a suggested exit
+    status.  [XXX Need to rewrite this to clarify it.]
+
+    Common usage is to derive a class, instantiate it, and then call its
+    run() method; by default this takes its arguments from sys.argv[1:].
+    """
+
+    UsageMessage = \
+      "usage: (name)s [flags] subcommand [subflags] [argument] ..."
+
+    PostUsageMessage = None
+
+    GlobalFlags = ''
+
+    def __init__(self):
+        """Constructor, present for completeness."""
+        pass
+
+    def run(self, args = None):
+        """Process flags, subcommand and options, then run it."""
+        import getopt, sys
+        if args is None: args = sys.argv[1:]
+        try:
+            opts, args = getopt.getopt(args, self.GlobalFlags)
+        except getopt.error, msg:
+            return self.usage(msg)
+        self.options(opts)
+        if not args:
+            self.ready()
+            return self.default()
+        else:
+            cmd = args[0]
+            mname = 'do_' + cmd
+            fname = 'flags_' + cmd
+            try:
+                method = getattr(self, mname)
+            except AttributeError:
+                return self.usage("command %r unknown" % (cmd,))
+            try:
+                flags = getattr(self, fname)
+            except AttributeError:
+                flags = ''
+            try:
+                opts, args = getopt.getopt(args[1:], flags)
+            except getopt.error, msg:
+                return self.usage(
+                        "subcommand %s: " % cmd + str(msg))
+            self.ready()
+            return method(opts, args)
+
+    def options(self, opts):
+        """Process the options retrieved by getopt.
+        Override this if you have any options."""
+        if opts:
+            print "-"*40
+            print "Options:"
+            for o, a in opts:
+                print 'option', o, 'value', repr(a)
+            print "-"*40
+
+    def ready(self):
+        """Called just before calling the subcommand."""
+        pass
+
+    def usage(self, msg = None):
+        """Print usage message.  Return suitable exit code (2)."""
+        if msg: print msg
+        print self.UsageMessage % {'name': self.__class__.__name__}
+        docstrings = {}
+        c = self.__class__
+        while 1:
+            for name in dir(c):
+                if name[:3] == 'do_':
+                    if docstrings.has_key(name):
+                        continue
+                    try:
+                        doc = getattr(c, name).__doc__
+                    except:
+                        doc = None
+                    if doc:
+                        docstrings[name] = doc
+            if not c.__bases__:
+                break
+            c = c.__bases__[0]
+        if docstrings:
+            print "where subcommand can be:"
+            names = docstrings.keys()
+            names.sort()
+            for name in names:
+                print docstrings[name]
+        if self.PostUsageMessage:
+            print self.PostUsageMessage
+        return 2
+
+    def default(self):
+        """Default method, called when no subcommand is given.
+        You should always override this."""
+        print "Nobody expects the Spanish Inquisition!"
+
+
+def test():
+    """Test script -- called when this module is run as a script."""
+    import sys
+    class Hello(CommandFrameWork):
+        def do_hello(self, opts, args):
+            "hello -- print 'hello world', needs no arguments"
+            print "Hello, world"
+    x = Hello()
+    tests = [
+            [],
+            ['hello'],
+            ['spam'],
+            ['-x'],
+            ['hello', '-x'],
+            None,
+            ]
+    for t in tests:
+        print '-'*10, t, '-'*10
+        sts = x.run(t)
+        print "Exit status:", repr(sts)
+
+
+if __name__ == '__main__':
+    test()