path: root/doxygen/man/man3/cmd2_Cmd.3

.TH "cmd2::Cmd" 3 "Fri Sep 9 2011" "Cmd2" \" -*- nroff -*-
.ad l
.nh
.SH NAME
cmd2::Cmd \- 
.SH SYNOPSIS
.br
.PP
.PP
Inherited by \fBexample::CmdLineApp\fP, \fBpirate6::Pirate\fP, \fBpirate7::Pirate\fP, and \fBpirate8::Pirate\fP'\&.
.SS "Public Member Functions"

.in +1c
.ti -1c
.RI "def \fB__init__\fP"
.br
.ti -1c
.RI "def \fBcmdloop\fP"
.br
.ti -1c
.RI "def \fBcolorize\fP"
.br
.ti -1c
.RI "def \fBcomplete_statement\fP"
.br
.ti -1c
.RI "def \fBdo__relative_load\fP"
.br
.ti -1c
.RI "def \fBdo_cmdenvironment\fP"
.br
.ti -1c
.RI "def \fBdo_ed\fP"
.br
.ti -1c
.RI "def \fBdo_EOF\fP"
.br
.ti -1c
.RI "def \fBdo_help\fP"
.br
.ti -1c
.RI "def \fBdo_history\fP"
.br
.ti -1c
.RI "def \fBdo_list\fP"
.br
.ti -1c
.RI "def \fBdo_load\fP"
.br
.ti -1c
.RI "def \fBdo_pause\fP"
.br
.ti -1c
.RI "def \fBdo_py\fP"
.br
.ti -1c
.RI "def \fBdo_quit\fP"
.br
.ti -1c
.RI "def \fBdo_run\fP"
.br
.ti -1c
.RI "def \fBdo_save\fP"
.br
.ti -1c
.RI "def \fBdo_set\fP"
.br
.ti -1c
.RI "def \fBdo_shell\fP"
.br
.ti -1c
.RI "def \fBdo_shortcuts\fP"
.br
.ti -1c
.RI "def \fBdo_show\fP"
.br
.ti -1c
.RI "def \fBfileimport\fP"
.br
.ti -1c
.RI "def \fBfunc_named\fP"
.br
.ti -1c
.RI "def \fBlast_matching\fP"
.br
.ti -1c
.RI "def \fBonecmd\fP"
.br
.ti -1c
.RI "def \fBonecmd_plus_hooks\fP"
.br
.ti -1c
.RI "def \fBparsed\fP"
.br
.ti -1c
.RI "def \fBperror\fP"
.br
.ti -1c
.RI "def \fBpfeedback\fP"
.br
.ti -1c
.RI "def \fBpostparse\fP"
.br
.ti -1c
.RI "def \fBpostparsing_postcmd\fP"
.br
.ti -1c
.RI "def \fBpostparsing_precmd\fP"
.br
.ti -1c
.RI "def \fBpoutput\fP"
.br
.ti -1c
.RI "def \fBpreparse\fP"
.br
.ti -1c
.RI "def \fBpseudo_raw_input\fP"
.br
.ti -1c
.RI "def \fBread_file_or_url\fP"
.br
.ti -1c
.RI "def \fBredirect_output\fP"
.br
.ti -1c
.RI "def \fBrestore_output\fP"
.br
.ti -1c
.RI "def \fBrun_commands_at_invocation\fP"
.br
.ti -1c
.RI "def \fBrunTranscriptTests\fP"
.br
.ti -1c
.RI "def \fBselect\fP"
.br
.in -1c
.SS "Public Attributes"

.in +1c
.ti -1c
.RI "\fBblankLineTerminationParser\fP"
.br
.ti -1c
.RI "\fBblankLineTerminator\fP"
.br
.ti -1c
.RI "\fBcontinuation_prompt\fP"
.br
.ti -1c
.RI "\fBhistory\fP"
.br
.ti -1c
.RI "\fBinitial_stdout\fP"
.br
.ti -1c
.RI "\fBinputParser\fP"
.br
.ti -1c
.RI "\fBintro\fP"
.br
.ti -1c
.RI "\fBkept_sys\fP"
.br
.ti -1c
.RI "\fBkeywords\fP"
.br
.ti -1c
.RI "\fBlastcmd\fP"
.br
.ti -1c
.RI "\fBmultilineCommand\fP"
.br
.ti -1c
.RI "\fBmultilineParser\fP"
.br
.ti -1c
.RI "\fBold_completer\fP"
.br
.ti -1c
.RI "\fBparser\fP"
.br
.ti -1c
.RI "\fBprompt\fP"
.br
.ti -1c
.RI "\fBpystate\fP"
.br
.ti -1c
.RI "\fBredirect\fP"
.br
.ti -1c
.RI "\fBshortcuts\fP"
.br
.ti -1c
.RI "\fBsingleLineParser\fP"
.br
.ti -1c
.RI "\fBstdin\fP"
.br
.ti -1c
.RI "\fBstdout\fP"
.br
.ti -1c
.RI "\fBuse_rawinput\fP"
.br
.in -1c
.SS "Static Public Attributes"

.in +1c
.ti -1c
.RI "\fBabbrev\fP = True"
.br
.ti -1c
.RI "\fBblankLinesAllowed\fP = False"
.br
.ti -1c
.RI "\fBcase_insensitive\fP = True"
.br
.ti -1c
.RI "dictionary \fBcolorcodes\fP"
.br
.ti -1c
.RI "tuple \fBcolors\fP = (platform\&.system() != 'Windows')"
.br
.ti -1c
.RI "tuple \fBcommentGrammars\fP = pyparsing\&.Or([pyparsing\&.pythonStyleComment, pyparsing\&.cStyleComment])"
.br
.ti -1c
.RI "tuple \fBcommentInProgress\fP = pyparsing\&.Literal('/*')"
.br
.ti -1c
.RI "string \fBcontinuation_prompt\fP = '> '"
.br
.ti -1c
.RI "\fBcurrent_script_dir\fP = None"
.br
.ti -1c
.RI "\fBdebug\fP = False"
.br
.ti -1c
.RI "string \fBdefault_file_name\fP = 'command\&.txt'"
.br
.ti -1c
.RI "\fBdefault_to_shell\fP = False"
.br
.ti -1c
.RI "string \fBdefaultExtension\fP = 'txt'"
.br
.ti -1c
.RI "\fBdo__load\fP = do_load"
.br
.ti -1c
.RI "\fBdo_edit\fP = do_ed"
.br
.ti -1c
.RI "\fBdo_eof\fP = do_EOF"
.br
.ti -1c
.RI "\fBdo_exit\fP = do_quit"
.br
.ti -1c
.RI "\fBdo_hi\fP = do_history"
.br
.ti -1c
.RI "\fBdo_l\fP = do_list"
.br
.ti -1c
.RI "\fBdo_li\fP = do_list"
.br
.ti -1c
.RI "\fBdo_q\fP = do_quit"
.br
.ti -1c
.RI "\fBdo_r\fP = do_run"
.br
.ti -1c
.RI "\fBecho\fP = False"
.br
.ti -1c
.RI "tuple \fBeditor\fP = os\&.environ\&.get('EDITOR')"
.br
.ti -1c
.RI "string \fBeditor\fP = 'notepad'"
.br
.ti -1c
.RI "string \fBexcludeFromHistory\fP = '''run r list l \fBhistory\fP hi ed edit li eof'''"
.br
.ti -1c
.RI "\fBfeedback_to_output\fP = False"
.br
.ti -1c
.RI "string \fBhelp\fP = 'describe function of parameter'"
.br
.ti -1c
.RI "\fBkept_state\fP = None"
.br
.ti -1c
.RI "string \fBlegalChars\fP = u'!#$%\&.:?@_'"
.br
.ti -1c
.RI "\fBlocals_in_py\fP = True"
.br
.ti -1c
.RI "list \fBmultilineCommands\fP = []"
.br
.ti -1c
.RI "string \fBnoSpecialParse\fP = 'set ed edit exit'"
.br
.ti -1c
.RI "tuple \fBprefixParser\fP = pyparsing\&.Empty()"
.br
.ti -1c
.RI "\fBquiet\fP = False"
.br
.ti -1c
.RI "string \fBredirector\fP = '>'"
.br
.ti -1c
.RI "list \fBreserved_words\fP = []"
.br
.ti -1c
.RI "tuple \fBsaveparser\fP"
.br
.ti -1c
.RI "tuple \fBsettable\fP"
.br
.ti -1c
.RI "dictionary \fBshortcuts\fP = {'?': '\fBhelp\fP', '!': 'shell', '@': 'load', '@@': '_relative_load'}"
.br
.ti -1c
.RI "list \fBterminators\fP = [';']"
.br
.ti -1c
.RI "\fBtiming\fP = False"
.br
.ti -1c
.RI "tuple \fBurlre\fP = re\&.compile('(https?://[-\\\\w\\\\\&./]+)')"
.br
.in -1c
.SS "Private Member Functions"

.in +1c
.ti -1c
.RI "def \fB_cmdloop\fP"
.br
.ti -1c
.RI "def \fB_default\fP"
.br
.ti -1c
.RI "def \fB_init_parser\fP"
.br
.in -1c
.SS "Static Private Attributes"

