...
just like or | , but that
# introduces an unnecessary extra level of nesting. Just skip.
pass
else:
# For any tag we don't recognize (notably | ), push a new, empty
# list to the top of the dest stack. This new list is NOT
# referenced by anything in self.table; thus, when we pop it, any
# data we've collected inside that list will be discarded.
self.dest.append([])
def handle_endtag(self, tag):
# Because we avoid pushing self.dest for in handle_starttag(), we
# must refrain from popping it for here.
if tag != "p":
# For everything else, including unrecognized tags, pop the dest
# stack, reverting to outer collection.
self.dest.pop()
def handle_startendtag(self, tag, attrs):
# The table of interest contains | entries of the form:
# 0x00000000
STATUS_SUCCESS
# The
is very useful -- we definitely want two different data
# items for "0x00000000" and "STATUS_SUCCESS" -- but we don't need or
# want it to push, then discard, an empty list as it would if we let
# the default HTMLParser.handle_startendtag() call handle_starttag()
# followed by handle_endtag(). Just ignore
or any other
# singleton tag.
pass
def handle_data(self, data):
# Outside the of interest, self.dest is empty. Do not bother
# collecting data when self.dest is empty.
# HTMLParser calls handle_data() with every chunk of whitespace
# between tags. That would be lovely if our eventual goal was to
# reconstitute the original input stream with its existing formatting,
# but for us, whitespace only clutters the table. Ignore it.
if self.dest and not self.whitespace.match(data):
# Here we're within our and we have non-whitespace data.
# Append it to the list designated by the top of the dest stack.
self.dest[-1].append(data)
# cache for get_windows_table()
_windows_table = None
def get_windows_table():
global _windows_table
# If we already loaded _windows_table, no need to load it all over again.
if _windows_table:
return _windows_table
# windows-rcs.html was fetched on 2015-03-24 with the following command:
# curl -o windows-rcs.html \
# https://msdn.microsoft.com/en-us/library/cc704588.aspx
parser = TableParser()
with open(os.path.join(os.path.dirname(__file__), "windows-rcs.html")) as hf:
# We tried feeding the file data to TableParser in chunks, to avoid
# buffering the entire file as a single string. Unfortunately its
# handle_data() cannot tell the difference between distinct calls
# separated by HTML tags, and distinct calls necessitated by a chunk
# boundary. Sigh! Read in the whole file. At the time this was
# written, it was only 500KB anyway.
parser.feed(hf.read())
parser.close()
table = parser.table
# With our parser, any | ... |
|---|
row leaves a table entry
# consisting only of an empty list. Remove any such.
while table and not table[0]:
table.pop(0)
# We expect rows of the form:
# [['0x00000000', 'STATUS_SUCCESS'],
# ['The operation completed successfully.']]
# The latter list will have multiple entries if Microsoft embedded
# or ... in the text, in which case joining with '\n' is
# appropriate.
# Turn that into a dict whose key is the hex string, and whose value is
# the pair (symbol, desc).
_windows_table = dict((key, (symbol, '\n'.join(desc)))
for (key, symbol), desc in table)
return _windows_table
# Use this instead of logging.basicConfig() because the latter prefixes
# every line of output with INFO:__main__:...
log=logging.getLogger()
log.setLevel(logging.INFO)
log.addHandler(logging.StreamHandler())
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--debug", dest="loglevel", action="store_const",
const=logging.DEBUG, default=logging.INFO)
parser.add_argument("-D", "--define", dest="vars", default=[], action="append",
metavar="VAR=value",
help="Add VAR=value to the env variables defined")
parser.add_argument("-l", "--libpath", dest="libpath", default=[], action="append",
metavar="DIR",
help="Add DIR to the platform-dependent DLL search path")
parser.add_argument("command")
parser.add_argument('args', nargs=argparse.REMAINDER)
args = parser.parse_args()
log.setLevel(args.loglevel)
# What we have in opts.vars is a list of strings of the form "VAR=value"
# or possibly just "VAR". What we want is a dict. We can build that dict by
# constructing a list of ["VAR", "value"] pairs -- so split each
# "VAR=value" string on the '=' sign (but only once, in case we have
# "VAR=some=user=string"). To handle the case of just "VAR", append "" to
# the list returned by split(), then slice off anything after the pair we
# want.
rc = main(command=args.command, arguments=args.args, libpath=args.libpath,
vars=dict([(pair.split('=', 1) + [""])[:2] for pair in args.vars]))
if rc not in (None, 0):
log.error("Failure running: %s" % " ".join([args.command] + args.args))
log.error("Error %s: %s" % (rc, translate_rc(rc)))
sys.exit((rc < 0) and 255 or rc)
|