GNU Info

(python2.1-lib.info)shlex Objects

---

Prev: shlex Up: shlex

---

Enter node , (file) or (file)node

shlex Objects
-------------

A `shlex' instance has the following methods:

`get_token()'
     Return a token.  If tokens have been stacked using `push_token()',
     pop a token off the stack.  Otherwise, read one from the input
     stream.  If reading encounters an immediate end-of-file, an empty
     string is returned.

`push_token(str)'
     Push the argument onto the token stack.

`read_token()'
     Read a raw token.  Ignore the pushback stack, and do not interpret
     source requests.  (This is not ordinarily a useful entry point,
     and is documented here only for the sake of completeness.)

`sourcehook(filename)'
     When `shlex' detects a source request (see `source' below) this
     method is given the following token as argument, and expected to
     return a tuple consisting of a filename and an open file-like
     object.

     Normally, this method first strips any quotes off the argument.  If
     the result is an absolute pathname, or there was no previous source
     request in effect, or the previous source was a stream (e.g.
     `sys.stdin'), the result is left alone.  Otherwise, if the result
     is a relative pathname, the directory part of the name of the file
     immediately before it on the source inclusion stack is prepended
     (this behavior is like the way the C preprocessor handles
     `#include "file.h"').

     The result of the manipulations is treated as a filename, and
     returned as the first component of the tuple, with `open()' called
     on it to yield the second component. (Note: this is the reverse of
     the order of arguments in instance initialization!)

     This hook is exposed so that you can use it to implement directory
     search paths, addition of file extensions, and other namespace
     hacks.  There is no corresponding `close' hook, but a shlex
     instance will call the `close()' method of the sourced input
     stream when it returns `EOF'.

     For more explicit control of source stacking, use the
     `push_source()' and `pop_source()' methods.

`push_source(stream[, filename])'
     Push an input source stream onto the input stack.  If the filename
     argument is specified it will later be available for use in error
     messages.  This is the same method used internally by the
     `sourcehook' method.  _Added in Python version 2.1_

`pop_source()'
     Pop the last-pushed input source from the input stack.  This is
     the same method used internally when the lexer reaches `EOF'on a
     stacked input stream.  _Added in Python version 2.1_

`error_leader([file[, line]])'
     This method generates an error message leader in the format of a
     UNIX C compiler error label; the format is `'"%s", line %d: '',
     where the `%s' is replaced with the name of the current source
     file and the `%d' with the current input line number (the optional
     arguments can be used to override these).

     This convenience is provided to encourage `shlex' users to
     generate error messages in the standard, parseable format
     understood by Emacs and other UNIX tools.

Instances of `shlex' subclasses have some public instance variables
which either control lexical analysis or can be used for debugging:

`commenters'
     The string of characters that are recognized as comment beginners.
     All characters from the comment beginner to end of line are
     ignored.  Includes just `#' by default.

`wordchars'
     The string of characters that will accumulate into multi-character
     tokens.  By default, includes all ASCII alphanumerics and
     underscore.

`whitespace'
     Characters that will be considered whitespace and skipped.
     Whitespace bounds tokens.  By default, includes space, tab,
     linefeed and carriage-return.

`quotes'
     Characters that will be considered string quotes.  The token
     accumulates until the same quote is encountered again (thus,
     different quote types protect each other as in the shell.)  By
     default, includes ASCII single and double quotes.

`infile'
     The name of the current input file, as initially set at class
     instantiation time or stacked by later source requests.  It may be
     useful to examine this when constructing error messages.

`instream'
     The input stream from which this `shlex' instance is reading
     characters.

`source'
     This member is `None' by default.  If you assign a string to it,
     that string will be recognized as a lexical-level inclusion request
     similar to the `source' keyword in various shells.  That is, the
     immediately following token will opened as a filename and input
     taken from that stream until `EOF', at which point the `close()'
     method of that stream will be called and the input source will
     again become the original input stream. Source requests may be
     stacked any number of levels deep.

`debug'
     If this member is numeric and `1' or more, a `shlex' instance will
     print verbose progress output on its behavior.  If you need to use
     this, you can read the module source code to learn the details.

Note that any character not declared to be a word character,
whitespace, or a quote will be returned as a single-character token.

Quote and comment characters are not recognized within words.  Thus,
the bare words `ain't' and `ain#t' would be returned as single tokens
by the default parser.

`lineno'
     Source line number (count of newlines seen so far plus one).

`token'
     The token buffer.  It may be useful to examine this when catching
     exceptions.