.in +1c
.ti -1c
.RI "\fB_STOP_AND_EXIT\fP = True"
.br
.ti -1c
.RI "int \fB_STOP_SCRIPT_NO_EXIT\fP = 999"
.br
.in -1c
.SH "Detailed Description"
.PP 
Definition at line 361 of file cmd2\&.py'\&.
.SH "Constructor & Destructor Documentation"
.PP 
.SS "def cmd2::Cmd::__init__ (self, args, kwargs)"
.PP
Definition at line 469 of file cmd2\&.py'\&.
.PP
.nf
469 
470     def __init__(self, *args, **kwargs):        
471         cmd\&.Cmd\&.__init__(self, *args, **kwargs)
472         self\&.initial_stdout = sys\&.stdout
473         self\&.history = History()
474         self\&.pystate = {}
475         self\&.shortcuts = sorted(self\&.shortcuts\&.items(), reverse=True)
476         self\&.keywords = self\&.reserved_words + [fname[3:] for fname in dir(self) 
477                                                if fname\&.startswith('do_')]            
478         self\&._init_parser()
            
.fi
.SH "Member Function Documentation"
.PP 
.SS "def cmd2::Cmd::_cmdloop (self, intro = \fCNone\fP)\fC [private]\fP".PP
.nf
Repeatedly issue a prompt, accept input, parse an initial prefix
off the received input, and dispatch to action methods, passing them
the remainder of the line as argument.
.fi
.PP
 
.PP
Definition at line 895 of file cmd2\&.py'\&.
.PP
Referenced by cmdloop()\&.
.PP
.nf
895 
896     def _cmdloop(self, intro=None):
897         '''Repeatedly issue a prompt, accept input, parse an initial prefix
898         off the received input, and dispatch to action methods, passing them
899         the remainder of the line as argument\&.
900         '''
901 
902         # An almost perfect copy from Cmd; however, the pseudo_raw_input portion
903         # has been split out so that it can be called separately
904         
905         self\&.preloop()
906         if self\&.use_rawinput and self\&.completekey:
907             try:
908                 import readline
909                 self\&.old_completer = readline\&.get_completer()
910                 readline\&.set_completer(self\&.complete)
911                 readline\&.parse_and_bind(self\&.completekey+': complete')
912             except ImportError:
913                 pass
914         try:
915             if intro is not None:
916                 self\&.intro = intro
917             if self\&.intro:
918                 self\&.stdout\&.write(str(self\&.intro)+'\n')
919             stop = None
920             while not stop:
921                 if self\&.cmdqueue:
922                     line = self\&.cmdqueue\&.pop(0)
923                 else:
924                     line = self\&.pseudo_raw_input(self\&.prompt)
925                 if (self\&.echo) and (isinstance(self\&.stdin, file)):
926                     self\&.stdout\&.write(line + '\n')
927                 stop = self\&.onecmd_plus_hooks(line)
928             self\&.postloop()
929         finally:
930             if self\&.use_rawinput and self\&.completekey:
931                 try:
932                     import readline
933                     readline\&.set_completer(self\&.old_completer)
934                 except ImportError:
935                     pass    
936             return stop

.fi
.SS "def cmd2::Cmd::_default (self, statement)\fC [private]\fP"
.PP
Definition at line 868 of file cmd2\&.py'\&.
.PP
References pirate6::Pirate::default(), pirate8::Pirate::default(), pirate7::Pirate::default(), default_to_shell, and postparsing_postcmd()\&.
.PP
.nf
868 
869     def _default(self, statement):
870         arg = statement\&.full_parsed_statement()
871         if self\&.default_to_shell:
872             result = os\&.system(arg)
873             if not result:
874                 return self\&.postparsing_postcmd(None)
875         return self\&.postparsing_postcmd(self\&.default(arg))

.fi
.SS "def cmd2::Cmd::_init_parser (self)\fC [private]\fP"
.PP
Definition at line 493 of file cmd2\&.py'\&.
.PP
.nf
493 
494     def _init_parser(self):
495         r'''
496         >>> c = Cmd()
497         >>> c\&.multilineCommands = ['multiline']
498         >>> c\&.case_insensitive = True
499         >>> c\&._init_parser()
500         >>> print (c\&.parser\&.parseString('')\&.dump())
501         []
502         >>> print (c\&.parser\&.parseString('')\&.dump())
503         []        
504         >>> print (c\&.parser\&.parseString('/* empty command */')\&.dump())
505         []        
506         >>> print (c\&.parser\&.parseString('plainword')\&.dump())
507         ['plainword', '']
508         - command: plainword
509         - statement: ['plainword', '']
510           - command: plainword        
511         >>> print (c\&.parser\&.parseString('termbare;')\&.dump())
512         ['termbare', '', ';', '']
513         - command: termbare
514         - statement: ['termbare', '', ';']
515           - command: termbare
516           - terminator: ;
517         - terminator: ;        
518         >>> print (c\&.parser\&.parseString('termbare; suffx')\&.dump())
519         ['termbare', '', ';', 'suffx']
520         - command: termbare
521         - statement: ['termbare', '', ';']
522           - command: termbare
523           - terminator: ;
524         - suffix: suffx
525         - terminator: ;        
526         >>> print (c\&.parser\&.parseString('barecommand')\&.dump())
527         ['barecommand', '']
528         - command: barecommand
529         - statement: ['barecommand', '']
530           - command: barecommand
531         >>> print (c\&.parser\&.parseString('COMmand with args')\&.dump())
532         ['command', 'with args']
533         - args: with args
534         - command: command
535         - statement: ['command', 'with args']
536           - args: with args
537           - command: command
538         >>> print (c\&.parser\&.parseString('command with args and terminator; and suffix')\&.dump())
539         ['command', 'with args and terminator', ';', 'and suffix']
540         - args: with args and terminator
541         - command: command
542         - statement: ['command', 'with args and terminator', ';']
543           - args: with args and terminator
544           - command: command
545           - terminator: ;
546         - suffix: and suffix
547         - terminator: ;
548         >>> print (c\&.parser\&.parseString('simple | piped')\&.dump())
549         ['simple', '', '|', ' piped']
550         - command: simple
551         - pipeTo:  piped
552         - statement: ['simple', '']
553           - command: simple
554         >>> print (c\&.parser\&.parseString('double-pipe || is not a pipe')\&.dump())
555         ['double', '-pipe || is not a pipe']
556         - args: -pipe || is not a pipe
557         - command: double
558         - statement: ['double', '-pipe || is not a pipe']
559           - args: -pipe || is not a pipe
560           - command: double
561         >>> print (c\&.parser\&.parseString('command with args, terminator;sufx | piped')\&.dump())
562         ['command', 'with args, terminator', ';', 'sufx', '|', ' piped']
563         - args: with args, terminator
564         - command: command
565         - pipeTo:  piped
566         - statement: ['command', 'with args, terminator', ';']
567           - args: with args, terminator
568           - command: command
569           - terminator: ;
570         - suffix: sufx
571         - terminator: ;
572         >>> print (c\&.parser\&.parseString('output into > afile\&.txt')\&.dump())
573         ['output', 'into', '>', 'afile\&.txt']
574         - args: into
575         - command: output
576         - output: >
577         - outputTo: afile\&.txt
578         - statement: ['output', 'into']
579           - args: into
580           - command: output   
581         >>> print (c\&.parser\&.parseString('output into;sufx | pipethrume plz > afile\&.txt')\&.dump())
582         ['output', 'into', ';', 'sufx', '|', ' pipethrume plz', '>', 'afile\&.txt']
583         - args: into
584         - command: output
585         - output: >
586         - outputTo: afile\&.txt
587         - pipeTo:  pipethrume plz
588         - statement: ['output', 'into', ';']
589           - args: into
590           - command: output
591           - terminator: ;
592         - suffix: sufx
593         - terminator: ;
594         >>> print (c\&.parser\&.parseString('output to paste buffer >> ')\&.dump())
595         ['output', 'to paste buffer', '>>', '']
596         - args: to paste buffer
597         - command: output
598         - output: >>
599         - statement: ['output', 'to paste buffer']
600           - args: to paste buffer
601           - command: output
602         >>> print (c\&.parser\&.parseString('ignore the /* commented | > */ stuff;')\&.dump())
603         ['ignore', 'the /* commented | > */ stuff', ';', '']
604         - args: the /* commented | > */ stuff
605         - command: ignore
606         - statement: ['ignore', 'the /* commented | > */ stuff', ';']
607           - args: the /* commented | > */ stuff
608           - command: ignore
609           - terminator: ;
610         - terminator: ;
611         >>> print (c\&.parser\&.parseString('has > inside;')\&.dump())
612         ['has', '> inside', ';', '']
613         - args: > inside
614         - command: has
615         - statement: ['has', '> inside', ';']
616           - args: > inside
617           - command: has
618           - terminator: ;
619         - terminator: ;        
620         >>> print (c\&.parser\&.parseString('multiline has > inside an unfinished command')\&.dump())
621         ['multiline', ' has > inside an unfinished command']
622         - multilineCommand: multiline        
623         >>> print (c\&.parser\&.parseString('multiline has > inside;')\&.dump())
624         ['multiline', 'has > inside', ';', '']
625         - args: has > inside
626         - multilineCommand: multiline
627         - statement: ['multiline', 'has > inside', ';']
628           - args: has > inside
629           - multilineCommand: multiline
630           - terminator: ;
631         - terminator: ;        
632         >>> print (c\&.parser\&.parseString('multiline command /* with comment in progress;')\&.dump())
633         ['multiline', ' command /* with comment in progress;']
634         - multilineCommand: multiline
635         >>> print (c\&.parser\&.parseString('multiline command /* with comment complete */ is done;')\&.dump())
636         ['multiline', 'command /* with comment complete */ is done', ';', '']
637         - args: command /* with comment complete */ is done
638         - multilineCommand: multiline
639         - statement: ['multiline', 'command /* with comment complete */ is done', ';']
640           - args: command /* with comment complete */ is done
641           - multilineCommand: multiline
642           - terminator: ;
643         - terminator: ;
644         >>> print (c\&.parser\&.parseString('multiline command ends\n\n')\&.dump())
645         ['multiline', 'command ends', '\n', '\n']
646         - args: command ends
647         - multilineCommand: multiline
648         - statement: ['multiline', 'command ends', '\n', '\n']
649           - args: command ends
650           - multilineCommand: multiline
651           - terminator: ['\n', '\n']
652         - terminator: ['\n', '\n']
653         >>> print (c\&.parser\&.parseString('multiline command 'with term; ends' now\n\n')\&.dump())
654         ['multiline', 'command 'with term; ends' now', '\n', '\n']
655         - args: command 'with term; ends' now
656         - multilineCommand: multiline
657         - statement: ['multiline', 'command 'with term; ends' now', '\n', '\n']
658           - args: command 'with term; ends' now
659           - multilineCommand: multiline
660           - terminator: ['\n', '\n']
661         - terminator: ['\n', '\n']
662         >>> print (c\&.parser\&.parseString('what if 'quoted strings /* seem to ' start comments?')\&.dump())
663         ['what', 'if 'quoted strings /* seem to ' start comments?']
664         - args: if 'quoted strings /* seem to ' start comments?
665         - command: what
666         - statement: ['what', 'if 'quoted strings /* seem to ' start comments?']
667           - args: if 'quoted strings /* seem to ' start comments?
668           - command: what
669         '''
670         #outputParser = (pyparsing\&.Literal('>>') | (pyparsing\&.WordStart() + '>') | pyparsing\&.Regex('[^=]>'))('output')
671         outputParser = (pyparsing\&.Literal(self\&.redirector *2) | \
672                        (pyparsing\&.WordStart() + self\&.redirector) | \
673                         pyparsing\&.Regex('[^=]' + self\&.redirector))('output')
674         
675         terminatorParser = pyparsing\&.Or([(hasattr(t, 'parseString') and t) or pyparsing\&.Literal(t) for t in self\&.terminators])('terminator')
676         stringEnd = pyparsing\&.stringEnd ^ '\nEOF'
677         self\&.multilineCommand = pyparsing\&.Or([pyparsing\&.Keyword(c, caseless=self\&.case_insensitive) for c in self\&.multilineCommands])('multilineCommand')
678         oneLineCommand = (~self\&.multilineCommand + pyparsing\&.Word(self\&.legalChars))('command')
679         pipe = pyparsing\&.Keyword('|', identChars='|')
680         self\&.commentGrammars\&.ignore(pyparsing\&.quotedString)\&.setParseAction(lambda x: '')
681         doNotParse = self\&.commentGrammars | self\&.commentInProgress | pyparsing\&.quotedString
682         afterElements = \
683             pyparsing\&.Optional(pipe + pyparsing\&.SkipTo(outputParser ^ stringEnd, ignore=doNotParse)('pipeTo')) + \
684             pyparsing\&.Optional(outputParser + pyparsing\&.SkipTo(stringEnd, ignore=doNotParse)\&.setParseAction(lambda x: x[0]\&.strip())('outputTo'))
685         if self\&.case_insensitive:
686             self\&.multilineCommand\&.setParseAction(lambda x: x[0]\&.lower())
687             oneLineCommand\&.setParseAction(lambda x: x[0]\&.lower())
688         if self\&.blankLinesAllowed:
689             self\&.blankLineTerminationParser = pyparsing\&.NoMatch
690         else:
691             self\&.blankLineTerminator = (pyparsing\&.lineEnd + pyparsing\&.lineEnd)('terminator')
692             self\&.blankLineTerminator\&.setResultsName('terminator')
693             self\&.blankLineTerminationParser = ((self\&.multilineCommand ^ oneLineCommand) + pyparsing\&.SkipTo(self\&.blankLineTerminator, ignore=doNotParse)\&.setParseAction(lambda x: x[0]\&.strip())('args') + self\&.blankLineTerminator)('statement')
694         self\&.multilineParser = (((self\&.multilineCommand ^ oneLineCommand) + pyparsing\&.SkipTo(terminatorParser, ignore=doNotParse)\&.setParseAction(lambda x: x[0]\&.strip())('args') + terminatorParser)('statement') +
695                                 pyparsing\&.SkipTo(outputParser ^ pipe ^ stringEnd, ignore=doNotParse)\&.setParseAction(lambda x: x[0]\&.strip())('suffix') + afterElements)
696         self\&.multilineParser\&.ignore(self\&.commentInProgress)
697         self\&.singleLineParser = ((oneLineCommand + pyparsing\&.SkipTo(terminatorParser ^ stringEnd ^ pipe ^ outputParser, ignore=doNotParse)\&.setParseAction(lambda x:x[0]\&.strip())('args'))('statement') +
698                                  pyparsing\&.Optional(terminatorParser) + afterElements)
699         #self\&.multilineParser = self\&.multilineParser\&.setResultsName('multilineParser')
700         #self\&.singleLineParser = self\&.singleLineParser\&.setResultsName('singleLineParser')
701         self\&.blankLineTerminationParser = self\&.blankLineTerminationParser\&.setResultsName('statement')
702         self\&.parser = self\&.prefixParser + (
703             stringEnd |
704             self\&.multilineParser |
705             self\&.singleLineParser |
706             self\&.blankLineTerminationParser | 
707             self\&.multilineCommand + pyparsing\&.SkipTo(stringEnd, ignore=doNotParse)
708             )
709         self\&.parser\&.ignore(self\&.commentGrammars)
710         
711         inputMark = pyparsing\&.Literal('<')
712         inputMark\&.setParseAction(lambda x: '')
713         fileName = pyparsing\&.Word(self\&.legalChars + '/\\')
714         inputFrom = fileName('inputFrom')
715         inputFrom\&.setParseAction(replace_with_file_contents)
716         # a not-entirely-satisfactory way of distinguishing < as in 'import from' from <
717         # as in 'lesser than'
718         self\&.inputParser = inputMark + pyparsing\&.Optional(inputFrom) + pyparsing\&.Optional('>') + \
719                            pyparsing\&.Optional(fileName) + (pyparsing\&.stringEnd | '|')
720         self\&.inputParser\&.ignore(self\&.commentInProgress)               
    
.fi
.SS "def cmd2::Cmd::cmdloop (self)"
.PP
Definition at line 1283 of file cmd2\&.py'\&.
.PP
References _cmdloop(), run_commands_at_invocation(), and runTranscriptTests()\&.
.PP
.nf
1283 
1284     def cmdloop(self):
1285         parser = optparse\&.OptionParser()
1286         parser\&.add_option('-t', '--test', dest='test',
1287                action='store_true', 
1288                help='Test against transcript(s) in FILE (wildcards OK)')
1289         (callopts, callargs) = parser\&.parse_args()
1290         if callopts\&.test:
1291             self\&.runTranscriptTests(callargs)
1292         else:
1293             if not self\&.run_commands_at_invocation(callargs):
1294                 self\&._cmdloop()   
            
.fi
.SS "def cmd2::Cmd::colorize (self, val, color)".PP
.nf
Given a string (``val``), returns that string wrapped in UNIX-style 
   special characters that turn on (and then off) text color and style.
   If the ``colors`` environment paramter is ``False``, or the application
   is running on Windows, will return ``val`` unchanged.
   ``color`` should be one of the supported strings (or styles):
   red/blue/green/cyan/magenta, bold, underline.fi
.PP
 
.PP
Definition at line 435 of file cmd2\&.py'\&.
.PP
Referenced by pirate7::Pirate::do_sing(), and pirate8::Pirate::do_sing()\&.
.PP
.nf
435 
436     def colorize(self, val, color):
437         '''Given a string (``val``), returns that string wrapped in UNIX-style 
438            special characters that turn on (and then off) text color and style\&.
439            If the ``colors`` environment paramter is ``False``, or the application
440            is running on Windows, will return ``val`` unchanged\&.
441            ``color`` should be one of the supported strings (or styles):
442            red/blue/green/cyan/magenta, bold, underline'''
443         if self\&.colors and (self\&.stdout == self\&.initial_stdout):
444             return self\&.colorcodes[color][True] + val + self\&.colorcodes[color][False]
445         return val

.fi
.SS "def cmd2::Cmd::complete_statement (self, line)".PP
.nf
Keep accepting lines of input until the command is complete..fi
.PP
 
.PP
Definition at line 794 of file cmd2\&.py'\&.
.PP
References commentGrammars, continuation_prompt, parsed(), and pseudo_raw_input()\&.
.PP
Referenced by onecmd_plus_hooks()\&.
.PP
.nf
794 
795     def complete_statement(self, line):
796         '''Keep accepting lines of input until the command is complete\&.'''
797         if (not line) or (
798             not pyparsing\&.Or(self\&.commentGrammars)\&.
799                 setParseAction(lambda x: '')\&.transformString(line)):
800             raise EmptyStatement
801         statement = self\&.parsed(line)
802         while statement\&.parsed\&.multilineCommand and (statement\&.parsed\&.terminator == ''):
803             statement = '%s\n%s' % (statement\&.parsed\&.raw, 
804                                     self\&.pseudo_raw_input(self\&.continuation_prompt))                
805             statement = self\&.parsed(statement)
806         if not statement\&.parsed\&.command:
807             raise EmptyStatement
808         return statement
    
.fi
.SS "def cmd2::Cmd::do__relative_load (self, arg = \fCNone\fP)".PP
.nf

Runs commands in script at file or URL; if this is called from within an
already-running script, the filename will be interpreted relative to the 
already-running script's directory..fi
.PP
 
.PP
Definition at line 1206 of file cmd2\&.py'\&.
.PP
References current_script_dir, and do__load\&.
.PP
.nf
1206 
1207     def do__relative_load(self, arg=None):
1208         '''
1209         Runs commands in script at file or URL; if this is called from within an
1210         already-running script, the filename will be interpreted relative to the 
1211         already-running script's directory\&.'''
1212         if arg:
1213             arg = arg\&.split(None, 1)
1214             targetname, args = arg[0], (arg[1:] or [''])[0]
1215             targetname = os\&.path\&.join(self\&.current_script_dir or '', targetname)
1216             self\&.do__load('%s %s' % (targetname, args))
    
.fi
.SS "def cmd2::Cmd::do_cmdenvironment (self, args)".PP
.nf
Summary report of interactive parameters..fi
.PP
 
.PP
Definition at line 446 of file cmd2\&.py'\&.
.PP
References case_insensitive, settable, and terminators\&.
.PP
.nf
446 
447     def do_cmdenvironment(self, args):
448         '''Summary report of interactive parameters\&.'''
449         self\&.stdout\&.write('''
450         Commands are %(casesensitive)scase-sensitive\&.
451         Commands may be terminated with: %(terminators)s
452         Settable parameters: %(settable)s\n''' % \
453         { 'casesensitive': (self\&.case_insensitive and 'not ') or '',
454           'terminators': str(self\&.terminators),
455           'settable': ' '\&.join(self\&.settable)
456         })
        
.fi
.SS "def cmd2::Cmd::do_ed (self, arg)".PP
.nf
ed: edit most recent command in text editor
ed [N]: edit numbered command from history
ed [filename]: edit specified file name

commands are run after editor is closed.
"set edit (program-name)" or set  EDITOR environment variable
to control which editing program is used..fi
.PP
 
.PP
Definition at line 1128 of file cmd2\&.py'\&.
.PP
References default_file_name, do__load, editor, history, and last_matching()\&.
.PP
.nf
1128 
1129     def do_ed(self, arg):
1130         '''ed: edit most recent command in text editor
1131         ed [N]: edit numbered command from history
1132         ed [filename]: edit specified file name
1133         
1134         commands are run after editor is closed\&.
1135         'set edit (program-name)' or set  EDITOR environment variable
1136         to control which editing program is used\&.'''
1137         if not self\&.editor:
1138             raise EnvironmentError('Please use 'set editor' to specify your text editing program of choice\&.')
1139         filename = self\&.default_file_name
1140         if arg:
1141             try:
1142                 buffer = self\&.last_matching(int(arg))
1143             except ValueError:
1144                 filename = arg
1145                 buffer = ''
1146         else:
1147             buffer = self\&.history[-1]
1148 
1149         if buffer:
1150             f = open(os\&.path\&.expanduser(filename), 'w')
1151             f\&.write(buffer or '')
1152             f\&.close()        
1153                 
1154         os\&.system('%s %s' % (self\&.editor, filename))
        self\&.do__load(filename)
.fi
.SS "def cmd2::Cmd::do_EOF (self, arg)"
.PP
Definition at line 937 of file cmd2\&.py'\&.
.PP
References _STOP_SCRIPT_NO_EXIT\&.
.PP
.nf
937 
938     def do_EOF(self, arg):
        return self\&._STOP_SCRIPT_NO_EXIT # End of script; should not exit app
.fi
.SS "def cmd2::Cmd::do_help (self, arg)"
.PP
Definition at line 457 of file cmd2\&.py'\&.
.PP
References func_named(), and stdout\&.
.PP
.nf
457 
458     def do_help(self, arg):
459         if arg:
460             funcname = self\&.func_named(arg)
461             if funcname:
462                 fn = getattr(self, funcname)
463                 try:
464                     fn\&.optionParser\&.print_help(file=self\&.stdout)
465                 except AttributeError:
466                     cmd\&.Cmd\&.do_help(self, funcname[3:])
467         else:
468             cmd\&.Cmd\&.do_help(self, arg)
        
.fi
.SS "def cmd2::Cmd::do_history (self, arg, opts)".PP
.nf
history [arg]: lists past commands issued

| no arg:         list all
| arg is integer: list one history item, by index
| arg is string:  string search
| arg is /enclosed in forward-slashes/: regular expression search
.fi
.PP
 
.PP
Definition at line 1083 of file cmd2\&.py'\&.
.PP
References history, and poutput()\&.
.PP
.nf
1083 
1084     def do_history(self, arg, opts):
1085         '''history [arg]: lists past commands issued
1086         
1087         | no arg:         list all
1088         | arg is integer: list one history item, by index
1089         | arg is string:  string search
1090         | arg is /enclosed in forward-slashes/: regular expression search
1091         '''
1092         if arg:
1093             history = self\&.history\&.get(arg)
1094         else:
1095             history = self\&.history
1096         for hi in history:
1097             if opts\&.script:
1098                 self\&.poutput(hi)
1099             else:
                self\&.stdout\&.write(hi\&.pr())
.fi
.SS "def cmd2::Cmd::do_list (self, arg)".PP
.nf
list [arg]: lists last command issued

no arg -> list most recent command
arg is integer -> list one history item, by index
a..b, a:b, a:, ..b -> list spans from a (or start) to b (or end)
arg is string -> list all commands matching string search
arg is /enclosed in forward-slashes/ -> regular expression search
.fi
.PP
 
.PP
Definition at line 1108 of file cmd2\&.py'\&.
.PP
References poutput()\&.
.PP
.nf
1108 
1109     def do_list(self, arg):
1110         '''list [arg]: lists last command issued
1111         
1112         no arg -> list most recent command
1113         arg is integer -> list one history item, by index
1114         a\&.\&.b, a:b, a:, \&.\&.b -> list spans from a (or start) to b (or end)
1115         arg is string -> list all commands matching string search
1116         arg is /enclosed in forward-slashes/ -> regular expression search
1117         '''
1118         try:
1119             history = self\&.history\&.span(arg or '-1')
1120         except IndexError:
1121             history = self\&.history\&.search(arg)
1122         for hi in history:
1123             self\&.poutput(hi\&.pr())

.fi
.SS "def cmd2::Cmd::do_load (self, arg = \fCNone\fP)".PP
.nf
Runs script of command(s) from a file or URL..fi
.PP
 
.PP
Definition at line 1218 of file cmd2\&.py'\&.
.PP
.nf
1218 
1219     def do_load(self, arg=None):           
1220         '''Runs script of command(s) from a file or URL\&.'''
1221         if arg is None:
1222             targetname = self\&.default_file_name
1223         else:
1224             arg = arg\&.split(None, 1)
1225             targetname, args = arg[0], (arg[1:] or [''])[0]\&.strip()
1226         try:
1227             target = self\&.read_file_or_url(targetname)
1228         except IOError, e:
1229             self\&.perror('Problem accessing script from %s: \n%s' % (targetname, e))
1230             return
1231         keepstate = Statekeeper(self, ('stdin','use_rawinput','prompt',
1232                                        'continuation_prompt','current_script_dir'))
1233         self\&.stdin = target    
1234         self\&.use_rawinput = False
1235         self\&.prompt = self\&.continuation_prompt = ''
1236         self\&.current_script_dir = os\&.path\&.split(targetname)[0]
1237         stop = self\&._cmdloop()
1238         self\&.stdin\&.close()
1239         keepstate\&.restore()
1240         self\&.lastcmd = ''
        return stop and (stop != self\&._STOP_SCRIPT_NO_EXIT)    
.fi
.SS "def cmd2::Cmd::do_pause (self, arg)"
.PP
Definition at line 1031 of file cmd2\&.py'\&.
.PP
.nf
1031 
1032     def do_pause(self, arg):
1033         'Displays the specified text then waits for the user to press RETURN\&.'
1034         raw_input(arg + '\n')
        
.fi
.SS "def cmd2::Cmd::do_py (self, arg)".PP
.nf

py <command>: Executes a Python command.
py: Enters interactive Python mode.
End with ``Ctrl-D`` (Unix) / ``Ctrl-Z`` (Windows), ``quit()``, '`exit()``.
Non-python commands can be issued with ``cmd("your command")``.
Run python code from external files with ``run("filename.py")``
.fi
.PP
 
.PP
Definition at line 1039 of file cmd2\&.py'\&.
.PP
References do_py(), locals_in_py, onecmd_plus_hooks(), cmd2::options(), perror(), pystate, stdin, and stdout\&.
.PP
Referenced by do_py()\&.
.PP
.nf
1039 
1040     def do_py(self, arg):  
1041         '''
1042         py <command>: Executes a Python command\&.
1043         py: Enters interactive Python mode\&.
1044         End with ``Ctrl-D`` (Unix) / ``Ctrl-Z`` (Windows), ``quit()``, '`exit()``\&.
1045         Non-python commands can be issued with ``cmd('your command')``\&.
1046         Run python code from external files with ``run('filename\&.py')``
1047         '''
1048         self\&.pystate['self'] = self
1049         arg = arg\&.parsed\&.raw[2:]\&.strip()
1050         localvars = (self\&.locals_in_py and self\&.pystate) or {}
1051         interp = InteractiveConsole(locals=localvars)
1052         interp\&.runcode('import sys, os;sys\&.path\&.insert(0, os\&.getcwd())')
1053         if arg\&.strip():
1054             interp\&.runcode(arg)
1055         else:
1056             def quit():
1057                 raise EmbeddedConsoleExit
1058             def onecmd_plus_hooks(arg):
1059                 return self\&.onecmd_plus_hooks(arg + '\n')
1060             def run(arg):
1061                 try:
1062                     file = open(arg)
1063                     interp\&.runcode(file\&.read())
1064                     file\&.close()
1065                 except IOError, e:
1066                     self\&.perror(e)
1067             self\&.pystate['quit'] = quit
1068             self\&.pystate['exit'] = quit
1069             self\&.pystate['cmd'] = onecmd_plus_hooks
1070             self\&.pystate['run'] = run
1071             try:
1072                 cprt = 'Type 'help', 'copyright', 'credits' or 'license' for more information\&.'        
1073                 keepstate = Statekeeper(sys, ('stdin','stdout'))
1074                 sys\&.stdout = self\&.stdout
1075                 sys\&.stdin = self\&.stdin
1076                 interp\&.interact(banner= 'Python %s on %s\n%s\n(%s)\n%s' %
1077                        (sys\&.version, sys\&.platform, cprt, self\&.__class__\&.__name__, self\&.do_py\&.__doc__))
1078             except EmbeddedConsoleExit:
1079                 pass
1080             keepstate\&.restore()
            
.fi
.SS "def cmd2::Cmd::do_quit (self, arg)"
.PP
Reimplemented in \fBpirate6::Pirate\fP, \fBpirate7::Pirate\fP, and \fBpirate8::Pirate\fP'\&.
.PP
Definition at line 941 of file cmd2\&.py'\&.
.PP
References _STOP_AND_EXIT\&.
.PP
.nf
941 
942     def do_quit(self, arg):
        return self\&._STOP_AND_EXIT
.fi
.SS "def cmd2::Cmd::do_run (self, arg)".PP
.nf
run [arg]: re-runs an earlier command

no arg -> run most recent command
arg is integer -> run one history item, by index
arg is string -> run most recent command by string search
arg is /enclosed in forward-slashes/ -> run most recent by regex
.fi
.PP
 
.PP
Definition at line 1243 of file cmd2\&.py'\&.
.PP
References last_matching(), onecmd_plus_hooks(), and pfeedback()\&.
.PP
.nf
1243 
1244     def do_run(self, arg):
1245         '''run [arg]: re-runs an earlier command
1246         
1247         no arg -> run most recent command
1248         arg is integer -> run one history item, by index
1249         arg is string -> run most recent command by string search
1250         arg is /enclosed in forward-slashes/ -> run most recent by regex
1251         '''        
1252         'run [N]: runs the SQL that was run N commands ago'
1253         runme = self\&.last_matching(arg)
1254         self\&.pfeedback(runme)
1255         if runme:
            stop = self\&.onecmd_plus_hooks(runme)
.fi
.SS "def cmd2::Cmd::do_save (self, arg)".PP
.nf
`save [N] [filename.ext]`

Saves command from history to file.

| N => Number of command (from history), or `*`; 
|      most recent command if omitted.fi
.PP
 
.PP
Definition at line 1160 of file cmd2\&.py'\&.
.PP
References default_file_name, do_save(), history, perror(), and pfeedback()\&.
.PP
Referenced by do_save()\&.
.PP
.nf
1160 
1161     def do_save(self, arg):
1162         '''`save [N] [filename\&.ext]`
1163 
1164         Saves command from history to file\&.
1165 
1166         | N => Number of command (from history), or `*`; 
1167         |      most recent command if omitted'''
1168 
1169         try:
1170             args = self\&.saveparser\&.parseString(arg)
1171         except pyparsing\&.ParseException:
1172             self\&.perror('Could not understand save target %s' % arg)
1173             raise SyntaxError(self\&.do_save\&.__doc__)
1174         fname = args\&.fname or self\&.default_file_name
1175         if args\&.idx == '*':
1176             saveme = '\n\n'\&.join(self\&.history[:])
1177         elif args\&.idx:
1178             saveme = self\&.history[int(args\&.idx)-1]
1179         else:
1180             saveme = self\&.history[-1]
1181         try:
1182             f = open(os\&.path\&.expanduser(fname), 'w')
1183             f\&.write(saveme)
1184             f\&.close()
1185             self\&.pfeedback('Saved to %s' % (fname))
1186         except Exception, e:
1187             self\&.perror('Error saving %s' % (fname))
1188             raise
            
.fi
.SS "def cmd2::Cmd::do_set (self, arg)".PP
.nf

Sets a cmd2 parameter.  Accepts abbreviated parameter names so long
as there is no ambiguity.  Call without arguments for a list of 
settable parameters with their values..fi
.PP
 
.PP
Definition at line 1000 of file cmd2\&.py'\&.
.PP
References cmd2::cast(), do_show(), and settable\&.
.PP
.nf
1000 
1001     def do_set(self, arg):
1002         '''
1003         Sets a cmd2 parameter\&.  Accepts abbreviated parameter names so long
1004         as there is no ambiguity\&.  Call without arguments for a list of 
1005         settable parameters with their values\&.'''
1006         try:
1007             statement, paramName, val = arg\&.parsed\&.raw\&.split(None, 2)
1008             val = val\&.strip()
1009             paramName = paramName\&.strip()\&.lower()
1010             if paramName not in self\&.settable:
1011                 hits = [p for p in self\&.settable if p\&.startswith(paramName)]
1012                 if len(hits) == 1:
1013                     paramName = hits[0]
1014                 else:
1015                     return self\&.do_show(paramName)
1016             currentVal = getattr(self, paramName)
1017             if (val[0] == val[-1]) and val[0] in (''', '''):
1018                 val = val[1:-1]
1019             else:                
1020                 val = cast(currentVal, val)
1021             setattr(self, paramName, val)
1022             self\&.stdout\&.write('%s - was: %s\nnow: %s\n' % (paramName, currentVal, val))
1023             if currentVal != val:
1024                 try:
1025                     onchange_hook = getattr(self, '_onchange_%s' % paramName)
1026                     onchange_hook(old=currentVal, new=val)
1027                 except AttributeError:
1028                     pass
1029         except (ValueError, AttributeError, NotSettableError), e:
1030             self\&.do_show(arg)
                
.fi
.SS "def cmd2::Cmd::do_shell (self, arg)"
.PP
Definition at line 1035 of file cmd2\&.py'\&.
.PP
.nf
1035 
1036     def do_shell(self, arg):
1037         'execute a command as if at the OS prompt\&.'
1038         os\&.system(arg)
                
.fi
.SS "def cmd2::Cmd::do_shortcuts (self, args)".PP
.nf
Lists single-key shortcuts available..fi
.PP
 
.PP
Definition at line 479 of file cmd2\&.py'\&.
.PP
References shortcuts\&.
.PP
.nf
479 
480     def do_shortcuts(self, args):
481         '''Lists single-key shortcuts available\&.'''
482         result = '\n'\&.join('%s: %s' % (sc[0], sc[1]) for sc in sorted(self\&.shortcuts))
483         self\&.stdout\&.write('Single-key shortcuts for other commands:\n%s\n' % (result))

.fi
.SS "def cmd2::Cmd::do_show (self, arg, opts)".PP
.nf
Shows value of a parameter..fi
.PP
 
.PP
Definition at line 982 of file cmd2\&.py'\&.
.PP
References cmd2::ljust(), poutput(), and settable\&.
.PP
Referenced by do_set()\&.
.PP
.nf
982 
983     def do_show(self, arg, opts):
984         '''Shows value of a parameter\&.'''
985         param = arg\&.strip()\&.lower()
986         result = {}
987         maxlen = 0
988         for p in self\&.settable:
989             if (not param) or p\&.startswith(param):
990                 result[p] = '%s: %s' % (p, str(getattr(self, p)))
991                 maxlen = max(maxlen, len(result[p]))
992         if result:
993             for p in sorted(result):
994                 if opts\&.long:
995                     self\&.poutput('%s # %s' % (result[p]\&.ljust(maxlen), self\&.settable[p]))
996                 else:
997                     self\&.poutput(result[p])
998         else:
999             raise NotImplementedError('Parameter '%s' not supported (type 'show' for list of parameters)\&.' % param)
    
.fi
.SS "def cmd2::Cmd::fileimport (self, statement, source)"
.PP
Definition at line 1258 of file cmd2\&.py'\&.
.PP
.nf
1258 
1259     def fileimport(self, statement, source):
1260         try:
1261             f = open(os\&.path\&.expanduser(source))
1262         except IOError:
1263             self\&.stdout\&.write('Couldn't read from file %s\n' % source)
1264             return ''
1265         data = f\&.read()
1266         f\&.close()
1267         return data

.fi
.SS "def cmd2::Cmd::func_named (self, arg)"
.PP
Definition at line 755 of file cmd2\&.py'\&.
.PP
References abbrev, and keywords\&.
.PP
Referenced by do_help()\&.
.PP
.nf
755 
756     def func_named(self, arg):
757         result = None
758         target = 'do_' + arg
759         if target in dir(self):
760             result = target
761         else:
762             if self\&.abbrev:   # accept shortened versions of commands
763                 funcs = [fname for fname in self\&.keywords if fname\&.startswith(arg)]
764                 if len(funcs) == 1:
765                     result = 'do_' + funcs[0]
        return result
.fi
.SS "def cmd2::Cmd::last_matching (self, arg)"
.PP
Definition at line 1100 of file cmd2\&.py'\&.
.PP
References history\&.
.PP
Referenced by do_ed(), and do_run()\&.
.PP
.nf
1100 
1101     def last_matching(self, arg):
1102         try:
1103             if arg:
1104                 return self\&.history\&.get(arg)[-1]
1105             else:
1106                 return self\&.history[-1]
1107         except IndexError:
            return None        
.fi
.SS "def cmd2::Cmd::onecmd (self, line)".PP
.nf
Interpret the argument as though it had been typed in response
to the prompt.

This may be overridden, but should not normally need to be;
see the precmd() and postcmd() methods for useful execution hooks.
The return value is a flag indicating whether interpretation of
commands by the interpreter should stop.

This (`cmd2`) version of `onecmd` already override's `cmd`'s `onecmd`.

.fi
.PP
 
.PP
Definition at line 844 of file cmd2\&.py'\&.
.PP
Referenced by onecmd_plus_hooks()\&.
.PP
.nf
844 
845     def onecmd(self, line):
846         '''Interpret the argument as though it had been typed in response
847         to the prompt\&.
848 
849         This may be overridden, but should not normally need to be;
850         see the precmd() and postcmd() methods for useful execution hooks\&.
851         The return value is a flag indicating whether interpretation of
852         commands by the interpreter should stop\&.
853         
854         This (`cmd2`) version of `onecmd` already override's `cmd`'s `onecmd`\&.
855 
856         '''
857         statement = self\&.parsed(line)
858         self\&.lastcmd = statement\&.parsed\&.raw   
859         funcname = self\&.func_named(statement\&.parsed\&.command)
860         if not funcname:
861             return self\&._default(statement)
862         try:
863             func = getattr(self, funcname)
864         except AttributeError:
865             return self\&._default(statement)
866         stop = func(statement) 
867         return stop                
        
.fi
.SS "def cmd2::Cmd::onecmd_plus_hooks (self, line)"
.PP
Definition at line 766 of file cmd2\&.py'\&.
.PP
References complete_statement(), excludeFromHistory, onecmd(), perror(), pfeedback(), pirate3::Pirate::postcmd(), pirate4::Pirate::postcmd(), pirate5::Pirate::postcmd(), pirate7::Pirate::postcmd(), pirate8::Pirate::postcmd(), pirate6::Pirate::postcmd(), postparsing_postcmd(), postparsing_precmd(), pirate3::Pirate::precmd(), pirate4::Pirate::precmd(), pirate5::Pirate::precmd(), pirate7::Pirate::precmd(), pirate8::Pirate::precmd(), pirate6::Pirate::precmd(), redirect_output(), restore_output(), and timing\&.
.PP
Referenced by do_py(), do_run(), and run_commands_at_invocation()\&.
.PP
.nf
766 
767     def onecmd_plus_hooks(self, line):
768         # The outermost level of try/finally nesting can be condensed once
769         # Python 2\&.4 support can be dropped\&.
770         stop = 0
771         try:
772             try:
773                 statement = self\&.complete_statement(line)
774                 (stop, statement) = self\&.postparsing_precmd(statement)
775                 if stop:
776                     return self\&.postparsing_postcmd(stop)
777                 if statement\&.parsed\&.command not in self\&.excludeFromHistory:
778                     self\&.history\&.append(statement\&.parsed\&.raw)      
779                 try:
780                     self\&.redirect_output(statement)
781                     timestart = datetime\&.datetime\&.now()
782                     statement = self\&.precmd(statement)
783                     stop = self\&.onecmd(statement)
784                     stop = self\&.postcmd(stop, statement)
785                     if self\&.timing:
786                         self\&.pfeedback('Elapsed: %s' % str(datetime\&.datetime\&.now() - timestart))
787                 finally:
788                     self\&.restore_output(statement)
789             except EmptyStatement:
790                 return 0
791             except Exception, e:
792                 self\&.perror(str(e), statement)            
793         finally:
            return self\&.postparsing_postcmd(stop)        
.fi
.SS "def cmd2::Cmd::parsed (self, raw, kwargs)"
.PP
Definition at line 726 of file cmd2\&.py'\&.
.PP
References parsed(), postparse(), preparse(), and shortcuts\&.
.PP
Referenced by complete_statement(), cmd2::ParsedString::full_parsed_statement(), parsed(), and cmd2::ParsedString::with_args_replaced()\&.
.PP
.nf
726 
727     def parsed(self, raw, **kwargs):
728         if isinstance(raw, ParsedString):
729             p = raw
730         else:
731             # preparse is an overridable hook; default makes no changes
732             s = self\&.preparse(raw, **kwargs)
733             s = self\&.inputParser\&.transformString(s\&.lstrip())
734             s = self\&.commentGrammars\&.transformString(s)
735             for (shortcut, expansion) in self\&.shortcuts:
736                 if s\&.lower()\&.startswith(shortcut):
737                     s = s\&.replace(shortcut, expansion + ' ', 1)
738                     break
739             result = self\&.parser\&.parseString(s)
740             result['raw'] = raw            
741             result['command'] = result\&.multilineCommand or result\&.command        
742             result = self\&.postparse(result)
743             p = ParsedString(result\&.args)
744             p\&.parsed = result
745             p\&.parser = self\&.parsed
746         for (key, val) in kwargs\&.items():
747             p\&.parsed[key] = val
748         return p
              
.fi
.SS "def cmd2::Cmd::perror (self, errmsg, statement = \fCNone\fP)"
.PP
Definition at line 404 of file cmd2\&.py'\&.
.PP
References debug\&.
.PP
Referenced by do_py(), do_save(), and onecmd_plus_hooks()\&.
.PP
.nf
404 
405     def perror(self, errmsg, statement=None):
406         if self\&.debug:
407             traceback\&.print_exc()
        print (str(errmsg))
.fi
.SS "def cmd2::Cmd::pfeedback (self, msg)".PP
.nf
For printing nonessential feedback.  Can be silenced with `quiet`.
   Inclusion in redirected output is controlled by `feedback_to_output`..fi
.PP
 
.PP
Definition at line 408 of file cmd2\&.py'\&.
.PP
References feedback_to_output, poutput(), and quiet\&.
.PP
Referenced by do_run(), do_save(), and onecmd_plus_hooks()\&.
.PP
.nf
408 
409     def pfeedback(self, msg):
410         '''For printing nonessential feedback\&.  Can be silenced with `quiet`\&.
411            Inclusion in redirected output is controlled by `feedback_to_output`\&.'''
412         if not self\&.quiet:
413             if self\&.feedback_to_output:
414                 self\&.poutput(msg)
415             else:
                print (msg)
.fi
.SS "def cmd2::Cmd::postparse (self, parseResult)"
.PP
Definition at line 723 of file cmd2\&.py'\&.
.PP
Referenced by parsed()\&.
.PP
.nf
723 
724     def postparse(self, parseResult):
725         return parseResult
   
.fi
.SS "def cmd2::Cmd::postparsing_postcmd (self, stop)"
.PP
Definition at line 752 of file cmd2\&.py'\&.
.PP
Referenced by _default(), and onecmd_plus_hooks()\&.
.PP
.nf
752 
753     def postparsing_postcmd(self, stop):
754         return stop
    
.fi
.SS "def cmd2::Cmd::postparsing_precmd (self, statement)"
.PP
Definition at line 749 of file cmd2\&.py'\&.
.PP
Referenced by onecmd_plus_hooks()\&.
.PP
.nf
749 
750     def postparsing_precmd(self, statement):
751         stop = 0
        return stop, statement
.fi
.SS "def cmd2::Cmd::poutput (self, msg)".PP
.nf
Convenient shortcut for self.stdout.write(); adds newline if necessary..fi
.PP
 
.PP
Definition at line 398 of file cmd2\&.py'\&.
.PP
Referenced by do_history(), do_list(), do_show(), pfeedback(), and select()\&.
.PP
.nf
398 
399     def poutput(self, msg):
400         '''Convenient shortcut for self\&.stdout\&.write(); adds newline if necessary\&.'''
401         if msg:
402             self\&.stdout\&.write(msg)
403             if msg[-1] != '\n':
                self\&.stdout\&.write('\n')
.fi
.SS "def cmd2::Cmd::preparse (self, raw, kwargs)"
.PP
Definition at line 721 of file cmd2\&.py'\&.
.PP
Referenced by parsed()\&.
.PP
.nf
721 
722     def preparse(self, raw, **kwargs):
        return raw
.fi
.SS "def cmd2::Cmd::pseudo_raw_input (self, prompt)".PP
.nf
copied from cmd's cmdloop; like raw_input, but accounts for changed stdin, stdout.fi
.PP
 
.PP
Definition at line 876 of file cmd2\&.py'\&.
.PP
References use_rawinput\&.
.PP
Referenced by complete_statement()\&.
.PP
.nf
876 
877     def pseudo_raw_input(self, prompt):
878         '''copied from cmd's cmdloop; like raw_input, but accounts for changed stdin, stdout'''
879         
880         if self\&.use_rawinput:
881             try:
882                 line = raw_input(prompt)
883             except EOFError:
884                 line = 'EOF'
885         else:
886             self\&.stdout\&.write(prompt)
887             self\&.stdout\&.flush()
888             line = self\&.stdin\&.readline()
889             if not len(line):
890                 line = 'EOF'
891             else:
892                 if line[-1] == '\n': # this was always true in Cmd
893                     line = line[:-1] 
894         return line
    
.fi
.SS "def cmd2::Cmd::read_file_or_url (self, fname)"
.PP
Definition at line 1189 of file cmd2\&.py'\&.
.PP
References defaultExtension\&.
.PP
.nf
1189 
1190     def read_file_or_url(self, fname):
1191         # TODO: not working on localhost
1192         if isinstance(fname, file):
1193             result = open(fname, 'r')
1194         else:
1195             match = self\&.urlre\&.match(fname)
1196             if match:
1197                 result = urllib\&.urlopen(match\&.group(1))
1198             else:
1199                 fname = os\&.path\&.expanduser(fname)
1200                 try:
1201                     result = open(os\&.path\&.expanduser(fname), 'r')
1202                 except IOError:                    
1203                     result = open('%s\&.%s' % (os\&.path\&.expanduser(fname), 
1204                                              self\&.defaultExtension), 'r')
1205         return result
        
.fi
.SS "def cmd2::Cmd::redirect_output (self, statement)"
.PP
Definition at line 809 of file cmd2\&.py'\&.
.PP
References cmd2::get_paste_buffer(), kept_state, kept_sys, redirect, redirector, and stdout\&.
.PP
Referenced by onecmd_plus_hooks()\&.
.PP
.nf
809 
810     def redirect_output(self, statement):
811         if statement\&.parsed\&.pipeTo:
812             self\&.kept_state = Statekeeper(self, ('stdout',))
813             self\&.kept_sys = Statekeeper(sys, ('stdout',))
814             self\&.redirect = subprocess\&.Popen(statement\&.parsed\&.pipeTo, shell=True, stdout=subprocess\&.PIPE, stdin=subprocess\&.PIPE)
815             sys\&.stdout = self\&.stdout = self\&.redirect\&.stdin
816         elif statement\&.parsed\&.output:
817             if (not statement\&.parsed\&.outputTo) and (not can_clip):
818                 raise EnvironmentError('Cannot redirect to paste buffer; install ``xclip`` and re-run to enable')
819             self\&.kept_state = Statekeeper(self, ('stdout',))            
820             self\&.kept_sys = Statekeeper(sys, ('stdout',))
821             if statement\&.parsed\&.outputTo:
822                 mode = 'w'
823                 if statement\&.parsed\&.output == 2 * self\&.redirector:
824                     mode = 'a'
825                 sys\&.stdout = self\&.stdout = open(os\&.path\&.expanduser(statement\&.parsed\&.outputTo), mode)                            
826             else:
827                 sys\&.stdout = self\&.stdout = tempfile\&.TemporaryFile(mode='w+')
828                 if statement\&.parsed\&.output == '>>':
829                     self\&.stdout\&.write(get_paste_buffer())
                    
.fi
.SS "def cmd2::Cmd::restore_output (self, statement)"
.PP
Definition at line 830 of file cmd2\&.py'\&.
.PP
References kept_state, and cmd2::write_to_paste_buffer\&.
.PP
Referenced by onecmd_plus_hooks()\&.
.PP
.nf
830 
831     def restore_output(self, statement):
832         if self\&.kept_state:
833             if statement\&.parsed\&.output:
834                 if not statement\&.parsed\&.outputTo:
835                     self\&.stdout\&.seek(0)
836                     write_to_paste_buffer(self\&.stdout\&.read())
837             elif statement\&.parsed\&.pipeTo:
838                 for result in self\&.redirect\&.communicate():              
839                     self\&.kept_state\&.stdout\&.write(result or '')                        
840             self\&.stdout\&.close()
841             self\&.kept_state\&.restore()  
842             self\&.kept_sys\&.restore()
843             self\&.kept_state = None                        
                        
.fi
.SS "def cmd2::Cmd::run_commands_at_invocation (self, callargs)"
.PP
Definition at line 1278 of file cmd2\&.py'\&.
.PP
References _STOP_AND_EXIT, and onecmd_plus_hooks()\&.
.PP
Referenced by cmdloop()\&.
.PP
.nf
1278 
1279     def run_commands_at_invocation(self, callargs):
1280         for initial_command in callargs:
1281             if self\&.onecmd_plus_hooks(initial_command + '\n'):
1282                 return self\&._STOP_AND_EXIT

.fi
.SS "def cmd2::Cmd::runTranscriptTests (self, callargs)"
.PP
Definition at line 1268 of file cmd2\&.py'\&.
.PP
Referenced by cmdloop()\&.
.PP
.nf
1268 
1269     def runTranscriptTests(self, callargs):
1270         class TestMyAppCase(Cmd2TestCase):
1271             CmdApp = self\&.__class__        
1272         self\&.__class__\&.testfiles = callargs
1273         sys\&.argv = [sys\&.argv[0]] # the --test argument upsets unittest\&.main()
1274         testcase = TestMyAppCase()
1275         runner = unittest\&.TextTestRunner()
1276         result = runner\&.run(testcase)
1277         result\&.printErrors()

.fi
.SS "def cmd2::Cmd::select (self, options, prompt = \fC'Your choice? '\fP)".PP
.nf
Presents a numbered menu to the user.  Modelled after
   the bash shell's SELECT.  Returns the item chosen.
   
   Argument ``options`` can be:

     | a single string -> will be split into one-word options
     | a list of strings -> will be offered as options
     | a list of tuples -> interpreted as (value, text), so 
                   that the return value can differ from
                   the text advertised to the user .fi
.PP
 
.PP
Definition at line 946 of file cmd2\&.py'\&.
.PP
References cmd2::options(), and poutput()\&.
.PP
.nf
946 
947     def select(self, options, prompt='Your choice? '):
948         '''Presents a numbered menu to the user\&.  Modelled after
949            the bash shell's SELECT\&.  Returns the item chosen\&.
950            
951            Argument ``options`` can be:
952 
953              | a single string -> will be split into one-word options
954              | a list of strings -> will be offered as options
955              | a list of tuples -> interpreted as (value, text), so 
956                                    that the return value can differ from
957                                    the text advertised to the user '''
958         if isinstance(options, basestring):
959             options = zip(options\&.split(), options\&.split())
960         fulloptions = []
961         for opt in options:
962             if isinstance(opt, basestring):
963                 fulloptions\&.append((opt, opt))
964             else:
965                 try:
966                     fulloptions\&.append((opt[0], opt[1]))
967                 except IndexError:
968                     fulloptions\&.append((opt[0], opt[0]))
969         for (idx, (value, text)) in enumerate(fulloptions):
970             self\&.poutput('  %2d\&. %s\n' % (idx+1, text))
971         while True:
972             response = raw_input(prompt)
973             try:
974                 response = int(response)
975                 result = fulloptions[response - 1][0]
976                 break
977             except ValueError:
978                 pass # loop and ask again
979         return result
    
.fi
.SH "Member Data Documentation"
.PP 
.SS "\fBcmd2::Cmd::_STOP_AND_EXIT\fP = True\fC [static, private]\fP"
.PP
Definition at line 416 of file cmd2\&.py'\&.
.PP
Referenced by do_quit(), and run_commands_at_invocation()\&.
.SS "int \fBcmd2::Cmd::_STOP_SCRIPT_NO_EXIT\fP = 999\fC [static, private]\fP"
.PP
Definition at line 417 of file cmd2\&.py'\&.
.PP
Referenced by do_EOF()\&.
.SS "\fBcmd2::Cmd::abbrev\fP = True\fC [static]\fP"
.PP
Definition at line 374 of file cmd2\&.py'\&.
.PP
Referenced by func_named()\&.
.SS "\fBcmd2::Cmd::blankLinesAllowed\fP = False\fC [static]\fP"
.PP
Definition at line 490 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::blankLineTerminationParser\fP"
.PP
Definition at line 667 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::blankLineTerminator\fP"
.PP
Definition at line 667 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::case_insensitive\fP = True\fC [static]\fP"
.PP
Definition at line 363 of file cmd2\&.py'\&.
.PP
Referenced by do_cmdenvironment()\&.
.SS "dictionary \fBcmd2::Cmd::colorcodes\fP\fC [static]\fP"\fBInitial value:\fP
.PP
.nf
{'bold':{True:'\x1b[1m',False:'\x1b[22m'},
                  'cyan':{True:'\x1b[36m',False:'\x1b[39m'},
                  'blue':{True:'\x1b[34m',False:'\x1b[39m'},
                  'red':{True:'\x1b[31m',False:'\x1b[39m'},
                  'magenta':{True:'\x1b[35m',False:'\x1b[39m'},
                  'green':{True:'\x1b[32m',False:'\x1b[39m'},
                  'underline':{True:'\x1b[4m',False:'\x1b[24m'}}
.fi
.PP
Definition at line 427 of file cmd2\&.py'\&.
.SS "tuple \fBcmd2::Cmd::colors\fP = (platform\&.system() != 'Windows')\fC [static]\fP"
.PP
Definition at line 434 of file cmd2\&.py'\&.
.SS "tuple \fBcmd2::Cmd::commentGrammars\fP = pyparsing\&.Or([pyparsing\&.pythonStyleComment, pyparsing\&.cStyleComment])\fC [static]\fP"
.PP
Definition at line 485 of file cmd2\&.py'\&.
.PP
Referenced by complete_statement()\&.
.SS "tuple \fBcmd2::Cmd::commentInProgress\fP = pyparsing\&.Literal('/*')\fC [static]\fP"
.PP
Definition at line 487 of file cmd2\&.py'\&.
.SS "string \fBcmd2::Cmd::continuation_prompt\fP = '> '\fC [static]\fP"
.PP
Definition at line 364 of file cmd2\&.py'\&.
.PP
Referenced by complete_statement()\&.
.SS "\fBcmd2::Cmd::continuation_prompt\fP"
.PP
Definition at line 1218 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::current_script_dir\fP = None\fC [static]\fP"
.PP
Definition at line 375 of file cmd2\&.py'\&.
.PP
Referenced by do__relative_load()\&.
.SS "\fBcmd2::Cmd::debug\fP = False\fC [static]\fP"
.PP
Definition at line 379 of file cmd2\&.py'\&.
.PP
Referenced by perror()\&.
.SS "string \fBcmd2::Cmd::default_file_name\fP = 'command\&.txt'\fC [static]\fP"
.PP
Definition at line 373 of file cmd2\&.py'\&.
.PP
Referenced by do_ed(), and do_save()\&.
.SS "\fBcmd2::Cmd::default_to_shell\fP = False\fC [static]\fP"
.PP
Reimplemented in \fBpirate7::Pirate\fP, and \fBpirate8::Pirate\fP'\&.
.PP
Definition at line 370 of file cmd2\&.py'\&.
.PP
Referenced by _default()\&.
.SS "string \fBcmd2::Cmd::defaultExtension\fP = 'txt'\fC [static]\fP"
.PP
Definition at line 372 of file cmd2\&.py'\&.
.PP
Referenced by read_file_or_url()\&.
.SS "\fBcmd2::Cmd::do__load\fP = do_load\fC [static]\fP"
.PP
Definition at line 1241 of file cmd2\&.py'\&.
.PP
Referenced by do__relative_load(), and do_ed()\&.
.SS "\fBcmd2::Cmd::do_edit\fP = do_ed\fC [static]\fP"
.PP
Definition at line 1155 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::do_eof\fP = do_EOF\fC [static]\fP"
.PP
Definition at line 939 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::do_exit\fP = do_quit\fC [static]\fP"
.PP
Definition at line 943 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::do_hi\fP = do_history\fC [static]\fP"
.PP
Definition at line 1124 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::do_l\fP = do_list\fC [static]\fP"
.PP
Definition at line 1125 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::do_li\fP = do_list\fC [static]\fP"
.PP
Definition at line 1126 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::do_q\fP = do_quit\fC [static]\fP"
.PP
Definition at line 944 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::do_r\fP = do_run\fC [static]\fP"
.PP
Definition at line 1256 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::echo\fP = False\fC [static]\fP"
.PP
Definition at line 362 of file cmd2\&.py'\&.
.SS "tuple \fBcmd2::Cmd::editor\fP = os\&.environ\&.get('EDITOR')\fC [static]\fP"
.PP
Definition at line 418 of file cmd2\&.py'\&.
.PP
Referenced by do_ed()\&.
.SS "string \fBcmd2::Cmd::editor\fP = 'notepad'\fC [static]\fP"
.PP
Definition at line 421 of file cmd2\&.py'\&.
.SS "string \fBcmd2::Cmd::excludeFromHistory\fP = '''run r list l \fBhistory\fP hi ed edit li eof'''\fC [static]\fP"
.PP
Definition at line 369 of file cmd2\&.py'\&.
.PP
Referenced by onecmd_plus_hooks()\&.
.SS "\fBcmd2::Cmd::feedback_to_output\fP = False\fC [static]\fP"
.PP
Definition at line 377 of file cmd2\&.py'\&.
.PP
Referenced by pfeedback()\&.
.SS "string \fBcmd2::Cmd::help\fP = 'describe function of parameter'\fC [static]\fP"
.PP
Reimplemented in \fBpirate8::Pirate\fP'\&.
.PP
Definition at line 981 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::history\fP"
.PP
Definition at line 469 of file cmd2\&.py'\&.
.PP
Referenced by do_ed(), do_history(), do_save(), and last_matching()\&.
.SS "\fBcmd2::Cmd::initial_stdout\fP"
.PP
Definition at line 469 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::inputParser\fP"
.PP
Definition at line 667 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::intro\fP"
.PP
Definition at line 898 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::kept_state\fP = None\fC [static]\fP"
.PP
Definition at line 381 of file cmd2\&.py'\&.
.PP
Referenced by redirect_output(), and restore_output()\&.
.SS "\fBcmd2::Cmd::kept_sys\fP"
.PP
Definition at line 809 of file cmd2\&.py'\&.
.PP
Referenced by redirect_output()\&.
.SS "\fBcmd2::Cmd::keywords\fP"
.PP
Definition at line 469 of file cmd2\&.py'\&.
.PP
Referenced by func_named()\&.
.SS "\fBcmd2::Cmd::lastcmd\fP"
.PP
Definition at line 854 of file cmd2\&.py'\&.
.SS "string \fBcmd2::Cmd::legalChars\fP = u'!#$%\&.:?@_'\fC [static]\fP"
.PP
Definition at line 367 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::locals_in_py\fP = True\fC [static]\fP"
.PP
Definition at line 380 of file cmd2\&.py'\&.
.PP
Referenced by do_py()\&.
.SS "\fBcmd2::Cmd::multilineCommand\fP"
.PP
Definition at line 667 of file cmd2\&.py'\&.
.SS "list \fBcmd2::Cmd::multilineCommands\fP = []\fC [static]\fP"
.PP
Reimplemented in \fBpirate7::Pirate\fP, \fBpirate8::Pirate\fP, and \fBexample::CmdLineApp\fP'\&.
.PP
Definition at line 491 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::multilineParser\fP"
.PP
Definition at line 667 of file cmd2\&.py'\&.
.SS "string \fBcmd2::Cmd::noSpecialParse\fP = 'set ed edit exit'\fC [static]\fP"
.PP
Definition at line 371 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::old_completer\fP"
.PP
Definition at line 898 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::parser\fP"
.PP
Definition at line 667 of file cmd2\&.py'\&.
.PP
Referenced by cmd2::ParsedString::full_parsed_statement(), and cmd2::ParsedString::with_args_replaced()\&.
.SS "tuple \fBcmd2::Cmd::prefixParser\fP = pyparsing\&.Empty()\fC [static]\fP"
.PP
Definition at line 484 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::prompt\fP"
.PP
Reimplemented in \fBpirate6::Pirate\fP, \fBpirate7::Pirate\fP, and \fBpirate8::Pirate\fP'\&.
.PP
Definition at line 1218 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::pystate\fP"
.PP
Definition at line 469 of file cmd2\&.py'\&.
.PP
Referenced by do_py()\&.
.SS "\fBcmd2::Cmd::quiet\fP = False\fC [static]\fP"
.PP
Definition at line 378 of file cmd2\&.py'\&.
.PP
Referenced by pfeedback()\&.
.SS "\fBcmd2::Cmd::redirect\fP"
.PP
Definition at line 809 of file cmd2\&.py'\&.
.PP
Referenced by redirect_output()\&.
.SS "string \fBcmd2::Cmd::redirector\fP = '>'\fC [static]\fP"
.PP
Reimplemented in \fBexample::CmdLineApp\fP'\&.
.PP
Definition at line 382 of file cmd2\&.py'\&.
.PP
Referenced by redirect_output()\&.
.SS "list \fBcmd2::Cmd::reserved_words\fP = []\fC [static]\fP"
.PP
Definition at line 376 of file cmd2\&.py'\&.
.SS "tuple \fBcmd2::Cmd::saveparser\fP\fC [static]\fP"\fBInitial value:\fP
.PP
.nf
(pyparsing\&.Optional(pyparsing\&.Word(pyparsing\&.nums)^'*')('idx') + 
                  pyparsing\&.Optional(pyparsing\&.Word(legalChars + '/\\'))('fname') +
                  pyparsing\&.stringEnd)
.fi
.PP
Definition at line 1157 of file cmd2\&.py'\&.
.SS "tuple \fBcmd2::Cmd::settable\fP\fC [static]\fP"\fBInitial value:\fP
.PP
.nf
stubbornDict('''
    prompt
    colors                Colorized output (*nix only)
    continuation_prompt   On 2nd+ line of input
    debug                 Show full error stack on error
    default_file_name     for ``save``, ``load``, etc\&.
    editor                Program used by ``edit``      
    case_insensitive      upper- and lower-case both OK
    feedback_to_output    include nonessentials in `|`, `>` results 
    quiet                 Don't print nonessential feedback
    echo                  Echo command issued into output
    timing                Report execution times
    abbrev                Accept abbreviated commands
    ''')
.fi
.PP
Reimplemented in \fBpirate7::Pirate\fP, and \fBpirate8::Pirate\fP'\&.
.PP
Definition at line 383 of file cmd2\&.py'\&.
.PP
Referenced by do_cmdenvironment(), do_set(), and do_show()\&.
.SS "dictionary \fBcmd2::Cmd::shortcuts\fP = {'?': '\fBhelp\fP', '!': 'shell', '@': 'load', '@@': '_relative_load'}\fC [static]\fP"
.PP
Definition at line 368 of file cmd2\&.py'\&.
.PP
Referenced by do_shortcuts(), and parsed()\&.
.SS "\fBcmd2::Cmd::shortcuts\fP"
.PP
Definition at line 469 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::singleLineParser\fP"
.PP
Definition at line 667 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::stdin\fP"
.PP
Definition at line 1218 of file cmd2\&.py'\&.
.PP
Referenced by do_py()\&.
.SS "\fBcmd2::Cmd::stdout\fP"
.PP
Definition at line 440 of file cmd2\&.py'\&.
.PP
Referenced by do_help(), do_py(), and redirect_output()\&.
.SS "list \fBcmd2::Cmd::terminators\fP = [';']\fC [static]\fP"
.PP
Reimplemented in \fBpirate7::Pirate\fP, and \fBpirate8::Pirate\fP'\&.
.PP
Definition at line 489 of file cmd2\&.py'\&.
.PP
Referenced by do_cmdenvironment()\&.
.SS "\fBcmd2::Cmd::timing\fP = False\fC [static]\fP"
.PP
Definition at line 365 of file cmd2\&.py'\&.
.PP
Referenced by onecmd_plus_hooks()\&.
.SS "tuple \fBcmd2::Cmd::urlre\fP = re\&.compile('(https?://[-\\\\w\\\\\&./]+)')\fC [static]\fP"
.PP
Definition at line 1217 of file cmd2\&.py'\&.
.SS "\fBcmd2::Cmd::use_rawinput\fP"
.PP
Definition at line 1218 of file cmd2\&.py'\&.
.PP
Referenced by pseudo_raw_input()\&.

.SH "Author"
.PP 
Generated automatically by Doxygen for Cmd2 from the source code'\&.