\2<\/h1>

"""

trailer = """\

""" def add_escapes(input): for line in input: yield cgi.escape(line) def main(): filename = "gprof.out" if sys.argv[1:]: filename = sys.argv[1] outputfilename = filename + ".html" input = add_escapes(file(filename)) output = file(outputfilename, "w") output.write(header % filename) for line in input: output.write(line) if line.startswith(" time"): break labels = {} for line in input: m = re.match(r"(.* )(\w+)\n", line) if not m: output.write(line) break stuff, fname = m.group(1, 2) labels[fname] = fname output.write('%s %s\n' % (stuff, fname, fname, fname)) for line in input: output.write(line) if line.startswith("index % time"): break for line in input: m = re.match(r"(.* )(\w+)(( <cycle.*>)? \[\d+\])\n", line) if not m: output.write(line) if line.startswith("Index by function name"): break continue prefix, fname, suffix = m.group(1, 2, 3) if fname not in labels: output.write(line) continue if line.startswith("["): output.write('%s%s%s\n' % (prefix, fname, fname, fname, suffix)) else: output.write('%s%s%s\n' % (prefix, fname, fname, suffix)) for line in input: for part in re.findall(r"(\w+(?:\.c)?|\W+)", line): if part in labels: part = '%s' % (part, part) output.write(part) output.write(trailer) output.close() webbrowser.open("file:" + os.path.abspath(outputfilename)) if __name__ == '__main__': main() PK!Ž((h2py.pyonu„[µü¤ó fc@sddlZddlZddlZddlZejdƒZejdƒZejdƒZejdƒZejdƒZ ee gZ ejdƒZejdƒZia iZyejd jd ƒZWnek rÍyejdjd ƒZWqÎek rÉyfejjdƒd kr9ejdjd ƒZn1ejjdƒrdejdjdƒZne‚WqÊek rÅdgZy*ejd ejjdejdƒƒWqÆek rÁqÆXqÊXqÎXnXd„Zd„Zid„ZedkreƒndS(iÿÿÿÿNs+^[ ]*#[ ]*define[ ]+([a-zA-Z0-9_]+)[ ]+sG^[ ]*#[ ]*define[ ]+([a-zA-Z0-9_]+)$([_a-zA-Z][_a-zA-Z0-9]*)$[ ]+s"^[ ]*#[ ]*include[ ]+<([^> ]+)>s/\*([^*]+|\*+[^/])*(\*+/)?s//.*s'(\\.[^\\]*|[^\\])'s0x([0-9a-fA-F]+)L?tincludet;tINCLUDEtbeosit BEINCLUDEStatheostC_INCLUDE_PATHt:s/usr/includet MULTIARCHcCsµtjtjddƒ\}}x9|D]1\}}|dkr&tjtj|ƒƒq&q&W|smdg}nxA|D]9}|dkr¬tjjdƒt tj tjƒqtt|dƒ}tj j|ƒ}|jdƒ}|dkrõ|| }n|jƒ}|d }t|d ƒ} | jd|ƒiaxXtD]P} |t| ƒ | kr8dt|t| ƒd<|t|t| ƒd|ddkr~|jƒ}|sgPn|d}||}qAW|jdƒ}||jƒ}e|ƒ}d} d||jƒf} y| |UWnejj d| ƒqX|j | ƒne j|ƒ}|r–|jddƒ\}}||jƒ}e|ƒ}d|||f} y| |UWnejj d| ƒq–X|j | ƒnej|ƒ}|r |j} | d\}}|||!}e j|ƒrø|j d e |ƒq™ej|ƒs™de|sF0 =PK!m³x~[[ mkreal.pynuÈ¯Ýí#! /usr/bin/python2.7 # mkreal # # turn a symlink to a directory into a real directory import sys import os from stat import * join = os.path.join error = 'mkreal error' BUFSIZE = 32*1024 def mkrealfile(name): st = os.stat(name) # Get the mode mode = S_IMODE(st[ST_MODE]) linkto = os.readlink(name) # Make sure again it's a symlink f_in = open(name, 'r') # This ensures it's a file os.unlink(name) f_out = open(name, 'w') while 1: buf = f_in.read(BUFSIZE) if not buf: break f_out.write(buf) del f_out # Flush data to disk before changing mode os.chmod(name, mode) def mkrealdir(name): st = os.stat(name) # Get the mode mode = S_IMODE(st[ST_MODE]) linkto = os.readlink(name) files = os.listdir(name) os.unlink(name) os.mkdir(name, mode) os.chmod(name, mode) linkto = join(os.pardir, linkto) # for filename in files: if filename not in (os.curdir, os.pardir): os.symlink(join(linkto, filename), join(name, filename)) def main(): sys.stdout = sys.stderr progname = os.path.basename(sys.argv[0]) if progname == '-c': progname = 'mkreal' args = sys.argv[1:] if not args: print 'usage:', progname, 'path ...' sys.exit(2) status = 0 for name in args: if not os.path.islink(name): print progname+':', name+':', 'not a symlink' status = 1 else: if os.path.isdir(name): mkrealdir(name) else: mkrealfile(name) sys.exit(status) if __name__ == '__main__': main() PK!Fw|š!!cleanfuture.pynuÈ¯Ýí#! /usr/bin/python2.7 """cleanfuture [-d][-r][-v] path ... -d Dry run. Analyze, but don't make any changes to, files. -r Recurse. Search for all .py files in subdirectories too. -v Verbose. Print informative msgs. Search Python (.py) files for future statements, and remove the features from such statements that are already mandatory in the version of Python you're using. Pass one or more file and/or directory paths. When a directory path, all .py files within the directory will be examined, and, if the -r option is given, likewise recursively for subdirectories. Overwrites files in place, renaming the originals with a .bak extension. If cleanfuture finds nothing to change, the file is left alone. If cleanfuture does change a file, the changed file is a fixed-point (i.e., running cleanfuture on the resulting .py file won't change it again, at least not until you try it again with a later Python release). Limitations: You can do these things, but this tool won't help you then: + A future statement cannot be mixed with any other statement on the same physical line (separated by semicolon). + A future statement cannot contain an "as" clause. Example: Assuming you're using Python 2.2, if a file containing from __future__ import nested_scopes, generators is analyzed by cleanfuture, the line is rewritten to from __future__ import generators because nested_scopes is no longer optional in 2.2 but generators is. """ import __future__ import tokenize import os import sys dryrun = 0 recurse = 0 verbose = 0 def errprint(*args): strings = map(str, args) msg = ' '.join(strings) if msg[-1:] != '\n': msg += '\n' sys.stderr.write(msg) def main(): import getopt global verbose, recurse, dryrun try: opts, args = getopt.getopt(sys.argv[1:], "drv") except getopt.error, msg: errprint(msg) return for o, a in opts: if o == '-d': dryrun += 1 elif o == '-r': recurse += 1 elif o == '-v': verbose += 1 if not args: errprint("Usage:", __doc__) return for arg in args: check(arg) def check(file): if os.path.isdir(file) and not os.path.islink(file): if verbose: print "listing directory", file names = os.listdir(file) for name in names: fullname = os.path.join(file, name) if ((recurse and os.path.isdir(fullname) and not os.path.islink(fullname)) or name.lower().endswith(".py")): check(fullname) return if verbose: print "checking", file, "...", try: f = open(file) except IOError, msg: errprint("%r: I/O Error: %s" % (file, str(msg))) return ff = FutureFinder(f, file) changed = ff.run() if changed: ff.gettherest() f.close() if changed: if verbose: print "changed." if dryrun: print "But this is a dry run, so leaving it alone." for s, e, line in changed: print "%r lines %d-%d" % (file, s+1, e+1) for i in range(s, e+1): print ff.lines[i], if line is None: print "-- deleted" else: print "-- change to:" print line, if not dryrun: bak = file + ".bak" if os.path.exists(bak): os.remove(bak) os.rename(file, bak) if verbose: print "renamed", file, "to", bak g = open(file, "w") ff.write(g) g.close() if verbose: print "wrote new", file else: if verbose: print "unchanged." class FutureFinder: def __init__(self, f, fname): self.f = f self.fname = fname self.ateof = 0 self.lines = [] # raw file lines # List of (start_index, end_index, new_line) triples. self.changed = [] # Line-getter for tokenize. def getline(self): if self.ateof: return "" line = self.f.readline() if line == "": self.ateof = 1 else: self.lines.append(line) return line def run(self): STRING = tokenize.STRING NL = tokenize.NL NEWLINE = tokenize.NEWLINE COMMENT = tokenize.COMMENT NAME = tokenize.NAME OP = tokenize.OP changed = self.changed get = tokenize.generate_tokens(self.getline).next type, token, (srow, scol), (erow, ecol), line = get() # Chew up initial comments and blank lines (if any). while type in (COMMENT, NL, NEWLINE): type, token, (srow, scol), (erow, ecol), line = get() # Chew up docstring (if any -- and it may be implicitly catenated!). while type is STRING: type, token, (srow, scol), (erow, ecol), line = get() # Analyze the future stmts. while 1: # Chew up comments and blank lines (if any). while type in (COMMENT, NL, NEWLINE): type, token, (srow, scol), (erow, ecol), line = get() if not (type is NAME and token == "from"): break startline = srow - 1 # tokenize is one-based type, token, (srow, scol), (erow, ecol), line = get() if not (type is NAME and token == "__future__"): break type, token, (srow, scol), (erow, ecol), line = get() if not (type is NAME and token == "import"): break type, token, (srow, scol), (erow, ecol), line = get() # Get the list of features. features = [] while type is NAME: features.append(token) type, token, (srow, scol), (erow, ecol), line = get() if not (type is OP and token == ','): break type, token, (srow, scol), (erow, ecol), line = get() # A trailing comment? comment = None if type is COMMENT: comment = token type, token, (srow, scol), (erow, ecol), line = get() if type is not NEWLINE: errprint("Skipping file %r; can't parse line %d:\n%s" % (self.fname, srow, line)) return [] endline = srow - 1 # Check for obsolete features. okfeatures = [] for f in features: object = getattr(__future__, f, None) if object is None: # A feature we don't know about yet -- leave it in. # They'll get a compile-time error when they compile # this program, but that's not our job to sort out. okfeatures.append(f) else: released = object.getMandatoryRelease() if released is None or released <= sys.version_info: # Withdrawn or obsolete. pass else: okfeatures.append(f) # Rewrite the line if at least one future-feature is obsolete. if len(okfeatures) < len(features): if len(okfeatures) == 0: line = None else: line = "from __future__ import " line += ', '.join(okfeatures) if comment is not None: line += ' ' + comment line += '\n' changed.append((startline, endline, line)) # Loop back for more future statements. return changed def gettherest(self): if self.ateof: self.therest = '' else: self.therest = self.f.read() def write(self, f): changed = self.changed assert changed # Prevent calling this again. self.changed = [] # Apply changes in reverse order. changed.reverse() for s, e, line in changed: if line is None: # pure deletion del self.lines[s:e+1] else: self.lines[s:e+1] = [line] f.writelines(self.lines) # Copy over the remainder of the file. if self.therest: f.write(self.therest) if __name__ == '__main__': main() PK!Ž((h2py.pycnu„[µü¤ó fc@sddlZddlZddlZddlZejdƒZejdƒZejdƒZejdƒZejdƒZ ee gZ ejdƒZejdƒZia iZyejd jd ƒZWnek rÍyejdjd ƒZWqÎek rÉyfejjdƒd kr9ejdjd ƒZn1ejjdƒrdejdjdƒZne‚WqÊek rÅdgZy*ejd ejjdejdƒƒWqÆek rÁqÆXqÊXqÎXnXd„Zd„Zid„ZedkreƒndS(iÿÿÿÿNs+^[ ]*#[ ]*define[ ]+([a-zA-Z0-9_]+)[ ]+sG^[ ]*#[ ]*define[ ]+([a-zA-Z0-9_]+)$([_a-zA-Z][_a-zA-Z0-9]*)$[ ]+s"^[ ]*#[ ]*include[ ]+<([^> ]+)>s/\*([^*]+|\*+[^/])*(\*+/)?s//.*s'(\\.[^\\]*|[^\\])'s0x([0-9a-fA-F]+)L?tincludet;tINCLUDEtbeosit BEINCLUDEStatheostC_INCLUDE_PATHt:s/usr/includet MULTIARCHcCsµtjtjddƒ\}}x9|D]1\}}|dkr&tjtj|ƒƒq&q&W|smdg}nxA|D]9}|dkr¬tjjdƒt tj tjƒqtt|dƒ}tj j|ƒ}|jdƒ}|dkrõ|| }n|jƒ}|d }t|d ƒ} | jd|ƒiaxXtD]P} |t| ƒ | kr8dt|t| ƒd<|t|t| ƒd|ddkr~|jƒ}|sgPn|d}||}qAW|jdƒ}||jƒ}e|ƒ}d} d||jƒf} y| |UWnejj d| ƒqX|j | ƒne j|ƒ}|r–|jddƒ\}}||jƒ}e|ƒ}d|||f} y| |UWnejj d| ƒq–X|j | ƒnej|ƒ}|r |j} | d\}}|||!}e j|ƒrø|j d e |ƒq™ej|ƒs™de|sF0 =PK!:Wå--findlinksto.pynuÈ¯Ýí#! /usr/bin/python2.7 # findlinksto # # find symbolic links to a path matching a regular expression import os import sys import re import getopt def main(): try: opts, args = getopt.getopt(sys.argv[1:], '') if len(args) < 2: raise getopt.GetoptError('not enough arguments', None) except getopt.GetoptError, msg: sys.stdout = sys.stderr print msg print 'usage: findlinksto pattern directory ...' sys.exit(2) pat, dirs = args[0], args[1:] prog = re.compile(pat) for dirname in dirs: os.path.walk(dirname, visit, prog) def visit(prog, dirname, names): if os.path.islink(dirname): names[:] = [] return if os.path.ismount(dirname): print 'descend into', dirname for name in names: name = os.path.join(dirname, name) try: linkto = os.readlink(name) if prog.search(linkto) is not None: print name, '->', linkto except os.error: pass if __name__ == '__main__': main() PK!Hò9«checkpip.pyonu„[µü¤ó fc@sYdZddlZddlZddlZddlZd„ZedkrUeƒndS(sa Checks that the version of the projects bundled in ensurepip are the latest versions available. iÿÿÿÿNcCs¡t}x~tjD]s\}}tjtjdj|ƒƒjƒj dƒƒ}|dd}||krt }dj|||ƒGHqqW|rtjdƒndS(Ns$https://pypi.python.org/pypi/{}/jsontutf8tinfotversions<The latest version of {} on PyPI is {}, but ensurepip has {}i( tFalset ensurepipt _PROJECTStjsontloadsturllib2turlopentformattreadtdecodetTruetsystexit(t outofdatetprojectRtdatatupstream_version((s./usr/lib64/python2.7/Tools/scripts/checkpip.pytmainst__main__(t__doc__RRRRRt__name__(((s./usr/lib64/python2.7/Tools/scripts/checkpip.pyts PK!ÿ³)¿¿untabify.pynuÈ¯Ýí#! /usr/bin/python2.7 "Replace tabs with spaces in argument files. Print names of changed files." import os import sys import getopt def main(): tabsize = 8 try: opts, args = getopt.getopt(sys.argv[1:], "t:") if not args: raise getopt.error, "At least one file argument required" except getopt.error, msg: print msg print "usage:", sys.argv[0], "[-t tabwidth] file ..." return for optname, optvalue in opts: if optname == '-t': tabsize = int(optvalue) for filename in args: process(filename, tabsize) def process(filename, tabsize, verbose=True): try: f = open(filename) text = f.read() f.close() except IOError, msg: print "%r: I/O error: %s" % (filename, msg) return newtext = text.expandtabs(tabsize) if newtext == text: return backup = filename + "~" try: os.unlink(backup) except os.error: pass try: os.rename(filename, backup) except os.error: pass with open(filename, "w") as f: f.write(newtext) if verbose: print filename if __name__ == '__main__': main() PK!óc3ž`` which.pycnu„[µü¤ó fc@szddlZejdd kr,ejd=nddlZddlZddlTd„Zd„ZedkrveƒndS( iÿÿÿÿNit.t(t*cCstjj|dƒdS(Ns (tsyststderrtwrite(tstr((s+/usr/lib64/python2.7/Tools/scripts/which.pytmsg sc CsÔtjdjtjƒ}d}d}tjdrctjdd dkrctjd}tjd=nx]tjdD]N}d}x"|D]}tjj||ƒ}ytj|ƒ}Wntj k rËq„nXt |tƒsít|dƒnpt |tƒ}|d@rO|s|GH|d }q]|d |kr8d } nd} t| |ƒnt|dƒ|r„tjd |d|ƒ}|ržtdt|ƒƒqžq„q„W|sqt|dƒd}qqqqWtj|ƒdS(NtPATHiRiis-ls: not a disk fileiIis same as: salso: s: not executablesls t s"ls -l" exit status: s: not found((tostenvirontsplittpathsepRtargvtpathtjointstatterrortS_ISREGtST_MODERtS_IMODEtsystemtreprtexit( tpathlisttststlonglisttprogtidenttdirtfilenametsttmodets((s+/usr/lib64/python2.7/Tools/scripts/which.pytmainsD$ t__main__(RR(RRR RRR#t__name__(((s+/usr/lib64/python2.7/Tools/scripts/which.pyts +PK!Qœ€Z¸ ¸ texcheck.pycnu„[µü¤ó fc@sœdZddlZddlZddlZddlmZmZmZddlZdZ d„Z gd„Zdd„Z edkr˜eje ƒƒndS( sá TeXcheck.py -- rough syntax checking on Python style LaTeX documents. Written by Raymond D. Hettinger Copyright (c) 2003 Python Software Foundation. All rights reserved. Designed to catch common markup errors including: * Unbalanced or mismatched parenthesis, brackets, and braces. * Unbalanced or mismatched \begin and \end blocks. * Misspelled or invalid LaTeX commands. * Use of forward slashes instead of backslashes for commands. * Table line size mismatches. Sample command line usage: python texcheck.py -k chapterheading -m lib/librandomtex *.tex Options: -m Munge parenthesis and brackets. [0,n) would normally mismatch. -k keyword: Keyword is a valid LaTeX command. Do not include the backslash. -d: Delimiter check only (useful for non-LaTeX files). -h: Help -s lineno: Start at lineno (useful for skipping complex sections). -v: Verbose. Trace the matching of //begin and //end blocks. iÿÿÿÿN(tiziptcounttislicesù \section \module \declaremodule \modulesynopsis \moduleauthor \sectionauthor \versionadded \code \class \method \begin \optional \var \ref \end \subsection \lineiii \hline \label \indexii \textrm \ldots \keyword \stindex \index \item \note \withsubitem \ttindex \footnote \citetitle \samp \opindex \noindent \exception \strong \dfn \ctype \obindex \character \indexiii \function \bifuncindex \refmodule \refbimodindex \subsubsection \nodename \member \chapter \emph \ASCII \UNIX \regexp \program \production \token \productioncont \term \grammartoken \lineii \seemodule \file \EOF \documentclass \usepackage \title \input \maketitle \ifhtml \fi \url \Cpp \tableofcontents \kbd \programopt \envvar \refstmodindex \cfunction \constant \NULL \moreargs \cfuncline \cdata \textasciicircum \n \ABC \setindexsubitem \versionchanged \deprecated \seetext \newcommand \POSIX \pep \warning \rfc \verbatiminput \methodline \textgreater \seetitle \lineiv \funclineni \ulink \manpage \funcline \dataline \unspecified \textbackslash \mimetype \mailheader \seepep \textunderscore \longprogramopt \infinity \plusminus \shortversion \version \refmodindex \seerfc \makeindex \makemodindex \renewcommand \indexname \appendix \protect \indexiv \mbox \textasciitilde \platform \seeurl \leftmargin \labelwidth \localmoduletable \LaTeX \copyright \memberline \backslash \pi \centerline \caption \vspace \textwidth \menuselection \textless \makevar \csimplemacro \menuselection \bfcode \sub \release \email \kwindex \refexmodindex \filenq \e \menuselection \exindex \linev \newsgroup \verbatim \setshortversion \author \authoraddress \paragraph \subparagraph \cmemberline \textbar \C \seelink cCsry|jƒ\}}Wn!tk r9d||fGHdSX||j||gƒkrYdSd||||fGHdS(sCVerify that closing delimiter matches most recent opening delimitersU Delimiter mismatch. On line %d, encountered closing '%s' without corresponding openNsJ Opener '%s' on line %d was not closed before encountering '%s' on line %d(tpopt IndexErrortget(tc_linenotc_symboltopenerstpairmapto_linenoto_symbol((s./usr/lib64/python2.7/Tools/scripts/texcheck.pyt matchclose?s c#CsPtjdƒ}tjdƒ}ttjƒƒ}x|D]}|jd|ƒq7Wd|kruidd6dd6}nid d6d d6}tdƒ}tjdƒ} tjdƒ} tjd ƒ}tjdƒ}g} g}tjdƒ}tjdƒ}tjdƒ}d}d}t|jddƒƒ}d}xÀtt |ƒt ||dd/ƒƒD]™\}}|jƒ}xû| j |ƒD]ê\}}}d|kr´|GdG|G|G|Gn|dkrâd|krâ| j||fƒnr||kr| j||fƒnP|dkr2d|kr2t||| |ƒn"||krTt||| |ƒnd|kr‚dG| GHq‚q‚Wxv| j |ƒD]e\}}|dkr¨|j|ƒn|dkr€y|jƒWqåtk rád|fGHqåXq€q€Wd|krûqZnxW|j |ƒD]F}d |ksd!|kr/qnd||krd"||fGHqqWx)|j |ƒD]}d#|||fGHqeW|jd$ƒ}|d%krÛ|jd|ƒ}|jd|ƒ}|j||d|!ƒnx5|j |ƒD]$}||krëd&||fGHqëqëW|j|ƒ}|r@|jdƒ}|}n|j|ƒ}|r‹|jdƒ|kr‹d'|jdƒ|||fGHn|j|ƒr£d}nd(|ks»d)|krÊd*|fGHnx&|j |ƒD]} d+| |fGHqÚWqZW|}!x#| D]\}}"d,|"|fGHqWx|D]}d-|fGHq*Wd.|!fGHdS(0s¼Check the LaTeX formatting in a sequence of lines. Opts is a mapping of options to option values if any: -m munge parenthesis and brackets -d delimiters only checking -v verbose trace of delimiter matching -s lineno: linenumber to start scan (default is 1). Morecmds is a sequence of LaTeX commands (without backslashes) that are to be considered valid in the scan. s\\[A-Za-z]+s \/([A-Za-z]+)s\s-ms[(t]s([t)t[t(s&\\(begin|end){([_a-zA-Z]+)}|([()\[\]])s({)|(})s(\b[A-za-z]+\b) \b\1\bs<\\(ABC|ASCII|C|Cpp|EOF|infinity|NULL|plusminus|POSIX|UNIX)\ss\\begin{(?:long)?table([iv]+)}s\\line([iv]+){s\\end{(?:long)?table([iv]+)}tis-st1is-vt|tbegins-dtends --> t{t}s Warning, unmatched } on line %s.t822s.htmls4Warning, forward slash used on line %d with cmd: /%ss2Warning, \%s should be written as \%s{} on line %ds\newcommandiÿÿÿÿs(Warning, unknown tex cmd on line %d: \%ss>Warning, \line%s on line %d does not match \table%s on line %dse.g.si.e.s2Style warning, avoid use of i.e or e.g. on line %ds&Doubled word warning. "%s" on line %ds(Unmatched open delimiter '%s' on line %dsUnmatched { on line %dsDone checking %d lines.N(tretcompiletsettcmdstrtsplittaddtintRRRRtNonetrstriptfindalltappendRRRtfindtsearchtgroup(#tsourcetoptstmorecmdsttexcmdtfalsetexcmdt validcmdstcmdR t openpunctt delimiterstbracestdoubledwordst spacingmarkupRt bracestackt tablestartt tablelinettableendt tablelevelttablestartlinet startlinetlinenotlinetbegendtnametpuncttopentclosetnctstartRtmtdwtlastlinetsymbol((s./usr/lib64/python2.7/Tools/scripts/texcheck.pytcheckitJs¤ 2 ! cCs‰|dkrtjd}ntj|dƒ\}}t|ƒ}d|ksX|gkratGHdSt|ƒdkr|dGHdSxOt|ƒD]A\}}d|ksd|kr‰tj|ƒ|||d+q‰q‰Wg|D]\}}|dkrÕ|^qÕ}g} x}|D]u} d d GHdG| GHyt | ƒ}Wnt k rOd|dGHd SXz| jt|||ƒƒWd|j ƒXqWt| ƒS(Nisk:mdhs:vs-his#Please specify a file to be checkedt*t?s-kt=itCheckingsCannot open file %s.i(R tsystargvtgetopttdictt__doc__tlent enumeratetglobR?tIOErrorR#RGR@tmax(targstoptitemstarglistR(titfilespectktvR)terrtfilenametf((s./usr/lib64/python2.7/Tools/scripts/texcheck.pytmainÄs6!+ t__main__(RPRRLRNt itertoolsRRRRSRRRGR R`t__name__texit(((s./usr/lib64/python2.7/Tools/scripts/texcheck.pyts z$PK!xúãmethfix.pyonu„[µü¤ó fc@s·ddlZddlZddlZddlTejjZeZejjZ d„Z ejdƒZd„Z d„Zd„ZdZejeƒZd „Zed kr³e ƒndS(iÿÿÿÿN(t*cCsÍd}tjds<tdtjddƒtjdƒnx}tjdD]n}tjj|ƒrzt|ƒr¸d}q¸qJtjj|ƒr£t|dƒd}qJt |ƒrJd}qJqJWtj|ƒdS(Niisusage: s file-or-directory ... is": will not process symbolic links ( tsystargvterrtexittostpathtisdirtrecursedowntislinktfix(tbadtarg((s-/usr/lib64/python2.7/Tools/scripts/methfix.pytmain&s s^[a-zA-Z0-9_]+\.py$cCstj|ƒdkS(Ni(tispythonprogtmatch(tname((s-/usr/lib64/python2.7/Tools/scripts/methfix.pytispython6scCs1td|fƒd}ytj|ƒ}Wn+tjk rW}td||fƒdSX|jƒg}xœ|D]”}|tjtjfkr“qontjj ||ƒ}tjj |ƒr½qotjj|ƒrß|j|ƒqot |ƒrot|ƒrd}qqoqoWx#|D]}t|ƒrd}qqW|S(Nsrecursedown(%r) is%s: cannot list directory: %r i(tdbgRtlistdirterrorRtsorttcurdirtpardirRtjoinR RtappendRR R(tdirnameRtnamestmsgtsubdirsRtfullname((s-/usr/lib64/python2.7/Tools/scripts/methfix.pyR9s0 c Csyt|dƒ}Wn(tk r=}td||fƒdSXtjj|ƒ\}}tjj|d|ƒ}d}d}x|jƒ}|s”Pn|d}|dkrÒd|krÒt|dƒ|j ƒdS|dkrc|dkrc|d d krc|djƒ} | rct jd | dƒdkrc|d| d}|d}t|ƒ|j ƒdSnx>|d dkr£|jƒ} | sŒPn|| }|d}qfWt|ƒ}||krj|dkr7yt|dƒ}Wn2tk r}|j ƒtd||fƒdSX|j dƒd}t|dƒq~ntt|ƒdƒtd|ƒtd|ƒn|dk r~|j|ƒq~q~W|j ƒ|sždSy+tj|ƒ}tj||td@ƒWn*tjk rõ}td||fƒnXytj||dƒWn*tjk r:}td||fƒnXytj||ƒWn+tjk r|}td||fƒdSXdS(Ntrs%s: cannot open: %r it@iss!: contains null bytes; not fixed is#!s [pP]ythons: s script; not fixed iþÿÿÿs\ tws%s: cannot create: %r s: s s< s> iÿs%s: warning: chmod failed (%r) t~s %s: warning: backup failed (%r) s%s: rename failed (%r) (topentIOErrorRRRtsplitRtNonetreadlinetclosetretsearchtfixlinetseektreptreprtwritetstattchmodtST_MODERtrename( tfilenametfRtheadttailttempnametgtlinenotlinetwordstnextlinetnewlinetstatbuf((s-/usr/lib64/python2.7/Tools/scripts/methfix.pyR Osˆ (" s8^[ ]+def +[a-zA-Z0-9_]+ *( *self *, *(( *(.*) *)) *) *:cCs[tj|ƒdkrWtjdd!\\}}\}}|| |||!||}n|S(Niii(tfixprogRtregs(R;tatbtctd((s-/usr/lib64/python2.7/Tools/scripts/methfix.pyR+¤s" t__main__(RR)RR0tstderrR/RRtstdoutR-R tcompileRRRR tfixpatR@R+t__name__(((s-/usr/lib64/python2.7/Tools/scripts/methfix.pyts R PK! âv¸vv byteyears.pyonu„[µü¤ó fc@sQddlZddlZddlZddlTd„ZedkrMeƒndS(iÿÿÿÿN(t*c CsÍy tj}Wntk r)tj}nXtjddkrPt}tjd=nRtjddkrvt}tjd=n,tjddkrœt}tjd=nt}d}tjƒ}d}d}x*tjdD]}t |t |ƒƒ}qÎWxÌtjdD]½}y||ƒ}Wn<tjk rO}tjj d ||fƒd}d }nX|rû||} |t} || }t| ƒt|ƒ|}|j|ƒGtt|ƒƒjd ƒGHqûqûWtj|ƒdS(Nis-ms-cs-agÐv@g8@g ¬@iscan't stat %r: %r igÁ@g8~A((tostlstattAttributeErrortstattsystargvtST_MTIMEtST_CTIMEttimetmaxtlenterrortstderrtwritetST_SIZEtfloattljusttreprtinttrjusttexit( tstatfunctitimet secs_per_yeartnowtstatustmaxlentfilenametsttmsgtanytimetsizetaget byteyears((s//usr/lib64/python2.7/Tools/scripts/byteyears.pytmainsF !t__main__(RRR RR#t__name__(((s//usr/lib64/python2.7/Tools/scripts/byteyears.pyt s$ 0PK!ÄÅN²66 fixdiv.pycnu„[µü¤ó fc@sÀdZddlZddlZddlZddlZdad„Zd„ZdZd„Z d„Z d „Zd „Zddd„ƒYZ d „Zd„Zedkr¼ejeƒƒndS(s(fixdiv - tool to fix division operators. To use this tool, first run `python -Qwarnall yourscript.py 2>warnings'. This runs the script `yourscript.py' while writing warning messages about all uses of the classic division operator to the file `warnings'. The warnings look like this: :: DeprecationWarning: classic division The warnings are written to stderr, so you must use `2>' for the I/O redirect. I know of no way to redirect stderr on Windows in a DOS box, so you will have to modify the script to set sys.stderr to some kind of log file if you want to do this on Windows. The warnings are not limited to the script; modules imported by the script may also trigger warnings. In fact a useful technique is to write a test script specifically intended to exercise all code in a particular module or set of modules. Then run `python fixdiv.py warnings'. This first reads the warnings, looking for classic division warnings, and sorts them by file name and line number. Then, for each file that received at least one warning, it parses the file and tries to match the warnings up to the division operators found in the source code. If it is successful, it writes its findings to stdout, preceded by a line of dashes and a line of the form: Index: If the only findings found are suggestions to change a / operator into a // operator, the output is acceptable input for the Unix 'patch' program. Here are the possible messages on stdout (N stands for a line number): - A plain-diff-style change ('NcN', a line marked by '<', a line containing '---', and a line marked by '>'): A / operator was found that should be changed to //. This is the recommendation when only int and/or long arguments were seen. - 'True division / operator at line N' and a line marked by '=': A / operator was found that can remain unchanged. This is the recommendation when only float and/or complex arguments were seen. - 'Ambiguous / operator (..., ...) at line N', line marked by '?': A / operator was found for which int or long as well as float or complex arguments were seen. This is highly unlikely; if it occurs, you may have to restructure the code to keep the classic semantics, or maybe you don't care about the classic semantics. - 'No conclusive evidence on line N', line marked by '*': A / operator was found for which no warnings were seen. This could be code that was never executed, or code that was only executed with user-defined objects as arguments. You will have to investigate further. Note that // can be overloaded separately from /, using __floordiv__. True division can also be separately overloaded, using __truediv__. Classic division should be the same as either of those. (XXX should I add a warning for division on user-defined objects, to disambiguate this case from code that was never executed?) - 'Phantom ... warnings for line N', line marked by '*': A warning was seen for a line not containing a / operator. The most likely cause is a warning about code executed by 'exec' or eval() (see note below), or an indirect invocation of the / operator, for example via the div() function in the operator module. It could also be caused by a change to the file between the time the test script was run to collect warnings and the time fixdiv was run. - 'More than one / operator in line N'; or 'More than one / operator per statement in lines N-N': The scanner found more than one / operator on a single line, or in a statement split across multiple lines. Because the warnings framework doesn't (and can't) show the offset within the line, and the code generator doesn't always give the correct line number for operations in a multi-line statement, we can't be sure whether all operators in the statement were executed. To be on the safe side, by default a warning is issued about this case. In practice, these cases are usually safe, and the -m option suppresses these warning. - 'Can't find the / operator in line N', line marked by '*': This really shouldn't happen. It means that the tokenize module reported a '/' operator but the line it returns didn't contain a '/' character at the indicated position. - 'Bad warning for line N: XYZ', line marked by '*': This really shouldn't happen. It means that a 'classic XYZ division' warning was read with XYZ being something other than 'int', 'long', 'float', or 'complex'. Notes: - The augmented assignment operator /= is handled the same way as the / operator. - This tool never looks at the // operator; no warnings are ever generated for use of this operator. - This tool never looks at the / operator when a future division statement is in effect; no warnings are generated in this case, and because the tool only looks at files for which at least one classic division warning was seen, it will never look at files containing a future division statement. - Warnings may be issued for code not read from a file, but executed using an exec statement or the eval() function. These may have in the filename position, in which case the fixdiv script will attempt and fail to open a file named '' and issue a warning about this failure; or these may be reported as 'Phantom' warnings (see above). You're on your own to deal with these. You could make all recommended changes and add a future division statement to all affected files, and then re-run the test script; it should not issue any warnings. If there are any, and you have a hard time tracking down where they are generated, you can use the -Werror option to force an error instead of a first warning, generating a traceback. - The tool should be run from the same directory as that from which the original script was run, otherwise it won't be able to open files given by relative pathnames. iÿÿÿÿNic CsJy#tjtjddƒ\}}Wn!tjk rF}t|ƒdSXx>|D]6\}}|dkrotGHdS|dkrNdaqNqNW|sœtdƒdS|drÃtjjdtjdƒnt |dƒ}|dkrãdS|jƒ}|sd G|dGHdS|jƒd}x-|D]%}t |||ƒ} |p?| }qW|S( Nithmis-hs-ms&at least one file argument is requireds!%s: extra file arguments ignored is&No classic division warnings read from(tgetopttsystargvterrortusaget__doc__tmulti_oktstderrtwritetreadwarningstNonetkeystsorttprocess( toptstargstmsgtotatwarningstfilestexittfilenametx((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pytmainŒs:# cCs[tjjdtjd|fƒtjjdtjdƒtjjdtjdƒdS(Ns%s: %s isUsage: %s [-m] warnings s"Try `%s -h' for more information. (RRR R(R((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyR¬s!sL^(.+?):(\d+): DeprecationWarning: classic (int|long|float|complex) division$cCs"tjtƒ}yt|ƒ}Wn(tk rI}tjjd|ƒdSXi}xÁ|jƒ}|siPn|j |ƒ}|s°|j dƒdkrStjjd|ƒqSqSn|jƒ\}}} |j|ƒ} | dkrñg||<} n| jt|ƒt| ƒfƒqSW|jƒ|S(Nscan't open: %s tdivisionisWarning: ignored input (tretcompiletPATTERNtopentIOErrorRRR treadlinetmatchtfindtgroupstgetRtappendtinttinterntclose(twarningsfiletprogtfRRtlinetmRtlinenotwhattlist((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyR ´s.# cCs@ddGH|st‚yt|ƒ}Wn(tk rO}tjjd|ƒdSXdG|GHt|ƒ}|jƒd}tj |j ƒ}x¨t|ƒ\}}} } |dkr³Pn||koÊdk nsÕt‚g}xE|t |ƒkr"||d|kr"|j||ƒ|d7}qÞW|r9t||ƒng}xE|t |ƒkr†||d|kr†|j||ƒ|d7}qBW| r˜|r˜qŠ| rµ|rµt| dƒqŠ|rÒ| rÒt||ƒqŠt | ƒdkr‡ts‡g} d}x?| D]7\\}}}||kr!qýn| j|ƒ|}qýW| sDt‚t | ƒdkrfdG| dGHq„d Gd | d| dfGHq‡ng}g}g}xY|D]Q\}}|dkrÈ|j|ƒq |dkrä|j|ƒq |j|ƒq Wd}x0| D](\\}}}||kr&qn|}t|ƒ}|||d!dkrgd|GHdG|GHqn|r†d|G|GHdG|GHq|rÌ|rÌd||fGHdG|GHdGHdG|| d||GHq|rî|rîd|GHdG|GHq|r|rddj|ƒdj|ƒ|fGHdG|GHqqWqŠW|jƒdS(Nt-iFscan't open: %s isIndex:isNo conclusive evidences$*** More than one / operator in lines**** More than one / operator per statementsin lines %d-%diÿÿÿÿR&tlongtfloattcomplext/s)*** Can't find the / operator in line %d:t*s*** Bad warning for line %d:s%dc%dts$True division / operator at line %d:t=s-*** Ambiguous / operator (%s, %s) at line %d:t|t?(R&R2(R3R4(tAssertionErrorRRRRR tFileContextR ttokenizetgenerate_tokensR tscanlineRtlenR%treportphantomwarningstreportRtchoptjoinR((RR0tfpRR+tindextgtstartlinenot endlinenotslashestlineinfotorphansRtrowstlastrowtrowtcolR,tintlongtfloatcomplextbadR.R/((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyRÍs¤ ")) !c Cs¯g}d}d}xF|D]>\}}||krJ|g}|j|ƒn|j|ƒqWxM|D]E}|d}dj|dƒ}d||fGH|j|ddƒqbWdS(NiR5is$*** Phantom %s warnings for line %d:tmarkR6(RR%RERC( RR+tblocksROt lastblockRPR/tblocktwhats((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyRB$s cCsZd}xM|D]E\\}}}||kr d||fGHdGt|ƒGH|}q q WdS(Ns*** %s on line %d:R6(RRD(RKtmessageRORPRQR,((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyRC3sR=cBsAeZddd„Zd„Zd„Zd„Zddd„ZRS( iicCs:||_d|_d|_d|_g|_g|_dS(Niii(RFtwindowR.teoflookaheadt lookaheadtbuffer(tselfRFR[R.((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyt__init__<s cCs_xXt|jƒ|jkrZ|jrZ|jjƒ}|sGd|_Pn|jj|ƒqWdS(Ni(RAR]R[R\RFR R%(R_R,((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pytfillCs% cCsL|jƒ|jsdS|jjdƒ}|jj|ƒ|jd7_|S(Ntii(RaR]tpopR^R%R.(R_R,((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyR Js cCsŸ|jƒ|jt|jƒ}|jt|jƒ}||koP|jknrd|j||S|j|ko~|knr•|j||jSt‚dS(N(RaR.RAR^R]tKeyError(R_RGtbufstarttlookend((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyt__getitem__Rs R6cCsn|dkr|}nxRt||dƒD]=}y||}Wntk rVd}nX|Gt|ƒGHq)WdS(Nis(RtrangeRdRD(R_tfirsttlastRUtiR,((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyRC[s N(t__name__t __module__R`RaR RgRRC(((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyR=;s c Cs“g}d}d}xq|D]i\}}}}}|d}|dkrM|}n|dkro|j||fƒn|tjkrPqqW|||fS(NiR5s/=(R5s/=(RR%R>tNEWLINE( RHRKRIRJttypettokentstarttendR,((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyR@es cCs|jdƒr|d S|SdS(Ns iÿÿÿÿ(tendswith(R,((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pyRDsst__main__((RRRRR>RRRRR RRBRCR=R@RDRlR(((s,/usr/lib64/python2.7/Tools/scripts/fixdiv.pytƒs" W * PK!8>}€EEobjgraph.pyonu„[µü¤ó fc@sùddlZddlZddlZddlZdZdZdZejdƒZd„Z d„Z iZiZiZ iZd„Zd „Zd „Zd„Zd„Zd „ZedkrõyejeƒƒWqõek rñejdƒqõXndS(iÿÿÿÿNt TRGDSBAECtUVtNntrgdsbavucs(.*): ?........ (.) (.*)$cCs4|j|ƒr#||j|ƒn |g||s0 5 PK!]o#combinerefs.pyonu„[µü¤ó fc@sTdZddlZddlZd„Zd„ZedkrPeejdƒndS(sL combinerefs path A helper for analyzing PYTHONDUMPREFS output. When the PYTHONDUMPREFS envar is set in a debug build, at Python shutdown time Py_Finalize() prints the list of all live objects twice: first it prints the repr() of each object while the interpreter is still fully intact. After cleaning up everything it can, it prints all remaining live objects again, but the second time just prints their addresses, refcounts, and type names (because the interpreter has been torn down, calling repr methods at this point can get into infinite loops or blow up). Save all this output into a file, then run this script passing the path to that file. The script finds both output chunks, combines them, then prints a line of output for each object still alive at the end: address refcnt typename repr address is the address of the object, in whatever format the platform C produces for a %p format code. refcnt is of the form "[" ref "]" when the object's refcount is the same in both PYTHONDUMPREFS output blocks, or "[" ref_before "->" ref_after "]" if the refcount changed. typename is object->ob_type->tp_name, extracted from the second PYTHONDUMPREFS output block. repr is repr(object), extracted from the first PYTHONDUMPREFS output block. CAUTION: If object is a container type, it may not actually contain all the objects shown in the repr: the repr was captured from the first output block, and some of the containees may have been released since then. For example, it's common for the line showing the dict of interned strings to display strings that no longer exist at the end of Py_Finalize; this can be recognized (albeit painfully) because such containees don't have a line of their own. The objects are listed in allocation order, with most-recently allocated printed first, and the first object allocated printed last. Simple examples: 00857060 [14] str '__len__' The str object '__len__' is alive at shutdown time, and both PYTHONDUMPREFS output blocks said there were 14 references to it. This is probably due to C modules that intern the string "__len__" and keep a reference to it in a file static. 00857038 [46->5] tuple () 46-5 = 41 references to the empty tuple were removed by the cleanup actions between the times PYTHONDUMPREFS produced output. 00858028 [1025->1456] str '' The string '', which is used in dictobject.c to overwrite a real key that gets deleted, grew several hundred references during cleanup. It suggests that stuff did get removed from dicts by cleanup, but that the dicts themselves are staying alive for some reason. iÿÿÿÿNccs9x2|D]*}t|j|ƒƒ|kr0|VqPqWdS(N(tbooltmatch(tfileitertpatt whilematchtline((s1/usr/lib64/python2.7/Tools/scripts/combinerefs.pytreadQs c Csšt|ƒ}t|ƒ}x#t|tjdƒtƒD]}q4Wtjdƒ}i}i}d}xkt|tjdƒtƒD]N}|j|ƒ}|rÀ|jƒ\} || <|| <|d7}q{dG|GHq{Wd} x§t||tƒD]“}| d7} |j|ƒ}|jƒ\} }}| |kr;dG|j ƒGHqæn| G||| krZd|Gnd || |fG|G|| GHqæW|j ƒd || fGHdS(Ns^Remaining objects:$s([a-zA-Z\d]+) \[(\d+)\] (.*)is^Remaining object addresses:$is??? skipped:s*??? new object created while tearing down:s[%s]s[%s->%s]s%d objects before, %d after(tfiletiterRtretcompiletFalseRtgroupstTruetrstriptclose( tfnametftfiRtcracktaddr2rct addr2gutstbeforetmtaddrtaftertrctguts((s1/usr/lib64/python2.7/Tools/scripts/combinerefs.pytcombineXs:"" t__main__i(t__doc__R tsysRRt__name__targv(((s1/usr/lib64/python2.7/Tools/scripts/combinerefs.pytFs &PK!júvû google.pynuÈ¯Ýí#! /usr/bin/python2.7 import sys, webbrowser def main(): args = sys.argv[1:] if not args: print "Usage: %s querystring" % sys.argv[0] return list = [] for arg in args: if '+' in arg: arg = arg.replace('+', '%2B') if ' ' in arg: arg = '"%s"' % arg arg = arg.replace(' ', '+') list.append(arg) s = '+'.join(list) url = "http://www.google.com/search?q=%s" % s webbrowser.open(url) if __name__ == '__main__': main() PK!‹-Å nm2def.pyonu„[µü¤ó fc@s¬dZddlZddlZdejd dZdejdejdd Zd Zedd„Zd„ZdZ dZ e d„Zd„Ze dkr¨eƒndS(sEnm2def.py Helpers to extract symbols from Unix libs and auto-generate Windows definition files from them. Depends on nm(1). Tested on Linux and Solaris only (-p option to nm is for Solaris only). By Marc-Andre Lemburg, Aug 1998. Additional notes: the output of nm is supposed to look like this: acceler.o: 000001fd T PyGrammar_AddAccelerators U PyGrammar_FindDFA 00000237 T PyGrammar_RemoveAccelerators U _IO_stderr_ U exit U fprintf U free U malloc U printf grammar1.o: 00000000 T PyGrammar_FindDFA 00000034 T PyGrammar_LabelRepr U _PyParser_TokenNames U abort U printf U sprintf ... Even if this isn't the default output of your nm, there is generally an option to produce this format (since it is the original v7 Unix format). iÿÿÿÿNt libpythonis.atPythoniis.dllsnm -p -g %stTtCtDc CsÌtjt|ƒjƒ}g|D]}|jƒ^q }i}x‡|D]}t|ƒdksEd|kroqEn|jƒ}t|ƒdkr“qEn|\}}} ||kr´qEn||f|| $s PK!Gƒ_o¨#¨#patchcheck.pyonu„[µü¤ó fc@sddlZddlZddlZddlZddlZddlZddlZddlZej j dddƒej j dddƒej j dddƒej j ddƒej j ddƒgZejd ƒZ d „Zedd„Zd„Zd „Zeddd„ƒd„ƒZeddd„ƒdd„ƒZd„Zeddeƒd„ƒZeddeƒd„ƒZejdƒZeddeƒd„ƒZeddeƒd„ƒZed deƒd!„ƒZed"deƒd#„ƒZd$„Z e!d%kre ƒndS(&iÿÿÿÿNtModulest_ctypestlibffit libffi_osxtlibffi_msvctexpattzlibtsrcdircCs"dj||dkrdndƒS(s7Return 'N file(s)' with the proper plurality on 'file'.s {} file{}itst(tformat(tcount((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytn_files_strscs‡‡‡fd†}|S(s*Decorator to output status info to stdout.cs‡‡‡‡fd†}|S(Ncsotjjˆdƒtjjƒˆ||Ž}ˆrFˆrFdGHn%ˆrZˆ|ƒGHn|rfdndGH|S(Ns ... tdonetyestNO(tsyststdouttwritetflush(targstkwargstresult(tfxntinfotmessagetmodal(s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytcall_fxns ((RR(RRR(Rs0/usr/lib64/python2.7/Tools/scripts/patchcheck.pyt decorated_fxns((RRRR((RRRs0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytstatuss cCsBdjƒ}ytj|dtjƒSWntjk r=dSXdS(s0Get the symbolic name for the current git branchsgit rev-parse --abbrev-ref HEADtstderrN(tsplitt subprocesstcheck_outputtPIPEtCalledProcessErrortNone(tcmd((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytget_git_branch.s cCsBdjƒ}ytj|dtjƒWntjk r=dSXdS(skGet the remote name to use for upstream branches Uses "upstream" if it exists, "origin" otherwise sgit remote get-url upstreamRtorigintupstream(RR R!R"R#(R%((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytget_git_upstream_remote7ssGetting base branch for PRRcCs|dk r|SdS(Nsnot a PR branch(R$(tx((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytER cCstjjtjjtdƒƒs%dStj}|jdkrFd}ndj |ƒ}t ƒ}|dksv||krzdStƒ}|d|S(Ns.gittalphatmasters{0.major}.{0.minor}t/(tostpathtexiststjointSRCDIRR$Rtversion_infotreleaselevelR R&R)(tversiontbase_branchtthis_branchtupstream_remote((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytget_base_branchDs! s6Getting the list of files that have been added/changedcCstt|ƒƒS(N(Rtlen(R*((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pyR+XR csvtjjtjjtdƒƒr |r4d|}nd}g}tj|jƒdtjƒ}z›x”|j D]‰}|j ƒjƒ}|jd dƒ\}‰t |ƒ}|jdƒs¼qkndˆkrçˆjddƒdjƒ‰n|jˆƒqkWWd |j jƒXn tjd ƒg}xO|D]G‰tjjˆƒ‰t‡fd†tDƒƒraq'n|jˆƒq'W|S(s0Get the list of changed or added files from git.s.gitsgit diff --name-status sgit status --porcelainRitMAUs -> iNs)need a git checkout to get modified filesc3s|]}ˆj|ƒVqdS(N(t startswith(t.0R0(tfilename(s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pys zs(R/R0R1R2R3R tPopenRR"RtdecodetrstripR$tsettintersectiontstriptappendtcloseRtexittnormpathtanytEXCLUDE_DIRS(R7R%t filenameststtlinetstatus_textRt filenames2((R?s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pyt changed_filesWs2! cCsrt|ƒ}|dkr"t|ƒSdjt|ƒƒg}x$|D]}|jdj|ƒƒqAWdj|ƒSdS(Nis{}:s {}s (R;RR RFR2(t file_pathsRtlinesR0((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytreport_modified_files‚s sFixing whitespacecCs\tt_g}xFd„|DƒD]4}tjtjjt|ƒƒr |j|ƒq q W|S(sAMake sure that the whitespace for .py files have been normalized.css$|]}|jdƒr|VqdS(s.pyN(tendswith(R>R*((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pys ’s( tFalsetreindentt makebackuptcheckR/R0R2R3RF(RRtfixedR0((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytnormalize_whitespaces sFixing C file whitespacecCsƒg}xv|D]n}tjjt|ƒ}t|dƒ}d|jƒkrRw nWdQXtj|ddtƒ|j |ƒq W|S(sReport if any C files trs Nitverbose( R/R0R2R3topentreadtuntabifytprocessRVRF(RRRZR0tabspathtf((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytnormalize_c_whitespace˜s s\s+(\r?\n)$sFixing docs whitespacec Cs÷g}xê|D]â}tjjt|ƒ}y¢t|dƒ}|jƒ}WdQXg|D]}tjd|ƒ^qV}||krÉtj ||dƒt|dƒ}|j |ƒWdQX|j|ƒnWq tk rî}d||fGHq Xq W|S(Ntrbs\1s.baktwbsCannot fix %s: %s( R/R0R2R3R^t readlinestws_retsubtshutiltcopyfilet writelinesRFt Exception( RRRZR0RbRcRSRNt new_linesterr((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytnormalize_docs_whitespace¨s %s Docs modifiedRcCs t|ƒS(s9Report if any file in the Doc directory has been changed.(tbool(RR((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pyt docs_modified»ssMisc/ACKS updatedcCstjjddƒ|kS(s$Check if Misc/ACKS has been changed.tMisctACKS(R/R0R2(RR((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytcredit_givenÁss Misc/NEWS.d updated with `blurb`cCstd„|DƒƒS(s&Check if Misc/NEWS.d has been changed.css0|]&}|jtjjdddƒƒVqdS(RssNEWS.dtnextN(R=R/R0R2(R>tp((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pys Ês(RJ(RR((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pyt reported_newsÇs cCstƒ}t|ƒ}g|D]}|jdƒr|^q}g|D]}|jdƒrD|^qD}g|D]*}|jdƒrl|jdƒrl|^ql}d„|Dƒ}t|ƒt|ƒt|ƒt|ƒt|ƒt |ƒ|sô|r|rdnd }Hd |GHndS( Ns.pys.cs.htDocs.rsts.inccSs%h|]}|jdƒr|’qS(Rs(R=(R>Rw((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pys Õs s and check for refleaks?t?sDid you run the test suite(s.cs.h(s.rsts.inc( R:RQRUR=R[RdRpRrRuRx(R7RRtfntpython_filestc_filest doc_filest misc_filestend((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytmainÎs" (( t__main__("treRRjtos.pathR/R t sysconfigRWR`R0R2RKtget_config_varR3RRVR$RR&R)R:RQRTR[RdtcompileRhRptTrueRrRuRxRt__name__(((s0/usr/lib64/python2.7/Tools/scripts/patchcheck.pytsB ) PK!BÉÐôpplfcr.pyonu„[µü¤ó fc@sMdZddlZddlZddlZd„ZedkrIeƒndS(sFReplace LF with CRLF in argument files. Print names of changed files.iÿÿÿÿNcCs¼xµtjdD]¦}tjj|ƒr5|GdGHqnt|dƒjƒ}d|kre|GdGHqntjdd|ƒ}||kr|GHt|dƒ}|j |ƒ|j ƒqqWdS( Nis Directory!trbssBinary!s ? s twb(tsystargvtostpathtisdirtopentreadtretsubtwritetclose(tfilenametdatatnewdatatf((s*/usr/lib64/python2.7/Tools/scripts/lfcr.pytmains t__main__(t__doc__RR RRt__name__(((s*/usr/lib64/python2.7/Tools/scripts/lfcr.pyts$ PK!òG†ø ø findnocoding.pynuÈ¯Ýí#! /usr/bin/python2.7 """List all those Python files that require a coding directive Usage: nocoding.py dir1 [dir2...] """ __author__ = "Oleg Broytmann, Georg Brandl" import sys, os, re, getopt # our pysource module finds Python source files try: import pysource except ImportError: # emulate the module with a simple os.walk class pysource: has_python_ext = looks_like_python = can_be_compiled = None def walk_python_files(self, paths, *args, **kwargs): for path in paths: if os.path.isfile(path): yield path.endswith(".py") elif os.path.isdir(path): for root, dirs, files in os.walk(path): for filename in files: if filename.endswith(".py"): yield os.path.join(root, filename) pysource = pysource() print >>sys.stderr, ("The pysource module is not available; " "no sophisticated Python source file search will be done.") decl_re = re.compile(r'^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)') blank_re = re.compile(r'^[ \t\f]*(?:[#\r\n]|$)') def get_declaration(line): match = decl_re.match(line) if match: return match.group(1) return b'' def has_correct_encoding(text, codec): try: unicode(text, codec) except UnicodeDecodeError: return False else: return True def needs_declaration(fullpath): try: infile = open(fullpath, 'rU') except IOError: # Oops, the file was removed - ignore it return None line1 = infile.readline() line2 = infile.readline() if (get_declaration(line1) or blank_re.match(line1) and get_declaration(line2)): # the file does have an encoding declaration, so trust it infile.close() return False # check the whole file for non-ASCII characters rest = infile.read() infile.close() if has_correct_encoding(line1+line2+rest, "ascii"): return False return True usage = """Usage: %s [-cd] paths... -c: recognize Python source files trying to compile them -d: debug output""" % sys.argv[0] try: opts, args = getopt.getopt(sys.argv[1:], 'cd') except getopt.error, msg: print >>sys.stderr, msg print >>sys.stderr, usage sys.exit(1) is_python = pysource.looks_like_python debug = False for o, a in opts: if o == '-c': is_python = pysource.can_be_compiled elif o == '-d': debug = True if not args: print >>sys.stderr, usage sys.exit(1) for fullpath in pysource.walk_python_files(args, is_python): if debug: print "Testing for coding: %s" % fullpath result = needs_declaration(fullpath) if result: print fullpath PK!d8f®OO dutree.pynuÈ¯Ýí#! /usr/bin/python2.7 # Format du output in a tree shape import os, sys, errno def main(): p = os.popen('du ' + ' '.join(sys.argv[1:]), 'r') total, d = None, {} for line in p.readlines(): i = 0 while line[i] in '0123456789': i = i+1 size = eval(line[:i]) while line[i] in ' \t': i = i+1 filename = line[i:-1] comps = filename.split('/') if comps[0] == '': comps[0] = '/' if comps[len(comps)-1] == '': del comps[len(comps)-1] total, d = store(size, comps, total, d) try: display(total, d) except IOError, e: if e.errno != errno.EPIPE: raise def store(size, comps, total, d): if comps == []: return size, d if not d.has_key(comps[0]): d[comps[0]] = None, {} t1, d1 = d[comps[0]] d[comps[0]] = store(size, comps[1:], t1, d1) return total, d def display(total, d): show(total, d, '') def show(total, d, prefix): if not d: return list = [] sum = 0 for key in d.keys(): tsub, dsub = d[key] list.append((tsub, key)) if tsub is not None: sum = sum + tsub ## if sum < total: ## list.append((total - sum, os.curdir)) list.sort() list.reverse() width = len(repr(list[0][0])) for tsub, key in list: if tsub is None: psub = prefix else: print prefix + repr(tsub).rjust(width) + ' ' + key psub = prefix + ' '*(width-1) + '|' + ' '*(len(key)+1) if d.has_key(key): show(tsub, d[key][1], psub) if __name__ == '__main__': main() PK!oHq]]classfix.pyonu„[µü¤ó fc@sÌddlZddlZddlZddlTejjZeZejjZ d„Z ejdƒZd„Z d„Zd„ZdZejeƒZd ZejeƒZd „ZedkrÈe ƒndS(iÿÿÿÿN(t*cCsÍd}tjds<tdtjddƒtjdƒnx}tjdD]n}tjj|ƒrzt|ƒr¸d}q¸qJtjj|ƒr£t|dƒd}qJt |ƒrJd}qJqJWtj|ƒdS(Niisusage: s file-or-directory ... is": will not process symbolic links ( tsystargvterrtexittostpathtisdirtrecursedowntislinktfix(tbadtarg((s./usr/lib64/python2.7/Tools/scripts/classfix.pytmain)s s^[a-zA-Z0-9_]+\.py$cCstj|ƒdkS(Ni(tispythonprogtmatch(tname((s./usr/lib64/python2.7/Tools/scripts/classfix.pytispython9scCs1td|fƒd}ytj|ƒ}Wn+tjk rW}td||fƒdSX|jƒg}xœ|D]”}|tjtjfkr“qontjj ||ƒ}tjj |ƒr½qotjj|ƒrß|j|ƒqot |ƒrot|ƒrd}qqoqoWx#|D]}t|ƒrd}qqW|S(Nsrecursedown(%r) is%s: cannot list directory: %r i(tdbgRtlistdirterrorRtsorttcurdirtpardirRtjoinR RtappendRR R(tdirnameRtnamestmsgtsubdirsRtfullname((s./usr/lib64/python2.7/Tools/scripts/classfix.pyR<s0 cCs¼yt|dƒ}Wn(tk r=}td||fƒdSXtjj|ƒ\}}tjj|d|ƒ}d}d}xG|jƒ}|s”Pn|d}x>|ddkrÞ|jƒ} | sÇPn|| }|d}q¡Wt |ƒ} | |kr¥|dkrryt|dƒ}Wn2tk rJ}|j ƒtd ||fƒdSX|jdƒd}t|d ƒq~ntt |ƒdƒtd|ƒtd | ƒn|dk r~|j| ƒq~q~W|j ƒ|sÙdSy+tj|ƒ}tj||td@ƒWn*tjk r0}td||fƒnXytj||dƒWn*tjk ru}td||fƒnXytj||ƒWn+tjk r·}td||fƒdSXdS(Ntrs%s: cannot open: %r it@iiþÿÿÿs\ tws%s: cannot create: %r s: s s< s> iÿs%s: warning: chmod failed (%r) t~s %s: warning: backup failed (%r) s%s: rename failed (%r) (topentIOErrorRRRtsplitRtNonetreadlinetfixlinetclosetseektreptreprtwritetstattchmodtST_MODERtrename(tfilenametfRtheadttailttempnametgtlinenotlinetnextlinetnewlinetstatbuf((s./usr/lib64/python2.7/Tools/scripts/classfix.pyR Rsp s-^([ ]*class +[a-zA-Z0-9_]+) *( *) *((=.*)?):s^ *(.*) *( *) *$cCstj|ƒdkr|Stjd \\}}\}}\}}|| }||}||krm|d|S||d|!} | jdƒ} x^tt| ƒƒD]J}tj| |ƒdkr tjd\}} | ||| !| | s$ E PK!l²8¥¥setup.pynu„[µü¤from distutils.core import setup if __name__ == '__main__': setup( scripts=[ 'byteyears.py', 'checkpyc.py', 'copytime.py', 'crlf.py', 'dutree.py', 'ftpmirror.py', 'h2py.py', 'lfcr.py', '../i18n/pygettext.py', 'logmerge.py', '../../Lib/tabnanny.py', '../../Lib/timeit.py', 'untabify.py', ], ) PK!ŽTFmÛÛlogmerge.pycnu„[µü¤ó fc@sÅdZddlZddlZddlZddlZdddZdddZd„Zd „Zdd „Z d„ZedkrÁyeƒWqÁe k r½Zejejkr¾‚q¾qÁXndS( s¿Consolidate a bunch of CVS or RCS logs read from stdin. Input should be the output of a CVS or RCS logging command, e.g. cvs log -rrelease14: which dumps all log messages from release1.4 upwards (assuming that release 1.4 was tagged with tag 'release14'). Note the trailing colon! This collects all the revision records and outputs them sorted by date rather than by file, collapsing duplicate revision record, i.e., records with the same message for different files. The -t option causes it to truncate (discard) the last revision log entry; this is useful when using something like the above cvs log command, which shows the revisions including the given tag, while you probably want everything *since* that tag. The -r option reverses the output (oldest first; the default is oldest last). The -b tag option restricts the output to *only* checkin messages belonging to the given branch tag. The form -b HEAD restricts the output to checkin messages belonging to the CVS head (trunk). (It produces some output if tag is a non-branch tag, but this output is not very useful.) -h prints this message and exits. XXX This code was created by reverse engineering CVS 1.9 and RCS 5.7 from their output. iÿÿÿÿNt=iMs t-ic Cs(d}d}d }tjtjddƒ\}}xt|D]l\}}|dkrYd}q8|dkrnd}q8|dkrƒ|}q8|dkr8tGHtjdƒq8q8Wg}xLttjƒ}|sÊPnt||ƒ} |ré| d=n| |t |ƒ)q±W|j ƒ|s|jƒnt|ƒd S( sMain programiistrb:hs-ts-rs-bs-hiÿÿÿÿN( tNonetgetopttsystargvt__doc__texitt read_chunktstdintdigest_chunktlentsorttreverset format_output( t truncate_lastR tbranchtoptstargstotatdatabasetchunktrecords((s./usr/lib64/python2.7/Tools/scripts/logmerge.pytmain*s6 cCs‹g}g}xx|jƒ}|s%Pn|tkrK|rG|j|ƒnPn|tkrv|rƒ|j|ƒg}qƒq|j|ƒqW|S(skRead a chunk -- data for one file, ending with sep1. Split the chunk in parts separated by sep2. (treadlinetsep1tappendtsep2(tfpRtlinestline((s./usr/lib64/python2.7/Tools/scripts/logmerge.pyRHs cCs5|d}d}t|ƒ}x8|D]*}|| |kr#||jƒ}Pq#q#Wd}|dkrfn"|dkr„tjdƒ}ni}d}d}x~|D]v}||kr¸d}q|r|ddkr |jƒ\} } | dd krý| d } n| || $s.0.t.t^s\.\d+$iisdate:t;t isauthor:itrevisionN( RtstripRtretcompiletsplittgettfindtreplacetescapetinserttmatchR(RRRtkeytkeylenRtworking_filet revisionstfoundttagtrevRtrevlinetdatelinettexttwordstauthortdatewordttimewordtdate((s./usr/lib64/python2.7/Tools/scripts/logmerge.pyR `sx & " " " cCs¼d}g}|jdƒxœ|D]”\}}}}}||kr•|rŒtGx+|D]#\}} } }|G|G| G| GHqRWtjj|ƒng}n|j||||fƒ|}q WdS(N(NNNNN(RRRRtstdoutt writelines(RtprevtexttprevR?R3R7R<R:tp_datetp_working_filetp_revtp_author((s./usr/lib64/python2.7/Tools/scripts/logmerge.pyR¥s t__main__(RRterrnoRR(RRRRRR Rt__name__tIOErrortetEPIPE(((s./usr/lib64/python2.7/Tools/scripts/logmerge.pyt#s0 E PK!ì!Ú0eebyteyears.pynuÈ¯Ýí#! /usr/bin/python2.7 # Print the product of age and size of each file, in suitable units. # # Usage: byteyears [ -a | -m | -c ] file ... # # Options -[amc] select atime, mtime (default) or ctime as age. import sys, os, time from stat import * def main(): # Use lstat() to stat files if it exists, else stat() try: statfunc = os.lstat except AttributeError: statfunc = os.stat # Parse options if sys.argv[1] == '-m': itime = ST_MTIME del sys.argv[1] elif sys.argv[1] == '-c': itime = ST_CTIME del sys.argv[1] elif sys.argv[1] == '-a': itime = ST_CTIME del sys.argv[1] else: itime = ST_MTIME secs_per_year = 365.0 * 24.0 * 3600.0 # Scale factor now = time.time() # Current time, for age computations status = 0 # Exit status, set to 1 on errors # Compute max file name length maxlen = 1 for filename in sys.argv[1:]: maxlen = max(maxlen, len(filename)) # Process each argument in turn for filename in sys.argv[1:]: try: st = statfunc(filename) except os.error, msg: sys.stderr.write("can't stat %r: %r\n" % (filename, msg)) status = 1 st = () if st: anytime = st[itime] size = st[ST_SIZE] age = now - anytime byteyears = float(size) * float(age) / secs_per_year print filename.ljust(maxlen), print repr(int(byteyears)).rjust(8) sys.exit(status) if __name__ == '__main__': main() PK!yIowin_add2path.pyonu„[µü¤ó fc@s}dZddlZddlZddlZddlZejZdZdZdZ d„Z d„ZedkryeƒndS( sAdd Python to the search path on Windows This is a simple script to add Python to the Windows search path. It modifies the current user (HKCU) tree of the registry. Copyright (c) 2008 by Christian Heimes Licensed to PSF under a Contributor Agreement. iÿÿÿÿNtEnvironmenttPATHu%PATH%c Csgtjjtjjtjƒƒ}tjj|dƒ}tjd}tt dƒrt j j|dƒ}tjj|dƒ}nd}t jttƒÊ}yt j|tƒd}Wntk rÍt}nX|g}xK|||fD]:}|rç||krçtjj|ƒrç|j|ƒqçqçWtjj|ƒ}t j|tdt j|ƒ||fSWdQXdS(NtScriptstAPPDATAt USER_SITEs %APPDATA%i(tostpathtdirnametnormpathtsyst executabletjointenvironthasattrtsiteRtreplacetNonet_winregt CreateKeytHKCUtENVtQueryValueExRtWindowsErrortDEFAULTtisdirtappendtpathsept SetValueExt REG_EXPAND_SZ( t pythonpathtscriptstappdatatuserpathtuserscriptstkeytenvpathtpathsR((s2/usr/lib64/python2.7/Tools/scripts/win_add2path.pytmodifys&! $cCs`tƒ\}}t|ƒdkr;dGHdj|dƒGHndGHd|GHdGHtj|ƒGHdS(NisPath(s) added:s sNo path was addeds PATH is now: %s s Expanded:(R%tlenRRtExpandEnvironmentStrings(R$R#((s2/usr/lib64/python2.7/Tools/scripts/win_add2path.pytmain-s t__main__( t__doc__R RRRtHKEY_CURRENT_USERRRRRR%R(t__name__(((s2/usr/lib64/python2.7/Tools/scripts/win_add2path.pyts PK!S•;findnocoding.pycnu„[µü¤ó fc@sùdZdZddlZddlZddlZddlZyddlZWn:ek rˆddd„ƒYZeƒZejdIJnXej dƒZ ej dƒZd „Zd „Z d„Zdejd Zy#ejejddƒ\ZZWn=ejk r5ZejeIJejeIJejdƒnXejZeZxAeD]9\ZZedkrpejZqLedkrLeZqLqLWes¬ejeIJejdƒnxFejeeƒD]2Zer×deGHneeƒZ e r¿eGHq¿q¿WdS(s_List all those Python files that require a coding directive Usage: nocoding.py dir1 [dir2...] sOleg Broytmann, Georg BrandliÿÿÿÿNtpysourcecBseZdZZZd„ZRS(c os§x |D]˜}tjj|ƒr0|jdƒVqtjj|ƒrxZtj|ƒD]F\}}}x4|D],}|jdƒrhtjj||ƒVqhqhWqRWqqWdS(Ns.py(tostpathtisfiletendswithtisdirtwalktjoin( tselftpathstargstkwargsRtroottdirstfilestfilename((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pytwalk_python_filess N(t__name__t __module__tNonethas_python_exttlooks_like_pythontcan_be_compiledR(((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pyRss^The pysource module is not available; no sophisticated Python source file search will be done.s&^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)s^[ \t\f]*(?:[#\r\n]|$)cCs&tj|ƒ}|r"|jdƒSdS(Nit(tdecl_retmatchtgroup(tlineR((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pytget_declaration&s cCs.yt||ƒWntk r%tSXtSdS(N(tunicodetUnicodeDecodeErrortFalsetTrue(ttexttcodec((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pythas_correct_encoding,s cCsªyt|dƒ}Wntk r'dSX|jƒ}|jƒ}t|ƒsgtj|ƒrut|ƒru|jƒtS|j ƒ}|jƒt |||dƒr¦tStS(NtrUtascii(topentIOErrorRtreadlineRtblank_reRtcloseRtreadR#R (tfullpathtinfiletline1tline2trest((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pytneeds_declaration4s sjUsage: %s [-cd] paths... -c: recognize Python source files trying to compile them -d: debug outputiitcds-cs-dsTesting for coding: %s((!t__doc__t __author__tsysRtretgetoptRtImportErrortstderrtcompileRR)RR#R1targvtusagetoptsR terrortmsgtexitRt is_pythonRtdebugtotaRR RR,tresult(((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pytsH0 # PK!ý³Ö{{serve.pynuÈ¯Ýí#! /usr/bin/python2.7 ''' Small wsgiref based web server. Takes a path to serve from and an optional port number (defaults to 8000), then tries to serve files. Mime types are guessed from the file names, 404 errors are raised if the file is not found. Used for the make serve target in Doc. ''' import sys import os import mimetypes from wsgiref import simple_server, util def app(environ, respond): fn = os.path.join(path, environ['PATH_INFO'][1:]) if '.' not in fn.split(os.path.sep)[-1]: fn = os.path.join(fn, 'index.html') type = mimetypes.guess_type(fn)[0] if os.path.exists(fn): respond('200 OK', [('Content-Type', type)]) return util.FileWrapper(open(fn)) else: respond('404 Not Found', [('Content-Type', 'text/plain')]) return ['not found'] if __name__ == '__main__': path = sys.argv[1] port = int(sys.argv[2]) if len(sys.argv) > 2 else 8000 httpd = simple_server.make_server('', port, app) print "Serving %s on port %s, control-C to stop" % (path, port) try: httpd.serve_forever() except KeyboardInterrupt: print "\b\bShutting down." PK!á3R== serve.pyonu„[µü¤ó fc@sâdZddlZddlZddlZddlmZmZd„ZedkrÞej dZ eej ƒdkrŠeej dƒndZ ejd e eƒZd e e fGHyejƒWqÞek rÚdGHqÞXndS(s Small wsgiref based web server. Takes a path to serve from and an optional port number (defaults to 8000), then tries to serve files. Mime types are guessed from the file names, 404 errors are raised if the file is not found. Used for the make serve target in Doc. iÿÿÿÿN(t simple_servertutilcCs½tjjt|ddƒ}d|jtjjƒdkrTtjj|dƒ}ntj|ƒd}tjj|ƒr¢|dd|fgƒtj t |ƒƒS|d dgƒdgSdS( Nt PATH_INFOit.iÿÿÿÿs index.htmlis200 OKsContent-Types 404 Not Founds text/plains not found(sContent-Types text/plain(tostpathtjointsplittsept mimetypest guess_typetexistsRtFileWrappertopen(tenvirontrespondtfnttype((s+/usr/lib64/python2.7/Tools/scripts/serve.pytapp st__main__iii@ts(Serving %s on port %s, control-C to stopsShutting down.(t__doc__tsysRR twsgirefRRRt__name__targvRtlentinttporttmake_serverthttpdt serve_forevertKeyboardInterrupt(((s+/usr/lib64/python2.7/Tools/scripts/serve.pyts . PK!Ü½\kââcleanfuture.pycnu„[µü¤ó fc@sdZddlZddlZddlZddlZdadadad„Zd„Z d„Z dd d„ƒYZed krŒe ƒndS(s‘cleanfuture [-d][-r][-v] path ... -d Dry run. Analyze, but don't make any changes to, files. -r Recurse. Search for all .py files in subdirectories too. -v Verbose. Print informative msgs. Search Python (.py) files for future statements, and remove the features from such statements that are already mandatory in the version of Python you're using. Pass one or more file and/or directory paths. When a directory path, all .py files within the directory will be examined, and, if the -r option is given, likewise recursively for subdirectories. Overwrites files in place, renaming the originals with a .bak extension. If cleanfuture finds nothing to change, the file is left alone. If cleanfuture does change a file, the changed file is a fixed-point (i.e., running cleanfuture on the resulting .py file won't change it again, at least not until you try it again with a later Python release). Limitations: You can do these things, but this tool won't help you then: + A future statement cannot be mixed with any other statement on the same physical line (separated by semicolon). + A future statement cannot contain an "as" clause. Example: Assuming you're using Python 2.2, if a file containing from __future__ import nested_scopes, generators is analyzed by cleanfuture, the line is rewritten to from __future__ import generators because nested_scopes is no longer optional in 2.2 but generators is. iÿÿÿÿNicGsOtt|ƒ}dj|ƒ}|ddkr;|d7}ntjj|ƒdS(Nt iÿÿÿÿs (tmaptstrtjointsyststderrtwrite(targststringstmsg((s1/usr/lib64/python2.7/Tools/scripts/cleanfuture.pyterrprint2s cCsëddl}y#|jtjddƒ\}}Wn!|jk rR}t|ƒdSXx_|D]W\}}|dkrtd7aqZ|dkr˜td7aqZ|dkrZtd7aqZqZW|sÌtdtƒdSx|D]}t |ƒqÓWdS(Niÿÿÿÿitdrvs-ds-rs-vsUsage:( tgetoptRtargvterrorR tdryruntrecursetverboset__doc__tcheck(RtoptsRR totatarg((s1/usr/lib64/python2.7/Tools/scripts/cleanfuture.pytmain9s$# cCs“tjj|ƒr½tjj|ƒr½tr7dG|GHntj|ƒ}xp|D]h}tjj||ƒ}tr“tjj|ƒr“tjj|ƒs¨|jƒj dƒrMt |ƒqMqMWdStrÒdG|GdGnyt|ƒ}Wn.tk r}t d|t|ƒfƒdSXt||ƒ}|jƒ}|rA|jƒn|jƒ|rtrmdGHtrmdGHqmnxw|D]o\}} } d||d | d fGHx&t|| d ƒD]}|j|Gq±W| dkrÚd GHqtdGH| GqtWts|d}tjj|ƒrtj|ƒntj||ƒtrCd G|GdG|GHnt|dƒ} |j| ƒ| jƒtr~dG|GHq~qntrdGHndS(Nslisting directorys.pytcheckings...s%r: I/O Error: %sschanged.s+But this is a dry run, so leaving it alone.s%r lines %d-%dis -- deleteds -- change to:s.baktrenamedttotws wrote news unchanged.(tostpathtisdirtislinkRtlistdirRRtlowertendswithRtopentIOErrorR RtFutureFindertrunt gettheresttcloseRtrangetlinestNonetexiststremovetrenameR(tfiletnamestnametfullnametfR tfftchangedtstetlinetitbaktg((s1/usr/lib64/python2.7/Tools/scripts/cleanfuture.pyRNsd% R&cBs5eZd„Zd„Zd„Zd„Zd„ZRS(cCs1||_||_d|_g|_g|_dS(Ni(R4tfnametateofR+R6(tselfR4R=((s1/usr/lib64/python2.7/Tools/scripts/cleanfuture.pyt__init__ˆs cCsH|jr dS|jjƒ}|dkr4d|_n|jj|ƒ|S(Nti(R>R4treadlineR+tappend(R?R9((s1/usr/lib64/python2.7/Tools/scripts/cleanfuture.pytgetline’s cCs tj}tj}tj}tj}tj}tj}|j}tj|j ƒj }|ƒ\} } \}}\} }}x=| |||fkr·|ƒ\} } \}}\} }}q{Wx4| |krî|ƒ\} } \}}\} }}q»Wxx=| |||fkr1|ƒ\} } \}}\} }}qõW| |koG| dksNPn|d}|ƒ\} } \}}\} }}| |ko‘| dks˜Pn|ƒ\} } \}}\} }}| |koÑ| dksØPn|ƒ\} } \}}\} }}g}x| |kr…|j| ƒ|ƒ\} } \}}\} }}| |koW| dks^Pn|ƒ\} } \}}\} }}qWd}| |krÅ| }|ƒ\} } \}}\} }}n| |k rït d|j||fƒgS|d}g}xs|D]k}tt|dƒ}|dkr:|j|ƒq|jƒ}|dksq|tjkrdq|j|ƒqWt|ƒt|ƒkròt|ƒdkr¨d}n@d}|d j|ƒ7}|dk rÞ|d |7}n|d7}|j|||fƒqòqòW|S(Ntfromit __future__timportt,s)Skipping file %r; can't parse line %d: %sisfrom __future__ import s, Rs (ttokenizetSTRINGtNLtNEWLINEtCOMMENTtNAMEtOPR6tgenerate_tokensRDtnextRCR,R R=tgetattrRFtgetMandatoryReleaseRtversion_infotlenR(R?RJRKRLRMRNROR6tgetttypettokentsrowtscolterowtecolR9t startlinetfeaturestcommenttendlinet okfeaturesR4tobjecttreleased((s1/usr/lib64/python2.7/Tools/scripts/cleanfuture.pyR'œsz $((( $$$ $(' cCs+|jrd|_n|jjƒ|_dS(NRA(R>ttherestR4tread(R?((s1/usr/lib64/python2.7/Tools/scripts/cleanfuture.pyR(ûs cCs©|j}|st‚g|_|jƒxN|D]F\}}}|dkr^|j||d5q/|g|j||d+q/W|j|jƒ|jr¥|j|jƒndS(Ni(R6tAssertionErrortreverseR,R+t writelinesRdR(R?R4R6R7R8R9((s1/usr/lib64/python2.7/Tools/scripts/cleanfuture.pyRs (t__name__t __module__R@RDR'R(R(((s1/usr/lib64/python2.7/Tools/scripts/cleanfuture.pyR&†s _ t__main__(( RRFRIRRRRRR RRR&Ri(((s1/usr/lib64/python2.7/Tools/scripts/cleanfuture.pyt's 8PK!1×Äô¼¼ mkreal.pycnu„[µü¤ó fc@soddlZddlZddlTejjZdZd Zd„Zd„Zd„Z e d krke ƒndS(iÿÿÿÿN(t*smkreal errori icCstj|ƒ}t|tƒ}tj|ƒ}t|dƒ}tj|ƒt|dƒ}x*|jtƒ}|suPn|j |ƒq\W~tj ||ƒdS(Ntrtw(toststattS_IMODEtST_MODEtreadlinktopentunlinktreadtBUFSIZEtwritetchmod(tnametsttmodetlinktotf_intf_outtbuf((s,/usr/lib64/python2.7/Tools/scripts/mkreal.pyt mkrealfiles cCsÎtj|ƒ}t|tƒ}tj|ƒ}tj|ƒ}tj|ƒtj||ƒtj||ƒt tj |ƒ}xK|D]C}|tjtj fkrƒtjt ||ƒt ||ƒƒqƒqƒWdS(N( RRRRRtlistdirR tmkdirR tjointpardirtcurdirtsymlink(RRRRtfilestfilename((s,/usr/lib64/python2.7/Tools/scripts/mkreal.pyt mkrealdirs cCsëtjt_tjjtjdƒ}|dkr:d}ntjd}|sjdG|GdGHtjdƒnd}xg|D]_}tjj|ƒs|dG|dGd GHd}qwtjj |ƒrÌt |ƒqwt|ƒqwWtj|ƒdS( Nis-ctmkrealisusage:spath ...it:s not a symlink(tsyststderrtstdoutRtpathtbasenametargvtexittislinktisdirRR(tprognametargststatusR((s,/usr/lib64/python2.7/Tools/scripts/mkreal.pytmain-s" t__main__i€(R!RRR$RterrorRRRR-t__name__(((s,/usr/lib64/python2.7/Tools/scripts/mkreal.pyts PK!.Ïrfftreesync.pycnu„[µü¤ó fc@sÈdZddlZddlZddlZddlZdZdZdadada d„Z d„Zd„ZdZ d„Zd„Zd „Zdddd„Zdd„ZedkrÄe ƒndS(s†Script to synchronize two source trees. Invoke with two arguments: python treesync.py slave master The assumption is that "master" contains CVS administration while slave doesn't. All files in the slave tree that have a CVS/Entries entry in the master tree are synchronized. This means: If the files differ: if the slave file is newer: normalize the slave file if the files still differ: copy the slave to the master else (the master is newer): copy the master to the slave normalizing the slave means replacing CRLF with LF when the master doesn't use CRLF iÿÿÿÿNtasktyestnocCs)tjtjddƒ\}}x³|D]«\}}|dkrGd}n|dkr\d}n|dkrq|an|dkr†|an|d kr›|an|d kr°|}n|dkr&|}aaaq&q&Wy|\}}Wn0tk rdGtjd p dGdGdGHdSXt||ƒdS(Nisnym:s:d:f:a:s-yRs-nRs-ss-ms-ds-fs-as usage: pythonistreesync.pys5[-n] [-y] [-m y|n|a] [-s y|n|a] [-d y|n|a] [-f n|y|a]sslavedir masterdir(tgetopttsystargvtwrite_slavetwrite_mastertcreate_directoriest ValueErrortprocess(toptstargstotatdefault_answertcreate_filestslavetmaster((s./usr/lib64/python2.7/Tools/scripts/treesync.pytmain#s0 cCsYtjj|dƒ}tjj|ƒs9dG|GHdGHdSddGHdG|GHdG|GHtjj|ƒsãtd|d tƒs’dG|GHd G|GHdSdG|GHytj|ƒWn(tjk rÖ}dG|Gd G|GHdSXdG|GHnd}g}tj |ƒ}xˆ|D]€}tjj||ƒ}tjj||ƒ}|dkrJ|}qtjj|ƒrtjj |ƒr|j||fƒqqW|r1tjj|dƒ} xŠt| ƒj ƒD]s} | jdƒ}|ddkr·|dr·|d}tjj||ƒ}tjj||ƒ} t|| ƒq·q·Wnx!|D]\}} t|| ƒq8WdS(NtCVSsskipping master subdirectorys-- not under CVSt-i(sslave Rscreate slave directory %s?tanswers-- no corresponding slavescreating slave directoryscan't make slave directoryt:smade slave directorytEntriest/iti(tostpathtjointisdirtokayRtmkdirterrortNonetlistdirtislinktappendtopent readlinestsplittcompareR (RRtcvsdirtmsgtsubdirstnamestnamet masternamet slavenametentriestetwordststm((s./usr/lib64/python2.7/Tools/scripts/treesync.pyR ?sT % cCsªyt|dƒ}Wntk r,d}nXyt|dƒ}Wntk rYd}nX|s“|ssdG|GHdSdG|GHt||dtƒdS|s¦dG|GHdS|rÈ|rÈt||ƒrÈdSnt|ƒ}t|ƒ}||kr)|jƒ|jƒdG|GHdG|GHt||dtƒdSd G||Gd GH|j dƒt |ƒ}|jƒ|jƒ|r‹dGHt||ddtƒnd GHt||ddtƒdS(NtrtrbsNeither master nor slave existssCreating missing slaveRsNot updating missing mastersMaster sis newer than slavesSlave issseconds newer than masteris#***UPDATING MASTER (BINARY COPY)***s***UPDATING MASTER***(R&tIOErrorR"tcopyRt identicaltmtimetcloseRtseekt funnycharsR(RRtsftmftsfttmfttfun((s./usr/lib64/python2.7/Tools/scripts/treesync.pyR)msP iicCsCx<|jtƒ}|jtƒ}||kr1dS|sPqqWdS(Nii(treadtBUFSIZE(R?R@tsdtmd((s./usr/lib64/python2.7/Tools/scripts/treesync.pyR:scCs tj|jƒƒ}|tjS(N(RtfstattfilenotstattST_MTIME(tftst((s./usr/lib64/python2.7/Tools/scripts/treesync.pyR;¥scCs@x9|jtƒ}|sPnd|ks4d|krdSqWdS(Ns sii(RDRE(RLtbuf((s./usr/lib64/python2.7/Tools/scripts/treesync.pyR>©sR7twbcCsˆdG|GHdG|GHtd|ƒs%dSt||ƒ}t||ƒ}x*|jtƒ}|s_Pn|j|ƒqFW|jƒ|jƒdS(Ntcopyings tosokay to copy? (RR&RDREtwriteR<(tsrctdsttrmodetwmodeRRLtgRN((s./usr/lib64/python2.7/Tools/scripts/treesync.pyR9°s cCs|jƒjƒ}|s)|ddkrYt|ƒ}|jƒjƒ}|sYt}qYn|d dkrmdS|d dkrdSdGHt|ƒS(NitnyitytnsYes or No please -- try again:(tstriptlowert raw_inputRR(tpromptR((s./usr/lib64/python2.7/Tools/scripts/treesync.pyR¾st__main__i@(t__doc__RRRJRRRRRRRR R)RER:R;R>R9Rt__name__(((s./usr/lib64/python2.7/Tools/scripts/treesync.pyts"0 . . PK!A_’±±xxci.pycnu„[µü¤ó fc@s8ddlZddlZddlTddlZdZd*Zd„Zd„Zdd d ddgZd ddddgZ ddddddddddddddgZ gZd „Zd!„Z d"„Zd#„Zd$„Zd%„Zd&„Zd'„Zed(kr4yeƒeeƒƒWq4ek r0d)GHq4XndS(+iÿÿÿÿN(t*s`iÈicCsÈtjd}|r|SdGHg}xBtjtjƒD].}t|ƒs5|jt|ƒ|fƒq5q5W|jƒ|sŒdGHtj dƒn|jƒ|j ƒx!|D]\}}|j|ƒq§W|S(Nis1No arguments, checking almost *, in "ls -t" ordersNothing to do -- exit 1(tsystargvtostlistdirtcurdirtskipfiletappendtgetmtimetsorttexittreverse(targstlisttfiletmtime((s*/usr/lib64/python2.7/Tools/scripts/xxci.pytgetargss" cCs7ytj|ƒ}|tSWntjk r2dSXdS(Niÿÿÿÿ(RtstattST_MTIMEterror(Rtst((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyR"s ttagstTAGStxyzzys nohup.outtcoret.t,t@t#so.t~s.as.os.olds.baks.origs.news.prevs.nots.pycs.fdcs.rgbs.elcs,vcCsŽtt(xtD]}tj|dƒqWxtD]}tjd|ƒq0Wytddƒ}Wntk rrdSXt|jƒjƒt(dS(NRs.xxcigntr( tbadnamestignoretbadprefixesRtbadsuffixestopentIOErrortreadtsplit(tptf((s*/usr/lib64/python2.7/Tools/scripts/xxci.pytsetup0s cCsºx$tD]}tj||ƒrdSqWytj|ƒ}Wntjk rQdSXt|tƒsfdS|ttkrzdSy2t |dƒj ttƒƒ}|tkr«dSWnnXdS(NiRi( R tfnmatchRtlstatRtS_ISREGtST_MODEtST_SIZEtMAXSIZER#R%tlent EXECMAGIC(RR'Rtdata((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyR<s$ cCs/x(tD] }|t|ƒ |krdSqWdS(Nii(R!R0(Rtbad((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyt badprefixOs cCs0x)tD]!}|t|ƒ|krdSqWdS(Nii(R"R0(RR3((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyt badsuffixTs cCstxm|D]e}|dGHt|ƒrt|ƒtd|dƒrltjd|ƒ}tjd|ƒ}qlqqWdS(Nt:s Check in s ? srcs -l sci -l (t differingt showdiffstaskyesnoRtsystem(RRtsts((s*/usr/lib64/python2.7/Tools/scripts/xxci.pytgoYs cCs+d|d|}tj|ƒ}|dkS(Nsco -p s 2>/dev/null | cmp -s - i(RR:(RtcmdR;((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyR7bscCs!d|d}tj|ƒ}dS(Nsrcsdiff s 2>&1 | ${PAGER-more}(RR:(RR=R;((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyR8gscCst|ƒ}|dkS(Ntytyes(R>R?(t raw_input(tpromptts((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyR9kst__main__s[Intr]i (RRRR*R1R/RRRR!R"R R)RR4R5R<R7R8R9t__name__tKeyboardInterrupt(((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyts4 PK!1VÍTTwin_add2path.pynu„[µü¤"""Add Python to the search path on Windows This is a simple script to add Python to the Windows search path. It modifies the current user (HKCU) tree of the registry. Copyright (c) 2008 by Christian Heimes Licensed to PSF under a Contributor Agreement. """ import sys import site import os import _winreg HKCU = _winreg.HKEY_CURRENT_USER ENV = "Environment" PATH = "PATH" DEFAULT = u"%PATH%" def modify(): pythonpath = os.path.dirname(os.path.normpath(sys.executable)) scripts = os.path.join(pythonpath, "Scripts") appdata = os.environ["APPDATA"] if hasattr(site, "USER_SITE"): userpath = site.USER_SITE.replace(appdata, "%APPDATA%") userscripts = os.path.join(userpath, "Scripts") else: userscripts = None with _winreg.CreateKey(HKCU, ENV) as key: try: envpath = _winreg.QueryValueEx(key, PATH)[0] except WindowsError: envpath = DEFAULT paths = [envpath] for path in (pythonpath, scripts, userscripts): if path and path not in envpath and os.path.isdir(path): paths.append(path) envpath = os.pathsep.join(paths) _winreg.SetValueEx(key, PATH, 0, _winreg.REG_EXPAND_SZ, envpath) return paths, envpath def main(): paths, envpath = modify() if len(paths) > 1: print "Path(s) added:" print '\n'.join(paths[1:]) else: print "No path was added" print "\nPATH is now:\n%s\n" % envpath print "Expanded:" print _winreg.ExpandEnvironmentStrings(envpath) if __name__ == '__main__': main() PK!GµTµ redemo.pynuÈ¯Ýí#! /usr/bin/python2.7 """Basic regular expression demonstration facility (Perl style syntax).""" from Tkinter import * import re class ReDemo: def __init__(self, master): self.master = master self.promptdisplay = Label(self.master, anchor=W, text="Enter a Perl-style regular expression:") self.promptdisplay.pack(side=TOP, fill=X) self.regexdisplay = Entry(self.master) self.regexdisplay.pack(fill=X) self.regexdisplay.focus_set() self.addoptions() self.statusdisplay = Label(self.master, text="", anchor=W) self.statusdisplay.pack(side=TOP, fill=X) self.labeldisplay = Label(self.master, anchor=W, text="Enter a string to search:") self.labeldisplay.pack(fill=X) self.labeldisplay.pack(fill=X) self.showframe = Frame(master) self.showframe.pack(fill=X, anchor=W) self.showvar = StringVar(master) self.showvar.set("first") self.showfirstradio = Radiobutton(self.showframe, text="Highlight first match", variable=self.showvar, value="first", command=self.recompile) self.showfirstradio.pack(side=LEFT) self.showallradio = Radiobutton(self.showframe, text="Highlight all matches", variable=self.showvar, value="all", command=self.recompile) self.showallradio.pack(side=LEFT) self.stringdisplay = Text(self.master, width=60, height=4) self.stringdisplay.pack(fill=BOTH, expand=1) self.stringdisplay.tag_configure("hit", background="yellow") self.grouplabel = Label(self.master, text="Groups:", anchor=W) self.grouplabel.pack(fill=X) self.grouplist = Listbox(self.master) self.grouplist.pack(expand=1, fill=BOTH) self.regexdisplay.bind('', self.recompile) self.stringdisplay.bind('', self.reevaluate) self.compiled = None self.recompile() btags = self.regexdisplay.bindtags() self.regexdisplay.bindtags(btags[1:] + btags[:1]) btags = self.stringdisplay.bindtags() self.stringdisplay.bindtags(btags[1:] + btags[:1]) def addoptions(self): self.frames = [] self.boxes = [] self.vars = [] for name in ('IGNORECASE', 'LOCALE', 'MULTILINE', 'DOTALL', 'VERBOSE'): if len(self.boxes) % 3 == 0: frame = Frame(self.master) frame.pack(fill=X) self.frames.append(frame) val = getattr(re, name) var = IntVar() box = Checkbutton(frame, variable=var, text=name, offvalue=0, onvalue=val, command=self.recompile) box.pack(side=LEFT) self.boxes.append(box) self.vars.append(var) def getflags(self): flags = 0 for var in self.vars: flags = flags | var.get() flags = flags return flags def recompile(self, event=None): try: self.compiled = re.compile(self.regexdisplay.get(), self.getflags()) bg = self.promptdisplay['background'] self.statusdisplay.config(text="", background=bg) except re.error, msg: self.compiled = None self.statusdisplay.config( text="re.error: %s" % str(msg), background="red") self.reevaluate() def reevaluate(self, event=None): try: self.stringdisplay.tag_remove("hit", "1.0", END) except TclError: pass try: self.stringdisplay.tag_remove("hit0", "1.0", END) except TclError: pass self.grouplist.delete(0, END) if not self.compiled: return self.stringdisplay.tag_configure("hit", background="yellow") self.stringdisplay.tag_configure("hit0", background="orange") text = self.stringdisplay.get("1.0", END) last = 0 nmatches = 0 while last <= len(text): m = self.compiled.search(text, last) if m is None: break first, last = m.span() if last == first: last = first+1 tag = "hit0" else: tag = "hit" pfirst = "1.0 + %d chars" % first plast = "1.0 + %d chars" % last self.stringdisplay.tag_add(tag, pfirst, plast) if nmatches == 0: self.stringdisplay.yview_pickplace(pfirst) groups = list(m.groups()) groups.insert(0, m.group()) for i in range(len(groups)): g = "%2d: %r" % (i, groups[i]) self.grouplist.insert(END, g) nmatches = nmatches + 1 if self.showvar.get() == "first": break if nmatches == 0: self.statusdisplay.config(text="(no match)", background="yellow") else: self.statusdisplay.config(text="") # Main function, run when invoked as a stand-alone Python program. def main(): root = Tk() demo = ReDemo(root) root.protocol('WM_DELETE_WINDOW', root.quit) root.mainloop() if __name__ == '__main__': main() PK!C;™¿¿ fixheader.pycnu„[µü¤ó fc@s8ddlZd„Zd„Zedkr4eƒndS(iÿÿÿÿNcCs,tjd}x|D]}t|ƒqWdS(Ni(tsystargvtprocess(targstfilename((s//usr/lib64/python2.7/Tools/scripts/fixheader.pytmains cCs•yt|dƒ}Wn4tk rI}tjjd|t|ƒfƒdSX|jƒ}|jƒ|d dkrˆtjjd|ƒdSyt|dƒ}Wn4tk rÑ}tjjd|t|ƒfƒdSXtjjd|ƒd }xI|D]A}t|ƒd kr*|j ƒr*||j ƒ}qó|d}qóW|t_dG|GHd G|GHdGHdGHdGHH|j|ƒHdGHdGHdGHdGd|GdGHdS(Ntrs%s: can't open: %s is/*s!%s does not begin with C comment tws%s: can't write: %s sProcessing %s ... tPy_i€t_s#ifndefs#defines#ifdef __cplusplussextern "C" {s#endift}s #endif /*t!s*/(topentIOErrorRtstderrtwritetstrtreadtclosetordtisalnumtuppertstdout(Rtftmsgtdatatmagictc((s//usr/lib64/python2.7/Tools/scripts/fixheader.pyRsD t__main__(RRRt__name__(((s//usr/lib64/python2.7/Tools/scripts/fixheader.pyts $PK!1"væþþpathfix.pyonu„[µü¤ó fc@s´ddlZddlZddlZddlTddlZejjZeZej jZ dad„Z ejdƒZd„Zd„Zd„Zd„Zed kr°e ƒndS( iÿÿÿÿN(t*cCspdtjd}y#tjtjddƒ\}}Wn;tjk rq}t|dƒt|ƒtjdƒnXx)|D]!\}}|dkry|aqyqyWts¼tddks¼|ràtd ƒt|ƒtjdƒnd}xv|D]n}tjj |ƒrt |ƒr[d}q[qítjj|ƒrFt|d ƒd}qít|ƒríd}qíqíWtj|ƒdS(Ns0usage: %s -i /interpreter file-or-directory ... iisi:s is-it/s'-i option or file-or-directory missing s": will not process symbolic links ( tsystargvtgetoptterrorterrtexittnew_interpretertostpathtisdirtrecursedowntislinktfix(tusagetoptstargstmsgtotatbadtarg((s-/usr/lib64/python2.7/Tools/scripts/pathfix.pytmain"s4# s^[a-zA-Z0-9_]+\.py$cCstj|ƒdkS(Ni(tispythonprogtmatch(tname((s-/usr/lib64/python2.7/Tools/scripts/pathfix.pytispython?scCs1td|fƒd}ytj|ƒ}Wn+tjk rW}td||fƒdSX|jƒg}xœ|D]”}|tjtjfkr“qontjj ||ƒ}tjj |ƒr½qotjj|ƒrß|j|ƒqot |ƒrot|ƒrd}qqoqoWx#|D]}t|ƒrd}qqW|S(Nsrecursedown(%r) is%s: cannot list directory: %r i(tdbgR tlistdirRRtsorttcurdirtpardirR tjoinR RtappendRRR(tdirnameRtnamesRtsubdirsRtfullname((s-/usr/lib64/python2.7/Tools/scripts/pathfix.pyRBs0 cCs<yt|dƒ}Wn(tk r=}td||fƒdSX|jƒ}t|ƒ}||kr~t|dƒ|jƒdStjj |ƒ\}}tjj |d|ƒ}yt|dƒ}Wn2tk rö}|jƒtd||fƒdSXt|dƒ|j|ƒd} x*|j| ƒ} | s4Pn|j| ƒqW|jƒ|jƒy+tj |ƒ}tj||td@ƒWn*tjk r°}td||fƒnXytj||d ƒWn*tjk rõ}td||fƒnXytj||ƒWn+tjk r7}td||fƒdSXdS(Ntrs%s: cannot open: %r is: no change t@tws%s: cannot create: %r s: updating iiiÿs%s: warning: chmod failed (%r) t~s %s: warning: backup failed (%r) s%s: rename failed (%r) ii (topentIOErrorRtreadlinetfixlinetreptcloseR R tsplitR!twritetreadtstattchmodtST_MODERtrename(tfilenametfRtlinetfixedtheadttailttempnametgtBUFSIZEtbuftstatbuf((s-/usr/lib64/python2.7/Tools/scripts/pathfix.pyRXsX cCs+|jdƒs|Sd|kr#|SdtS(Ns#!tpythons#! %s (t startswithR(R:((s-/usr/lib64/python2.7/Tools/scripts/pathfix.pyR.s t__main__(RtreR R4RtstderrR2RRtstdoutR/tNoneRRtcompileRRRRR.t__name__(((s-/usr/lib64/python2.7/Tools/scripts/pathfix.pyts 5 PK!=àÁ”” pdeps.pycnu„[µü¤ó fc@sÀddlZddlZddlZd„ZejdƒZejdƒZd„Zd„Zd„Z d„Z d „Zed kr¼yej eƒƒWq¼ek r¸ej dƒq¼XndS(iÿÿÿÿNcCs¤tjd}|sdGHdSi}x|D]}t||ƒq)WdGHt|ƒdGHt|ƒ}t|ƒdGHt|ƒ}t|ƒdGHt|ƒ}t|ƒdS( Nis usage: pdeps file.py file.py ...is--- Uses ---s--- Used By ---s--- Closure of Uses ---s--- Closure of Used By ---i(tsystargvtprocesstprintresultstinversetclosure(targsttabletargtinvtreachtinvreach((s+/usr/lib64/python2.7/Tools/scripts/pdeps.pytmains& s^[ ]*from[ ]+([^ ]+)[ ]+s^[ ]*import[ ]+([^#]+)c Csht|dƒ}tjj|ƒ}|ddkr>|d }ng||<}x|jƒ}|sePnx8|ddkrŸ|jƒ}|sŽPn|d |}qhWtj|ƒdkr×tjd \\}}\} } n:tj|ƒdkrOtjd \\}}\} } nqO|| | !j dƒ}x6|D].}|j ƒ}||kr.|j|ƒq.q.WqOWdS( Ntriýÿÿÿs.pyiÿÿÿÿs\iit,(topentostpathtbasenametreadlinetm_importtmatchtregstm_fromtsplittstriptappend( tfilenameRtfptmodtlisttlinetnextlinetatbta1tb1twordstword((s+/usr/lib64/python2.7/Tools/scripts/pdeps.pyRBs0 "" cCsÃ|jƒ}i}x|D]}||||s PK!)`%¥¥fixheader.pynuÈ¯Ýí#! /usr/bin/python2.7 # Add some standard cpp magic to a header file import sys def main(): args = sys.argv[1:] for filename in args: process(filename) def process(filename): try: f = open(filename, 'r') except IOError, msg: sys.stderr.write('%s: can\'t open: %s\n' % (filename, str(msg))) return data = f.read() f.close() if data[:2] <> '/*': sys.stderr.write('%s does not begin with C comment\n' % filename) return try: f = open(filename, 'w') except IOError, msg: sys.stderr.write('%s: can\'t write: %s\n' % (filename, str(msg))) return sys.stderr.write('Processing %s ...\n' % filename) magic = 'Py_' for c in filename: if ord(c)<=0x80 and c.isalnum(): magic = magic + c.upper() else: magic = magic + '_' sys.stdout = f print '#ifndef', magic print '#define', magic print '#ifdef __cplusplus' print 'extern "C" {' print '#endif' print f.write(data) print print '#ifdef __cplusplus' print '}' print '#endif' print '#endif /*', '!'+magic, '*/' if __name__ == '__main__': main() PK!A ¨b‘‘findlinksto.pycnu„[µü¤ó fc@s\ddlZddlZddlZddlZd„Zd„ZedkrXeƒndS(iÿÿÿÿNcCsÕyJtjtjddƒ\}}t|ƒdkrItjddƒ‚nWn9tjk r…}tjt_|GHdGHtjdƒnX|d|d}}t j |ƒ}x$|D]}tjj |t|ƒq±WdS(Nitisnot enough argumentss(usage: findlinksto pattern directory ...i(tgetopttsystargvtlentGetoptErrortNonetstderrtstdouttexittretcompiletostpathtwalktvisit(toptstargstmsgtpattdirstprogtdirname((s1/usr/lib64/python2.7/Tools/scripts/findlinksto.pytmains cCs´tjj|ƒrg|(dStjj|ƒr;dG|GHnxr|D]j}tjj||ƒ}y8tj|ƒ}|j|ƒdk r”|GdG|GHnWqBtjk r«qBXqBWdS(Nsdescend intos->( RR tislinktismounttjointreadlinktsearchRterror(RRtnamestnametlinkto((s1/usr/lib64/python2.7/Tools/scripts/findlinksto.pyRs t__main__(RRR RRRt__name__(((s1/usr/lib64/python2.7/Tools/scripts/findlinksto.pyts PK!þÞ©$YY rgrep.pyonu„[µü¤ó fc@sYdZddlZddlZddlZd„Zdd„ZedkrUeƒndS(s.Reverse grep. Usage: rgrep [-i] pattern file iÿÿÿÿNcCsAd}d}tjtjddƒ\}}x0|D](\}}|dkr2|tjB}q2q2Wt|ƒdkr}tdƒnt|ƒdkrœtd ƒn|\}}ytj||ƒ}Wn*tjk rê} td t | ƒƒnXyt |ƒ} Wn6tk r3} tdt|ƒt | ƒfdƒnX| j ddƒ| jƒ}d}xä|dkrs -PK!úYVŒŒanalyze_dxp.pyonu„[µü¤ó fc@s¾dZddlZddlZddlZddlZddlZeedƒs`edƒ‚nejƒZ ej ƒad„Zd„Z d„Zd„Zd „Zd „Zdd„ZdS(s Some helper functions to analyze the output of sys.getdxp() (which is only available if Python was built with -DDYNAMIC_EXECUTION_PROFILE). These will tell you which opcodes have been executed most frequently in the current process, and, if Python was also built with -DDXPAIRS, will tell you which instruction _pairs_ were executed most frequently, which may help in choosing new instructions. If Python was built without -DDYNAMIC_EXECUTION_PROFILE, importing this module will raise a RuntimeError. If you're running a script you want to profile, a simple way to get the common pairs is: $ PYTHONPATH=$PYTHONPATH:/Tools/scripts ./python -i -O the_script.py --args ... > from analyze_dxp import * > s = render_common_pairs() > open('/tmp/some_file', 'w').write(s) iÿÿÿÿNtgetdxpsKCan't import analyze_dxp: Python built without -DDYNAMIC_EXECUTION_PROFILE.cCs#t|ƒdko"t|dtƒS(s[Returns True if the Python that produced the argument profile was built with -DDXPAIRS.i(tlent isinstancetlist(tprofile((s1/usr/lib64/python2.7/Tools/scripts/analyze_dxp.pyt has_pairs(scCs'ttjƒtjƒaWdQXdS(s<Forgets any execution profile that has been gathered so far.N(t _profile_locktsysRt_cumulative_profile(((s1/usr/lib64/python2.7/Tools/scripts/analyze_dxp.pyt reset_profile/s cCs·t«tjƒ}t|ƒr|x‹tttƒƒD]C}x:ttt|ƒƒD]"}t||c|||7cs7ˆdkrtƒ‰n‡fd†}dj|ƒƒS(sÃRenders the most common opcode pairs to a string in order of descending frequency. The result is a series of lines of the form: # of occurrences: ('1st opname', '2nd opname') c3s3x,tˆƒD]\}}}d||fVq WdS(Ns%s: %s (R$(t_topsR(R(s1/usr/lib64/python2.7/Tools/scripts/analyze_dxp.pytseqstN(tNoneRtjoin(RR'((Rs1/usr/lib64/python2.7/Tools/scripts/analyze_dxp.pytrender_common_pairsus(t__doc__RRRRt threadingthasattrtRuntimeErrortRLockRRRRR RRR R$R)R+(((s1/usr/lib64/python2.7/Tools/scripts/analyze_dxp.pyts PK!Tƒ ^æælll.pynuÈ¯Ýí#! /usr/bin/python2.7 # Find symbolic links and show where they point to. # Arguments are directories to search; default is current directory. # No recursion. # (This is a totally different program from "findsymlinks.py"!) import sys, os def lll(dirname): for name in os.listdir(dirname): if name not in (os.curdir, os.pardir): full = os.path.join(dirname, name) if os.path.islink(full): print name, '->', os.readlink(full) def main(args): if not args: args = [os.curdir] first = 1 for arg in args: if len(args) > 1: if not first: print first = 0 print arg + ':' lll(arg) if __name__ == '__main__': main(sys.argv[1:]) PK!«qüˆˆsuff.pyonu„[µü¤ó fc@s8ddlZd„Zd„Zedkr4eƒndS(iÿÿÿÿNcCs¡tjd}i}xG|D]?}t|ƒ}|j|ƒsHg||s PK!Í—[»ëë pickle2db.pycnu„[µü¤ó fc@sBdZddlZyddlZWnek r;dZnXyddlZWnek redZnXyddlZWnek rdZnXyddlZWnek r¹dZnXddlZyddl Z Wnek rõddl Z nXejdZd„Z d„Zedkr>ejeejdƒƒndS(s, Synopsis: %(prog)s [-h|-b|-g|-r|-a|-d] [ picklefile ] dbfile Read the given picklefile as a series of key/value pairs and write to a new database. If the database already exists, any contents are deleted. The optional flags indicate the type of the output database: -a - open using anydbm -b - open as bsddb btree file -d - open as dbm file -g - open as gdbm file -h - open as bsddb hash file -r - open as bsddb recno file The default is hash. If a pickle file is named it is opened for read access. If no pickle file is named, the pickle input is read from standard input. Note that recno databases can only contain integer keys, so you can't dump a hash or btree database using db2pickle.py and reconstitute it to a recno database with %(prog)s unless your keys are integers. iÿÿÿÿNicCstjjttƒƒdS(N(tsyststderrtwritet__doc__tglobals(((s//usr/lib64/python2.7/Tools/scripts/pickle2db.pytusage4sc Cs¤y1tj|dddddddgƒ\}}Wntjk rOtƒdSXt|ƒd kstt|ƒd krtƒdSt|ƒdkr§tj}|d }nNyt|d dƒ}Wn*tk rêtjj d|d ƒdSX|d}d}xš|D]’\}}|d"krOy tj}Wq”t k rKtjj dƒdSXq|d#kry tj}Wq”t k rŒtjj dƒdSXq|d$krÑy tj}Wq”t k rÍtjj dƒdSXq|d%kry tj}Wq”t k rtjj dƒdSXq|d&krSy tj}Wq”t k rOtjj dƒdSXq|d'kry tj}Wq”t k rtjj dƒdSXqqW|dkràtdkrÔtjj dƒtjj dƒdStj}ny||dƒ}Wn9tjk r.tjj d |ƒtjj d!ƒdSXx|jƒD] }||=qs6 [PK!ªhÖ^^which.pynuÈ¯Ýí#! /usr/bin/python2.7 # Variant of "which". # On stderr, near and total misses are reported. # '-l' argument adds ls -l of each file found. import sys if sys.path[0] in (".", ""): del sys.path[0] import sys, os from stat import * def msg(str): sys.stderr.write(str + '\n') def main(): pathlist = os.environ['PATH'].split(os.pathsep) sts = 0 longlist = '' if sys.argv[1:] and sys.argv[1][:2] == '-l': longlist = sys.argv[1] del sys.argv[1] for prog in sys.argv[1:]: ident = () for dir in pathlist: filename = os.path.join(dir, prog) try: st = os.stat(filename) except os.error: continue if not S_ISREG(st[ST_MODE]): msg(filename + ': not a disk file') else: mode = S_IMODE(st[ST_MODE]) if mode & 0111: if not ident: print filename ident = st[:3] else: if st[:3] == ident: s = 'same as: ' else: s = 'also: ' msg(s + filename) else: msg(filename + ': not executable') if longlist: sts = os.system('ls ' + longlist + ' ' + filename) if sts: msg('"ls -l" exit status: ' + repr(sts)) if not ident: msg(prog + ': not found') sts = 1 sys.exit(sts) if __name__ == '__main__': main() PK!Tìááreindent-rst.pycnu„[µü¤ó fc@sJddlZddlZejd„ZedkrFejeƒƒndS(iÿÿÿÿNcCstj|dƒdS(Ni(t patchchecktnormalize_docs_whitespace(targv((s2/usr/lib64/python2.7/Tools/scripts/reindent-rst.pytmain st__main__(tsysRRRt__name__texit(((s2/usr/lib64/python2.7/Tools/scripts/reindent-rst.pytsPK! ØÉR R diff.pyonu„[µü¤ó fc@sedZddlZddlZddlZddlZddlZd„ZedkraeƒndS(sS Command line interface to difflib.py providing diffs in four formats: * ndiff: lists every line and highlights interline changes. * context: highlights clusters of changes in a before/after format. * unified: highlights clusters of changes in an inline format. * html: generates side by side comparison with change highlights. iÿÿÿÿNc Csed}tj|ƒ}|jddddtddƒ|jddddtdd ƒ|jd dddtddƒ|jddddtdd ƒ|jddddddddƒ|jƒ\}}t|ƒdkrñ|jƒtjdƒnt|ƒdkr|j dƒn|j }|\}}tjt j|ƒjƒ}tjt j|ƒjƒ}t|dƒ} | jƒ} WdQXt|dƒ} | jƒ}WdQX|jrÖtj| |||||d|ƒ}n{|jrôtj| |ƒ}n]|jr-tjƒj| |||d|jd|ƒ}n$tj| |||||d|ƒ}tjj|ƒdS(Ns&usage: %prog [options] fromfile tofiles-ctactiont store_truetdefaultthelps'Produce a context format diff (default)s-usProduce a unified format diffs-msAProduce HTML side by side diff (can use -c and -l in conjunction)s-nsProduce a ndiff format diffs-ls--linesttypetintis'Set number of context lines (default 3)iiis*need to specify both a fromfile and tofiletUtntcontexttnumlines(toptparsetOptionParsert add_optiontFalset parse_argstlent print_helptsystexitterrortlinesttimetctimetoststattst_mtimetopent readlinestutdifflibtunified_diffRtndifftmtHtmlDifft make_filetctcontext_difftstdoutt writelines( tusagetparsertoptionstargsRtfromfilettofiletfromdatettodatetft fromlinesttolinestdiff((s*/usr/lib64/python2.7/Tools/scripts/diff.pytmain s:" ' 0$t__main__(t__doc__RRRRR R3t__name__(((s*/usr/lib64/python2.7/Tools/scripts/diff.pyt s< &PK!Ä«ÁÁtexi2html.pynuÈ¯Ýí#! /usr/bin/python2.7 # Convert GNU texinfo files into HTML, one file per node. # Based on Texinfo 2.14. # Usage: texi2html [-d] [-d] [-c] inputfile outputdirectory # The input file must be a complete texinfo file, e.g. emacs.texi. # This creates many files (one per info node) in the output directory, # overwriting existing files of the same name. All files created have # ".html" as their extension. # XXX To do: # - handle @comment*** correctly # - handle @xref {some words} correctly # - handle @ftable correctly (items aren't indexed?) # - handle @itemx properly # - handle @exdent properly # - add links directly to the proper line from indices # - check against the definitive list of @-cmds; we still miss (among others): # - @defindex (hard) # - @c(omment) in the middle of a line (rarely used) # - @this* (not really needed, only used in headers anyway) # - @today{} (ever used outside title page?) # More consistent handling of chapters/sections/etc. # Lots of documentation # Many more options: # -top designate top node # -links customize which types of links are included # -split split at chapters or sections instead of nodes # -name Allow different types of filename handling. Non unix systems # will have problems with long node names # ... # Support the most recent texinfo version and take a good look at HTML 3.0 # More debugging output (customizable) and more flexible error handling # How about icons ? # rpyron 2002-05-07 # Robert Pyron # 1. BUGFIX: In function makefile(), strip blanks from the nodename. # This is necessary to match the behavior of parser.makeref() and # parser.do_node(). # 2. BUGFIX fixed KeyError in end_ifset (well, I may have just made # it go away, rather than fix it) # 3. BUGFIX allow @menu and menu items inside @ifset or @ifclear # 4. Support added for: # @uref URL reference # @image image file reference (see note below) # @multitable output an HTML table # @vtable # 5. Partial support for accents, to match MAKEINFO output # 6. I added a new command-line option, '-H basename', to specify # HTML Help output. This will cause three files to be created # in the current directory: # `basename`.hhp HTML Help Workshop project file # `basename`.hhc Contents file for the project # `basename`.hhk Index file for the project # When fed into HTML Help Workshop, the resulting file will be # named `basename`.chm. # 7. A new class, HTMLHelp, to accomplish item 6. # 8. Various calls to HTMLHelp functions. # A NOTE ON IMAGES: Just as 'outputdirectory' must exist before # running this program, all referenced images must already exist # in outputdirectory. import os import sys import string import re MAGIC = '\\input texinfo' cmprog = re.compile('^@([a-z]+)([ \t]|$)') # Command (line-oriented) blprog = re.compile('^[ \t]*$') # Blank line kwprog = re.compile('@[a-z]+') # Keyword (embedded, usually # with {} args) spprog = re.compile('[\n@{}&<>]') # Special characters in # running text # # menu item (Yuck!) miprog = re.compile('^\* ([^:]*):(:|[ \t]*([^\t,\n.]+)([^ \t\n]*))[ \t\n]*') # 0 1 1 2 3 34 42 0 # ----- ---------- --------- # -|----------------------------- # ----------------------------------------------------- class HTMLNode: """Some of the parser's functionality is separated into this class. A Node accumulates its contents, takes care of links to other Nodes and saves itself when it is finished and all links are resolved. """ DOCTYPE = '' type = 0 cont = '' epilogue = '\n' def __init__(self, dir, name, topname, title, next, prev, up): self.dirname = dir self.name = name if topname: self.topname = topname else: self.topname = name self.title = title self.next = next self.prev = prev self.up = up self.lines = [] def write(self, *lines): map(self.lines.append, lines) def flush(self): fp = open(self.dirname + '/' + makefile(self.name), 'w') fp.write(self.prologue) fp.write(self.text) fp.write(self.epilogue) fp.close() def link(self, label, nodename, rel=None, rev=None): if nodename: if nodename.lower() == '(dir)': addr = '../dir.html' title = '' else: addr = makefile(nodename) title = ' TITLE="%s"' % nodename self.write(label, ': ', nodename, ' \n') def finalize(self): length = len(self.lines) self.text = ''.join(self.lines) self.lines = [] self.open_links() self.output_links() self.close_links() links = ''.join(self.lines) self.lines = [] self.prologue = ( self.DOCTYPE + '\n\n' ' \n' ' ' + self.title + '\n' ' \n' ' \n' ' \n' '\n' + links) if length > 20: self.epilogue = '

\n%s\n' % links def open_links(self): self.write('

\n') def close_links(self): self.write('

\n') def output_links(self): if self.cont != self.next: self.link(' Cont', self.cont) self.link(' Next', self.next, rel='Next') self.link(' Prev', self.prev, rel='Previous') self.link(' Up', self.up, rel='Up') if self.name <> self.topname: self.link(' Top', self.topname) class HTML3Node(HTMLNode): DOCTYPE = '' def open_links(self): self.write('\n') class TexinfoParser: COPYRIGHT_SYMBOL = "©" FN_ID_PATTERN = "(%(id)s)" FN_SOURCE_PATTERN = '' \ + FN_ID_PATTERN + '' FN_TARGET_PATTERN = '' \ + FN_ID_PATTERN + '\n%(text)s

\n' FN_HEADER = '\n

\n' \ 'Footnotes\n

' Node = HTMLNode # Initialize an instance def __init__(self): self.unknown = {} # statistics about unknown @-commands self.filenames = {} # Check for identical filenames self.debugging = 0 # larger values produce more output self.print_headers = 0 # always print headers? self.nodefp = None # open file we're writing to self.nodelineno = 0 # Linenumber relative to node self.links = None # Links from current node self.savetext = None # If not None, save text head instead self.savestack = [] # If not None, save text head instead self.htmlhelp = None # html help data self.dirname = 'tmp' # directory where files are created self.includedir = '.' # directory to search @include files self.nodename = '' # name of current node self.topname = '' # name of top node (first node seen) self.title = '' # title of this whole Texinfo tree self.resetindex() # Reset all indices self.contents = [] # Reset table of contents self.numbering = [] # Reset section numbering counters self.nofill = 0 # Normal operation: fill paragraphs self.values={'html': 1} # Names that should be parsed in ifset self.stackinfo={} # Keep track of state in the stack # XXX The following should be reset per node?! self.footnotes = [] # Reset list of footnotes self.itemarg = None # Reset command used by @item self.itemnumber = None # Reset number for @item in @enumerate self.itemindex = None # Reset item index name self.node = None self.nodestack = [] self.cont = 0 self.includedepth = 0 # Set htmlhelp helper class def sethtmlhelp(self, htmlhelp): self.htmlhelp = htmlhelp # Set (output) directory name def setdirname(self, dirname): self.dirname = dirname # Set include directory name def setincludedir(self, includedir): self.includedir = includedir # Parse the contents of an entire file def parse(self, fp): line = fp.readline() lineno = 1 while line and (line[0] == '%' or blprog.match(line)): line = fp.readline() lineno = lineno + 1 if line[:len(MAGIC)] <> MAGIC: raise SyntaxError, 'file does not begin with %r' % (MAGIC,) self.parserest(fp, lineno) # Parse the contents of a file, not expecting a MAGIC header def parserest(self, fp, initial_lineno): lineno = initial_lineno self.done = 0 self.skip = 0 self.stack = [] accu = [] while not self.done: line = fp.readline() self.nodelineno = self.nodelineno + 1 if not line: if accu: if not self.skip: self.process(accu) accu = [] if initial_lineno > 0: print '*** EOF before @bye' break lineno = lineno + 1 mo = cmprog.match(line) if mo: a, b = mo.span(1) cmd = line[a:b] if cmd in ('noindent', 'refill'): accu.append(line) else: if accu: if not self.skip: self.process(accu) accu = [] self.command(line, mo) elif blprog.match(line) and \ 'format' not in self.stack and \ 'example' not in self.stack: if accu: if not self.skip: self.process(accu) if self.nofill: self.write('\n') else: self.write('

\n') accu = [] else: # Append the line including trailing \n! accu.append(line) # if self.skip: print '*** Still skipping at the end' if self.stack: print '*** Stack not empty at the end' print '***', self.stack if self.includedepth == 0: while self.nodestack: self.nodestack[-1].finalize() self.nodestack[-1].flush() del self.nodestack[-1] # Start saving text in a buffer instead of writing it to a file def startsaving(self): if self.savetext <> None: self.savestack.append(self.savetext) # print '*** Recursively saving text, expect trouble' self.savetext = '' # Return the text saved so far and start writing to file again def collectsavings(self): savetext = self.savetext if len(self.savestack) > 0: self.savetext = self.savestack[-1] del self.savestack[-1] else: self.savetext = None return savetext or '' # Write text to file, or save it in a buffer, or ignore it def write(self, *args): try: text = ''.join(args) except: print args raise TypeError if self.savetext <> None: self.savetext = self.savetext + text elif self.nodefp: self.nodefp.write(text) elif self.node: self.node.write(text) # Complete the current node -- write footnotes and close file def endnode(self): if self.savetext <> None: print '*** Still saving text at end of node' dummy = self.collectsavings() if self.footnotes: self.writefootnotes() if self.nodefp: if self.nodelineno > 20: self.write('

\n') [name, next, prev, up] = self.nodelinks[:4] self.link('Next', next) self.link('Prev', prev) self.link('Up', up) if self.nodename <> self.topname: self.link('Top', self.topname) self.write('

\n') self.write('\n') self.nodefp.close() self.nodefp = None elif self.node: if not self.cont and \ (not self.node.type or \ (self.node.next and self.node.prev and self.node.up)): self.node.finalize() self.node.flush() else: self.nodestack.append(self.node) self.node = None self.nodename = '' # Process a list of lines, expanding embedded @-commands # This mostly distinguishes between menus and normal text def process(self, accu): if self.debugging > 1: print '!'*self.debugging, 'process:', self.skip, self.stack, if accu: print accu[0][:30], if accu[0][30:] or accu[1:]: print '...', print if self.inmenu(): # XXX should be done differently for line in accu: mo = miprog.match(line) if not mo: line = line.strip() + '\n' self.expand(line) continue bgn, end = mo.span(0) a, b = mo.span(1) c, d = mo.span(2) e, f = mo.span(3) g, h = mo.span(4) label = line[a:b] nodename = line[c:d] if nodename[0] == ':': nodename = label else: nodename = line[e:f] punct = line[g:h] self.write('

', nodename, '', punct, '\n') self.htmlhelp.menuitem(nodename) self.expand(line[end:]) else: text = ''.join(accu) self.expand(text) # find 'menu' (we might be inside 'ifset' or 'ifclear') def inmenu(self): #if 'menu' in self.stack: # print 'inmenu :', self.skip, self.stack, self.stackinfo stack = self.stack while stack and stack[-1] in ('ifset','ifclear'): try: if self.stackinfo[len(stack)]: return 0 except KeyError: pass stack = stack[:-1] return (stack and stack[-1] == 'menu') # Write a string, expanding embedded @-commands def expand(self, text): stack = [] i = 0 n = len(text) while i < n: start = i mo = spprog.search(text, i) if mo: i = mo.start() else: self.write(text[start:]) break self.write(text[start:i]) c = text[i] i = i+1 if c == '\n': self.write('\n') continue if c == '<': self.write('<') continue if c == '>': self.write('>') continue if c == '&': self.write('&') continue if c == '{': stack.append('') continue if c == '}': if not stack: print '*** Unmatched }' self.write('}') continue cmd = stack[-1] del stack[-1] try: method = getattr(self, 'close_' + cmd) except AttributeError: self.unknown_close(cmd) continue method() continue if c <> '@': # Cannot happen unless spprog is changed raise RuntimeError, 'unexpected funny %r' % c start = i while i < n and text[i] in string.ascii_letters: i = i+1 if i == start: # @ plus non-letter: literal next character i = i+1 c = text[start:i] if c == ':': # `@:' means no extra space after # preceding `.', `?', `!' or `:' pass else: # `@.' means a sentence-ending period; # `@@', `@{', `@}' quote `@', `{', `}' self.write(c) continue cmd = text[start:i] if i < n and text[i] == '{': i = i+1 stack.append(cmd) try: method = getattr(self, 'open_' + cmd) except AttributeError: self.unknown_open(cmd) continue method() continue try: method = getattr(self, 'handle_' + cmd) except AttributeError: self.unknown_handle(cmd) continue method() if stack: print '*** Stack not empty at para:', stack # --- Handle unknown embedded @-commands --- def unknown_open(self, cmd): print '*** No open func for @' + cmd + '{...}' cmd = cmd + '{' self.write('@', cmd) if not self.unknown.has_key(cmd): self.unknown[cmd] = 1 else: self.unknown[cmd] = self.unknown[cmd] + 1 def unknown_close(self, cmd): print '*** No close func for @' + cmd + '{...}' cmd = '}' + cmd self.write('}') if not self.unknown.has_key(cmd): self.unknown[cmd] = 1 else: self.unknown[cmd] = self.unknown[cmd] + 1 def unknown_handle(self, cmd): print '*** No handler for @' + cmd self.write('@', cmd) if not self.unknown.has_key(cmd): self.unknown[cmd] = 1 else: self.unknown[cmd] = self.unknown[cmd] + 1 # XXX The following sections should be ordered as the texinfo docs # --- Embedded @-commands without {} argument list -- def handle_noindent(self): pass def handle_refill(self): pass # --- Include file handling --- def do_include(self, args): file = args file = os.path.join(self.includedir, file) try: fp = open(file, 'r') except IOError, msg: print '*** Can\'t open include file', repr(file) return print '!'*self.debugging, '--> file', repr(file) save_done = self.done save_skip = self.skip save_stack = self.stack self.includedepth = self.includedepth + 1 self.parserest(fp, 0) self.includedepth = self.includedepth - 1 fp.close() self.done = save_done self.skip = save_skip self.stack = save_stack print '!'*self.debugging, '<-- file', repr(file) # --- Special Insertions --- def open_dmn(self): pass def close_dmn(self): pass def open_dots(self): self.write('...') def close_dots(self): pass def open_bullet(self): pass def close_bullet(self): pass def open_TeX(self): self.write('TeX') def close_TeX(self): pass def handle_copyright(self): self.write(self.COPYRIGHT_SYMBOL) def open_copyright(self): self.write(self.COPYRIGHT_SYMBOL) def close_copyright(self): pass def open_minus(self): self.write('-') def close_minus(self): pass # --- Accents --- # rpyron 2002-05-07 # I would like to do at least as well as makeinfo when # it is producing HTML output: # # input output # @"o @"o umlaut accent # @'o 'o acute accent # @,{c} @,{c} cedilla accent # @=o @=o macron/overbar accent # @^o @^o circumflex accent # @`o `o grave accent # @~o @~o tilde accent # @dotaccent{o} @dotaccent{o} overdot accent # @H{o} @H{o} long Hungarian umlaut # @ringaccent{o} @ringaccent{o} ring accent # @tieaccent{oo} @tieaccent{oo} tie-after accent # @u{o} @u{o} breve accent # @ubaraccent{o} @ubaraccent{o} underbar accent # @udotaccent{o} @udotaccent{o} underdot accent # @v{o} @v{o} hacek or check accent # @exclamdown{} ¡ upside-down ! # @questiondown{} ¿ upside-down ? # @aa{},@AA{} å,Å a,A with circle # @ae{},@AE{} æ,Æ ae,AE ligatures # @dotless{i} @dotless{i} dotless i # @dotless{j} @dotless{j} dotless j # @l{},@L{} l/,L/ suppressed-L,l # @o{},@O{} ø,Ø O,o with slash # @oe{},@OE{} oe,OE oe,OE ligatures # @ss{} ß es-zet or sharp S # # The following character codes and approximations have been # copied from makeinfo's HTML output. def open_exclamdown(self): self.write('¡') # upside-down ! def close_exclamdown(self): pass def open_questiondown(self): self.write('¿') # upside-down ? def close_questiondown(self): pass def open_aa(self): self.write('å') # a with circle def close_aa(self): pass def open_AA(self): self.write('Å') # A with circle def close_AA(self): pass def open_ae(self): self.write('æ') # ae ligatures def close_ae(self): pass def open_AE(self): self.write('Æ') # AE ligatures def close_AE(self): pass def open_o(self): self.write('ø') # o with slash def close_o(self): pass def open_O(self): self.write('Ø') # O with slash def close_O(self): pass def open_ss(self): self.write('ß') # es-zet or sharp S def close_ss(self): pass def open_oe(self): self.write('oe') # oe ligatures def close_oe(self): pass def open_OE(self): self.write('OE') # OE ligatures def close_OE(self): pass def open_l(self): self.write('l/') # suppressed-l def close_l(self): pass def open_L(self): self.write('L/') # suppressed-L def close_L(self): pass # --- Special Glyphs for Examples --- def open_result(self): self.write('=>') def close_result(self): pass def open_expansion(self): self.write('==>') def close_expansion(self): pass def open_print(self): self.write('-|') def close_print(self): pass def open_error(self): self.write('error-->') def close_error(self): pass def open_equiv(self): self.write('==') def close_equiv(self): pass def open_point(self): self.write('-!-') def close_point(self): pass # --- Cross References --- def open_pxref(self): self.write('see ') self.startsaving() def close_pxref(self): self.makeref() def open_xref(self): self.write('See ') self.startsaving() def close_xref(self): self.makeref() def open_ref(self): self.startsaving() def close_ref(self): self.makeref() def open_inforef(self): self.write('See info file ') self.startsaving() def close_inforef(self): text = self.collectsavings() args = [s.strip() for s in text.split(',')] while len(args) < 3: args.append('') node = args[0] file = args[2] self.write('`', file, '\', node `', node, '\'') def makeref(self): text = self.collectsavings() args = [s.strip() for s in text.split(',')] while len(args) < 5: args.append('') nodename = label = args[0] if args[2]: label = args[2] file = args[3] title = args[4] href = makefile(nodename) if file: href = '../' + file + '/' + href self.write('', label, '') # rpyron 2002-05-07 uref support def open_uref(self): self.startsaving() def close_uref(self): text = self.collectsavings() args = [s.strip() for s in text.split(',')] while len(args) < 2: args.append('') href = args[0] label = args[1] if not label: label = href self.write('', label, '') # rpyron 2002-05-07 image support # GNU makeinfo producing HTML output tries `filename.png'; if # that does not exist, it tries `filename.jpg'. If that does # not exist either, it complains. GNU makeinfo does not handle # GIF files; however, I include GIF support here because # MySQL documentation uses GIF files. def open_image(self): self.startsaving() def close_image(self): self.makeimage() def makeimage(self): text = self.collectsavings() args = [s.strip() for s in text.split(',')] while len(args) < 5: args.append('') filename = args[0] width = args[1] height = args[2] alt = args[3] ext = args[4] # The HTML output will have a reference to the image # that is relative to the HTML output directory, # which is what 'filename' gives us. However, we need # to find it relative to our own current directory, # so we construct 'imagename'. imagelocation = self.dirname + '/' + filename if os.path.exists(imagelocation+'.png'): filename += '.png' elif os.path.exists(imagelocation+'.jpg'): filename += '.jpg' elif os.path.exists(imagelocation+'.gif'): # MySQL uses GIF files filename += '.gif' else: print "*** Cannot find image " + imagelocation #TODO: what is 'ext'? self.write('

' ) self.htmlhelp.addimage(imagelocation) # --- Marking Words and Phrases --- # --- Other @xxx{...} commands --- def open_(self): pass # Used by {text enclosed in braces} def close_(self): pass open_asis = open_ close_asis = close_ def open_cite(self): self.write('') def close_cite(self): self.write('') def open_code(self): self.write('

')
    def close_code(self): self.write('

') def open_t(self): self.write('') def close_t(self): self.write('') def open_dfn(self): self.write('') def close_dfn(self): self.write('') def open_emph(self): self.write('') def close_emph(self): self.write('') def open_i(self): self.write('') def close_i(self): self.write('') def open_footnote(self): # if self.savetext <> None: # print '*** Recursive footnote -- expect weirdness' id = len(self.footnotes) + 1 self.write(self.FN_SOURCE_PATTERN % {'id': repr(id)}) self.startsaving() def close_footnote(self): id = len(self.footnotes) + 1 self.footnotes.append((id, self.collectsavings())) def writefootnotes(self): self.write(self.FN_HEADER) for id, text in self.footnotes: self.write(self.FN_TARGET_PATTERN % {'id': repr(id), 'text': text}) self.footnotes = [] def open_file(self): self.write('

')
    def close_file(self): self.write('

') def open_kbd(self): self.write('') def close_kbd(self): self.write('') def open_key(self): self.write('') def close_key(self): self.write('') def open_r(self): self.write('') def close_r(self): self.write('') def open_samp(self): self.write('`') def close_samp(self): self.write('\'') def open_sc(self): self.write('') def close_sc(self): self.write('') def open_strong(self): self.write('') def close_strong(self): self.write('') def open_b(self): self.write('') def close_b(self): self.write('') def open_var(self): self.write('') def close_var(self): self.write('') def open_w(self): self.write('') def close_w(self): self.write('') def open_url(self): self.startsaving() def close_url(self): text = self.collectsavings() self.write('', text, '') def open_email(self): self.startsaving() def close_email(self): text = self.collectsavings() self.write('', text, '') open_titlefont = open_ close_titlefont = close_ def open_small(self): pass def close_small(self): pass def command(self, line, mo): a, b = mo.span(1) cmd = line[a:b] args = line[b:].strip() if self.debugging > 1: print '!'*self.debugging, 'command:', self.skip, self.stack, \ '@' + cmd, args try: func = getattr(self, 'do_' + cmd) except AttributeError: try: func = getattr(self, 'bgn_' + cmd) except AttributeError: # don't complain if we are skipping anyway if not self.skip: self.unknown_cmd(cmd, args) return self.stack.append(cmd) func(args) return if not self.skip or cmd == 'end': func(args) def unknown_cmd(self, cmd, args): print '*** unknown', '@' + cmd, args if not self.unknown.has_key(cmd): self.unknown[cmd] = 1 else: self.unknown[cmd] = self.unknown[cmd] + 1 def do_end(self, args): words = args.split() if not words: print '*** @end w/o args' else: cmd = words[0] if not self.stack or self.stack[-1] <> cmd: print '*** @end', cmd, 'unexpected' else: del self.stack[-1] try: func = getattr(self, 'end_' + cmd) except AttributeError: self.unknown_end(cmd) return func() def unknown_end(self, cmd): cmd = 'end ' + cmd print '*** unknown', '@' + cmd if not self.unknown.has_key(cmd): self.unknown[cmd] = 1 else: self.unknown[cmd] = self.unknown[cmd] + 1 # --- Comments --- def do_comment(self, args): pass do_c = do_comment # --- Conditional processing --- def bgn_ifinfo(self, args): pass def end_ifinfo(self): pass def bgn_iftex(self, args): self.skip = self.skip + 1 def end_iftex(self): self.skip = self.skip - 1 def bgn_ignore(self, args): self.skip = self.skip + 1 def end_ignore(self): self.skip = self.skip - 1 def bgn_tex(self, args): self.skip = self.skip + 1 def end_tex(self): self.skip = self.skip - 1 def do_set(self, args): fields = args.split(' ') key = fields[0] if len(fields) == 1: value = 1 else: value = ' '.join(fields[1:]) self.values[key] = value def do_clear(self, args): self.values[args] = None def bgn_ifset(self, args): if args not in self.values.keys() \ or self.values[args] is None: self.skip = self.skip + 1 self.stackinfo[len(self.stack)] = 1 else: self.stackinfo[len(self.stack)] = 0 def end_ifset(self): try: if self.stackinfo[len(self.stack) + 1]: self.skip = self.skip - 1 del self.stackinfo[len(self.stack) + 1] except KeyError: print '*** end_ifset: KeyError :', len(self.stack) + 1 def bgn_ifclear(self, args): if args in self.values.keys() \ and self.values[args] is not None: self.skip = self.skip + 1 self.stackinfo[len(self.stack)] = 1 else: self.stackinfo[len(self.stack)] = 0 def end_ifclear(self): try: if self.stackinfo[len(self.stack) + 1]: self.skip = self.skip - 1 del self.stackinfo[len(self.stack) + 1] except KeyError: print '*** end_ifclear: KeyError :', len(self.stack) + 1 def open_value(self): self.startsaving() def close_value(self): key = self.collectsavings() if key in self.values.keys(): self.write(self.values[key]) else: print '*** Undefined value: ', key # --- Beginning a file --- do_finalout = do_comment do_setchapternewpage = do_comment do_setfilename = do_comment def do_settitle(self, args): self.startsaving() self.expand(args) self.title = self.collectsavings() def do_parskip(self, args): pass # --- Ending a file --- def do_bye(self, args): self.endnode() self.done = 1 # --- Title page --- def bgn_titlepage(self, args): self.skip = self.skip + 1 def end_titlepage(self): self.skip = self.skip - 1 def do_shorttitlepage(self, args): pass def do_center(self, args): # Actually not used outside title page... self.write('

') self.expand(args) self.write('

\n') do_title = do_center do_subtitle = do_center do_author = do_center do_vskip = do_comment do_vfill = do_comment do_smallbook = do_comment do_paragraphindent = do_comment do_setchapternewpage = do_comment do_headings = do_comment do_footnotestyle = do_comment do_evenheading = do_comment do_evenfooting = do_comment do_oddheading = do_comment do_oddfooting = do_comment do_everyheading = do_comment do_everyfooting = do_comment # --- Nodes --- def do_node(self, args): self.endnode() self.nodelineno = 0 parts = [s.strip() for s in args.split(',')] while len(parts) < 4: parts.append('') self.nodelinks = parts [name, next, prev, up] = parts[:4] file = self.dirname + '/' + makefile(name) if self.filenames.has_key(file): print '*** Filename already in use: ', file else: if self.debugging: print '!'*self.debugging, '--- writing', file self.filenames[file] = 1 # self.nodefp = open(file, 'w') self.nodename = name if self.cont and self.nodestack: self.nodestack[-1].cont = self.nodename if not self.topname: self.topname = name title = name if self.title: title = title + ' -- ' + self.title self.node = self.Node(self.dirname, self.nodename, self.topname, title, next, prev, up) self.htmlhelp.addnode(self.nodename,next,prev,up,file) def link(self, label, nodename): if nodename: if nodename.lower() == '(dir)': addr = '../dir.html' else: addr = makefile(nodename) self.write(label, ': ', nodename, ' \n') # --- Sectioning commands --- def popstack(self, type): if (self.node): self.node.type = type while self.nodestack: if self.nodestack[-1].type > type: self.nodestack[-1].finalize() self.nodestack[-1].flush() del self.nodestack[-1] elif self.nodestack[-1].type == type: if not self.nodestack[-1].next: self.nodestack[-1].next = self.node.name if not self.node.prev: self.node.prev = self.nodestack[-1].name self.nodestack[-1].finalize() self.nodestack[-1].flush() del self.nodestack[-1] else: if type > 1 and not self.node.up: self.node.up = self.nodestack[-1].name break def do_chapter(self, args): self.heading('H1', args, 0) self.popstack(1) def do_unnumbered(self, args): self.heading('H1', args, -1) self.popstack(1) def do_appendix(self, args): self.heading('H1', args, -1) self.popstack(1) def do_top(self, args): self.heading('H1', args, -1) def do_chapheading(self, args): self.heading('H1', args, -1) def do_majorheading(self, args): self.heading('H1', args, -1) def do_section(self, args): self.heading('H1', args, 1) self.popstack(2) def do_unnumberedsec(self, args): self.heading('H1', args, -1) self.popstack(2) def do_appendixsec(self, args): self.heading('H1', args, -1) self.popstack(2) do_appendixsection = do_appendixsec def do_heading(self, args): self.heading('H1', args, -1) def do_subsection(self, args): self.heading('H2', args, 2) self.popstack(3) def do_unnumberedsubsec(self, args): self.heading('H2', args, -1) self.popstack(3) def do_appendixsubsec(self, args): self.heading('H2', args, -1) self.popstack(3) def do_subheading(self, args): self.heading('H2', args, -1) def do_subsubsection(self, args): self.heading('H3', args, 3) self.popstack(4) def do_unnumberedsubsubsec(self, args): self.heading('H3', args, -1) self.popstack(4) def do_appendixsubsubsec(self, args): self.heading('H3', args, -1) self.popstack(4) def do_subsubheading(self, args): self.heading('H3', args, -1) def heading(self, type, args, level): if level >= 0: while len(self.numbering) <= level: self.numbering.append(0) del self.numbering[level+1:] self.numbering[level] = self.numbering[level] + 1 x = '' for i in self.numbering: x = x + repr(i) + '.' args = x + ' ' + args self.contents.append((level, args, self.nodename)) self.write('<', type, '>') self.expand(args) self.write('\n') if self.debugging or self.print_headers: print '---', args def do_contents(self, args): # pass self.listcontents('Table of Contents', 999) def do_shortcontents(self, args): pass # self.listcontents('Short Contents', 0) do_summarycontents = do_shortcontents def listcontents(self, title, maxlevel): self.write('

', title, '

\n') prevlevels.append(level) elif level < prevlevels[-1]: # might drop back multiple levels while level < prevlevels[-1]: del prevlevels[-1] self.write(' '*prevlevels[-1], '

') self.expand(title) self.write('\n') self.write('

\n' * len(prevlevels)) # --- Page lay-out --- # These commands are only meaningful in printed text def do_page(self, args): pass def do_need(self, args): pass def bgn_group(self, args): pass def end_group(self): pass # --- Line lay-out --- def do_sp(self, args): if self.nofill: self.write('\n') else: self.write('

\n') def do_hline(self, args): self.write('

') # --- Function and variable definitions --- def bgn_deffn(self, args): self.write('

') self.do_deffnx(args) def end_deffn(self): self.write('\n') def do_deffnx(self, args): self.write('

') words = splitwords(args, 2) [category, name], rest = words[:2], words[2:] self.expand('@b{%s}' % name) for word in rest: self.expand(' ' + makevar(word)) #self.expand(' -- ' + category) self.write('\n

') self.index('fn', name) def bgn_defun(self, args): self.bgn_deffn('Function ' + args) end_defun = end_deffn def do_defunx(self, args): self.do_deffnx('Function ' + args) def bgn_defmac(self, args): self.bgn_deffn('Macro ' + args) end_defmac = end_deffn def do_defmacx(self, args): self.do_deffnx('Macro ' + args) def bgn_defspec(self, args): self.bgn_deffn('{Special Form} ' + args) end_defspec = end_deffn def do_defspecx(self, args): self.do_deffnx('{Special Form} ' + args) def bgn_defvr(self, args): self.write('

') words = splitwords(args, 2) [category, name], rest = words[:2], words[2:] self.expand('@code{%s}' % name) # If there are too many arguments, show them for word in rest: self.expand(' ' + word) #self.expand(' -- ' + category) self.write('\n

') self.index('vr', name) def bgn_defvar(self, args): self.bgn_defvr('Variable ' + args) end_defvar = end_defvr def do_defvarx(self, args): self.do_defvrx('Variable ' + args) def bgn_defopt(self, args): self.bgn_defvr('{User Option} ' + args) end_defopt = end_defvr def do_defoptx(self, args): self.do_defvrx('{User Option} ' + args) # --- Ditto for typed languages --- def bgn_deftypefn(self, args): self.write('

') words = splitwords(args, 3) [category, datatype, name], rest = words[:3], words[3:] self.expand('@code{%s} @b{%s}' % (datatype, name)) for word in rest: self.expand(' ' + makevar(word)) #self.expand(' -- ' + category) self.write('\n

') self.index('fn', name) def bgn_deftypefun(self, args): self.bgn_deftypefn('Function ' + args) end_deftypefun = end_deftypefn def do_deftypefunx(self, args): self.do_deftypefnx('Function ' + args) def bgn_deftypevr(self, args): self.write('

') words = splitwords(args, 3) [category, datatype, name], rest = words[:3], words[3:] self.expand('@code{%s} @b{%s}' % (datatype, name)) # If there are too many arguments, show them for word in rest: self.expand(' ' + word) #self.expand(' -- ' + category) self.write('\n

') self.index('fn', name) def bgn_deftypevar(self, args): self.bgn_deftypevr('Variable ' + args) end_deftypevar = end_deftypevr def do_deftypevarx(self, args): self.do_deftypevrx('Variable ' + args) # --- Ditto for object-oriented languages --- def bgn_defcv(self, args): self.write('

') words = splitwords(args, 3) [category, classname, name], rest = words[:3], words[3:] self.expand('@b{%s}' % name) # If there are too many arguments, show them for word in rest: self.expand(' ' + word) #self.expand(' -- %s of @code{%s}' % (category, classname)) self.write('\n

') self.index('vr', '%s @r{on %s}' % (name, classname)) def bgn_defivar(self, args): self.bgn_defcv('{Instance Variable} ' + args) end_defivar = end_defcv def do_defivarx(self, args): self.do_defcvx('{Instance Variable} ' + args) def bgn_defop(self, args): self.write('

') words = splitwords(args, 3) [category, classname, name], rest = words[:3], words[3:] self.expand('@b{%s}' % name) for word in rest: self.expand(' ' + makevar(word)) #self.expand(' -- %s of @code{%s}' % (category, classname)) self.write('\n

') self.index('fn', '%s @r{on %s}' % (name, classname)) def bgn_defmethod(self, args): self.bgn_defop('Method ' + args) end_defmethod = end_defop def do_defmethodx(self, args): self.do_defopx('Method ' + args) # --- Ditto for data types --- def bgn_deftp(self, args): self.write('

') words = splitwords(args, 2) [category, name], rest = words[:2], words[2:] self.expand('@b{%s}' % name) for word in rest: self.expand(' ' + word) #self.expand(' -- ' + category) self.write('\n

') self.index('tp', name) # --- Making Lists and Tables def bgn_enumerate(self, args): if not args: self.write('

\n') self.stackinfo[len(self.stack)] = '\n' else: self.itemnumber = args self.write('

\n') self.stackinfo[len(self.stack)] = '\n' def end_enumerate(self): self.itemnumber = None self.write(self.stackinfo[len(self.stack) + 1]) del self.stackinfo[len(self.stack) + 1] def bgn_itemize(self, args): self.itemarg = args self.write('

\n') def end_itemize(self): self.itemarg = None self.write('\n') def bgn_table(self, args): self.itemarg = args self.write('

\n') def end_table(self): self.itemarg = None self.write('\n') def bgn_ftable(self, args): self.itemindex = 'fn' self.bgn_table(args) def end_ftable(self): self.itemindex = None self.end_table() def bgn_vtable(self, args): self.itemindex = 'vr' self.bgn_table(args) def end_vtable(self): self.itemindex = None self.end_table() def do_item(self, args): if self.itemindex: self.index(self.itemindex, args) if self.itemarg: if self.itemarg[0] == '@' and self.itemarg[1] and \ self.itemarg[1] in string.ascii_letters: args = self.itemarg + '{' + args + '}' else: # some other character, e.g. '-' args = self.itemarg + ' ' + args if self.itemnumber <> None: args = self.itemnumber + '. ' + args self.itemnumber = increment(self.itemnumber) if self.stack and self.stack[-1] == 'table': self.write('

') self.expand(args) self.write('\n

') elif self.stack and self.stack[-1] == 'multitable': self.write('') self.expand(args) self.write('\n\n') else: self.write('

') self.expand(args) self.write(' ') do_itemx = do_item # XXX Should suppress leading blank line # rpyron 2002-05-07 multitable support def bgn_multitable(self, args): self.itemarg = None # should be handled by columnfractions self.write('\n') def end_multitable(self): self.itemarg = None self.write('

\n
\n') def handle_columnfractions(self): # It would be better to handle this, but for now it's in the way... self.itemarg = None def handle_tab(self): self.write('\n ') # --- Enumerations, displays, quotations --- # XXX Most of these should increase the indentation somehow def bgn_quotation(self, args): self.write('

') def end_quotation(self): self.write('

\n') def bgn_example(self, args): self.nofill = self.nofill + 1 self.write('

')
    def end_example(self):
        self.write('

\n') self.nofill = self.nofill - 1 bgn_lisp = bgn_example # Synonym when contents are executable lisp code end_lisp = end_example bgn_smallexample = bgn_example # XXX Should use smaller font end_smallexample = end_example bgn_smalllisp = bgn_lisp # Ditto end_smalllisp = end_lisp bgn_display = bgn_example end_display = end_example bgn_format = bgn_display end_format = end_display def do_exdent(self, args): self.expand(args + '\n') # XXX Should really mess with indentation def bgn_flushleft(self, args): self.nofill = self.nofill + 1 self.write('

\n')
    def end_flushleft(self):
        self.write('

\n') self.nofill = self.nofill - 1 def bgn_flushright(self, args): self.nofill = self.nofill + 1 self.write('

\n') def end_flushright(self): self.write('

\n') self.nofill = self.nofill - 1 def bgn_menu(self, args): self.write('\n') self.write(' Menu

\n') self.htmlhelp.beginmenu() def end_menu(self): self.write('

\n') self.htmlhelp.endmenu() def bgn_cartouche(self, args): pass def end_cartouche(self): pass # --- Indices --- def resetindex(self): self.noncodeindices = ['cp'] self.indextitle = {} self.indextitle['cp'] = 'Concept' self.indextitle['fn'] = 'Function' self.indextitle['ky'] = 'Keyword' self.indextitle['pg'] = 'Program' self.indextitle['tp'] = 'Type' self.indextitle['vr'] = 'Variable' # self.whichindex = {} for name in self.indextitle.keys(): self.whichindex[name] = [] def user_index(self, name, args): if self.whichindex.has_key(name): self.index(name, args) else: print '*** No index named', repr(name) def do_cindex(self, args): self.index('cp', args) def do_findex(self, args): self.index('fn', args) def do_kindex(self, args): self.index('ky', args) def do_pindex(self, args): self.index('pg', args) def do_tindex(self, args): self.index('tp', args) def do_vindex(self, args): self.index('vr', args) def index(self, name, args): self.whichindex[name].append((args, self.nodename)) self.htmlhelp.index(args, self.nodename) def do_synindex(self, args): words = args.split() if len(words) <> 2: print '*** bad @synindex', args return [old, new] = words if not self.whichindex.has_key(old) or \ not self.whichindex.has_key(new): print '*** bad key(s) in @synindex', args return if old <> new and \ self.whichindex[old] is not self.whichindex[new]: inew = self.whichindex[new] inew[len(inew):] = self.whichindex[old] self.whichindex[old] = inew do_syncodeindex = do_synindex # XXX Should use code font def do_printindex(self, args): words = args.split() for name in words: if self.whichindex.has_key(name): self.prindex(name) else: print '*** No index named', repr(name) def prindex(self, name): iscodeindex = (name not in self.noncodeindices) index = self.whichindex[name] if not index: return if self.debugging: print '!'*self.debugging, '--- Generating', \ self.indextitle[name], 'index' # The node already provides a title index1 = [] junkprog = re.compile('^(@[a-z]+)?{') for key, node in index: sortkey = key.lower() # Remove leading `@cmd{' from sort key # -- don't bother about the matching `}' oldsortkey = sortkey while 1: mo = junkprog.match(sortkey) if not mo: break i = mo.end() sortkey = sortkey[i:] index1.append((sortkey, key, node)) del index[:] index1.sort() self.write('

') if iscodeindex: key = '@code{' + key + '}' if key != prevkey: self.expand(key) self.write('\n: %s\n' % (makefile(node), node)) prevkey, prevnode = key, node self.write('

\n') # --- Final error reports --- def report(self): if self.unknown: print '--- Unrecognized commands ---' cmds = self.unknown.keys() cmds.sort() for cmd in cmds: print cmd.ljust(20), self.unknown[cmd] class TexinfoParserHTML3(TexinfoParser): COPYRIGHT_SYMBOL = "©" FN_ID_PATTERN = "[%(id)s]" FN_SOURCE_PATTERN = '' + FN_ID_PATTERN + '' FN_TARGET_PATTERN = '\n' \ '

' + FN_ID_PATTERN \ + '\n%(text)s

\n' FN_HEADER = '

\n' \ ' Footnotes\n

\n' Node = HTML3Node def bgn_quotation(self, args): self.write('') def end_quotation(self): self.write('\n') def bgn_example(self, args): # this use of would not be legal in HTML 2.0, # but is in more recent DTDs. self.nofill = self.nofill + 1 self.write('

')
    def end_example(self):
        self.write("

\n")
        self.nofill = self.nofill - 1

    def bgn_flushleft(self, args):
        self.nofill = self.nofill + 1
        self.write('\n')

    def bgn_flushright(self, args):
        self.nofill = self.nofill + 1
        self.write('\n')
    def end_flushright(self):
        self.write('\n')
        self.nofill = self.nofill - 1

    def bgn_menu(self, args):
        self.write('\n')
        self.write('  Menu\n')
    def end_menu(self):
        self.write('\n')


# rpyron 2002-05-07
class HTMLHelp:
    """
    This class encapsulates support for HTML Help. Node names,
    file names, menu items, index items, and image file names are
    accumulated until a call to finalize(). At that time, three
    output files are created in the current directory:

        `helpbase`.hhp  is a HTML Help Workshop project file.
                        It contains various information, some of
                        which I do not understand; I just copied
                        the default project info from a fresh
                        installation.
        `helpbase`.hhc  is the Contents file for the project.
        `helpbase`.hhk  is the Index file for the project.

    When these files are used as input to HTML Help Workshop,
    the resulting file will be named:

        `helpbase`.chm

    If none of the defaults in `helpbase`.hhp are changed,
    the .CHM file will have Contents, Index, Search, and
    Favorites tabs.
    """

    codeprog = re.compile('@code{(.*?)}')

    def __init__(self,helpbase,dirname):
        self.helpbase    = helpbase
        self.dirname     = dirname
        self.projectfile = None
        self.contentfile = None
        self.indexfile   = None
        self.nodelist    = []
        self.nodenames   = {}         # nodename : index
        self.nodeindex   = {}
        self.filenames   = {}         # filename : filename
        self.indexlist   = []         # (args,nodename) == (key,location)
        self.current     = ''
        self.menudict    = {}
        self.dumped      = {}


    def addnode(self,name,next,prev,up,filename):
        node = (name,next,prev,up,filename)
        # add this file to dict
        # retrieve list with self.filenames.values()
        self.filenames[filename] = filename
        # add this node to nodelist
        self.nodeindex[name] = len(self.nodelist)
        self.nodelist.append(node)
        # set 'current' for menu items
        self.current = name
        self.menudict[self.current] = []

    def menuitem(self,nodename):
        menu = self.menudict[self.current]
        menu.append(nodename)


    def addimage(self,imagename):
        self.filenames[imagename] = imagename

    def index(self, args, nodename):
        self.indexlist.append((args,nodename))

    def beginmenu(self):
        pass

    def endmenu(self):
        pass

    def finalize(self):
        if not self.helpbase:
            return

        # generate interesting filenames
        resultfile   = self.helpbase + '.chm'
        projectfile  = self.helpbase + '.hhp'
        contentfile  = self.helpbase + '.hhc'
        indexfile    = self.helpbase + '.hhk'

        # generate a reasonable title
        title        = self.helpbase

        # get the default topic file
        (topname,topnext,topprev,topup,topfile) = self.nodelist[0]
        defaulttopic = topfile

        # PROJECT FILE
        try:
            fp = open(projectfile,'w')
            print>>fp, '[OPTIONS]'
            print>>fp, 'Auto Index=Yes'
            print>>fp, 'Binary TOC=No'
            print>>fp, 'Binary Index=Yes'
            print>>fp, 'Compatibility=1.1'
            print>>fp, 'Compiled file=' + resultfile + ''
            print>>fp, 'Contents file=' + contentfile + ''
            print>>fp, 'Default topic=' + defaulttopic + ''
            print>>fp, 'Error log file=ErrorLog.log'
            print>>fp, 'Index file=' + indexfile + ''
            print>>fp, 'Title=' + title + ''
            print>>fp, 'Display compile progress=Yes'
            print>>fp, 'Full-text search=Yes'
            print>>fp, 'Default window=main'
            print>>fp, ''
            print>>fp, '[WINDOWS]'
            print>>fp, ('main=,"' + contentfile + '","' + indexfile
                        + '","","",,,,,0x23520,222,0x1046,[10,10,780,560],'
                        '0xB0000,,,,,,0')
            print>>fp, ''
            print>>fp, '[FILES]'
            print>>fp, ''
            self.dumpfiles(fp)
            fp.close()
        except IOError, msg:
            print projectfile, ':', msg
            sys.exit(1)

        # CONTENT FILE
        try:
            fp = open(contentfile,'w')
            print>>fp, ''
            print>>fp, ''
            print>>fp, ''
            print>>fp, ''
            print>>fp, ('')
            print>>fp, ''
            print>>fp, ''
            print>>fp, ''
            print>>fp, '   '
            self.dumpnodes(fp)
            print>>fp, ''
            print>>fp, ''
            fp.close()
        except IOError, msg:
            print contentfile, ':', msg
            sys.exit(1)

        # INDEX FILE
        try:
            fp = open(indexfile  ,'w')
            print>>fp, ''
            print>>fp, ''
            print>>fp, ''
            print>>fp, ''
            print>>fp, ('')
            print>>fp, ''
            print>>fp, ''
            print>>fp, ''
            print>>fp, ''
            self.dumpindex(fp)
            print>>fp, ''
            print>>fp, ''
            fp.close()
        except IOError, msg:
            print indexfile  , ':', msg
            sys.exit(1)

    def dumpfiles(self, outfile=sys.stdout):
        filelist = self.filenames.values()
        filelist.sort()
        for filename in filelist:
            print>>outfile, filename

    def dumpnodes(self, outfile=sys.stdout):
        self.dumped = {}
        if self.nodelist:
            nodename, dummy, dummy, dummy, dummy = self.nodelist[0]
            self.topnode = nodename

        print>>outfile,  ''
        for node in self.nodelist:
            self.dumpnode(node,0,outfile)
        print>>outfile,  ''

    def dumpnode(self, node, indent=0, outfile=sys.stdout):
        if node:
            # Retrieve info for this node
            (nodename,next,prev,up,filename) = node
            self.current = nodename

            # Have we been dumped already?
            if self.dumped.has_key(nodename):
                return
            self.dumped[nodename] = 1

            # Print info for this node
            print>>outfile, ' '*indent,
            print>>outfile, ''

            # Does this node have menu items?
            try:
                menu = self.menudict[nodename]
                self.dumpmenu(menu,indent+2,outfile)
            except KeyError:
                pass

    def dumpmenu(self, menu, indent=0, outfile=sys.stdout):
        if menu:
            currentnode = self.current
            if currentnode != self.topnode:    # XXX this is a hack
                print>>outfile, ' '*indent + ''
                indent += 2
            for item in menu:
                menunode = self.getnode(item)
                self.dumpnode(menunode,indent,outfile)
            if currentnode != self.topnode:    # XXX this is a hack
                print>>outfile, ' '*indent + ''
                indent -= 2

    def getnode(self, nodename):
        try:
            index = self.nodeindex[nodename]
            return self.nodelist[index]
        except KeyError:
            return None
        except IndexError:
            return None

    # (args,nodename) == (key,location)
    def dumpindex(self, outfile=sys.stdout):
        print>>outfile,  ''
        for (key,location) in self.indexlist:
            key = self.codeexpand(key)
            location = makefile(location)
            location = self.dirname + '/' + location
            print>>outfile, ''
        print>>outfile,  ''

    def codeexpand(self, line):
        co = self.codeprog.match(line)
        if not co:
            return line
        bgn, end = co.span(0)
        a, b = co.span(1)
        line = line[:bgn] + line[a:b] + line[end:]
        return line


# Put @var{} around alphabetic substrings
def makevar(str):
    return '@var{'+str+'}'


# Split a string in "words" according to findwordend
def splitwords(str, minlength):
    words = []
    i = 0
    n = len(str)
    while i < n:
        while i < n and str[i] in ' \t\n': i = i+1
        if i >= n: break
        start = i
        i = findwordend(str, i, n)
        words.append(str[start:i])
    while len(words) < minlength: words.append('')
    return words


# Find the end of a "word", matching braces and interpreting @@ @{ @}
fwprog = re.compile('[@{} ]')
def findwordend(str, i, n):
    level = 0
    while i < n:
        mo = fwprog.search(str, i)
        if not mo:
            break
        i = mo.start()
        c = str[i]; i = i+1
        if c == '@': i = i+1 # Next character is not special
        elif c == '{': level = level+1
        elif c == '}': level = level-1
        elif c == ' ' and level <= 0: return i-1
    return n


# Convert a node name into a file name
def makefile(nodename):
    nodename = nodename.strip()
    return fixfunnychars(nodename) + '.html'


# Characters that are perfectly safe in filenames and hyperlinks
goodchars = string.ascii_letters + string.digits + '!@-=+.'

# Replace characters that aren't perfectly safe by dashes
# Underscores are bad since Cern HTTPD treats them as delimiters for
# encoding times, so you get mismatches if you compress your files:
# a.html.gz will map to a_b.html.gz
def fixfunnychars(addr):
    i = 0
    while i < len(addr):
        c = addr[i]
        if c not in goodchars:
            c = '-'
            addr = addr[:i] + c + addr[i+1:]
        i = i + len(c)
    return addr


# Increment a string used as an enumeration
def increment(s):
    if not s:
        return '1'
    for sequence in string.digits, string.lowercase, string.uppercase:
        lastc = s[-1]
        if lastc in sequence:
            i = sequence.index(lastc) + 1
            if i >= len(sequence):
                if len(s) == 1:
                    s = sequence[0]*2
                    if s == '00':
                        s = '10'
                else:
                    s = increment(s[:-1]) + sequence[0]
            else:
                s = s[:-1] + sequence[i]
            return s
    return s # Don't increment


def test():
    import sys
    debugging = 0
    print_headers = 0
    cont = 0
    html3 = 0
    htmlhelp = ''

    while sys.argv[1] == ['-d']:
        debugging = debugging + 1
        del sys.argv[1]
    if sys.argv[1] == '-p':
        print_headers = 1
        del sys.argv[1]
    if sys.argv[1] == '-c':
        cont = 1
        del sys.argv[1]
    if sys.argv[1] == '-3':
        html3 = 1
        del sys.argv[1]
    if sys.argv[1] == '-H':
        helpbase = sys.argv[2]
        del sys.argv[1:3]
    if len(sys.argv) <> 3:
        print 'usage: texi2hh [-d [-d]] [-p] [-c] [-3] [-H htmlhelp]', \
              'inputfile outputdirectory'
        sys.exit(2)

    if html3:
        parser = TexinfoParserHTML3()
    else:
        parser = TexinfoParser()
    parser.cont = cont
    parser.debugging = debugging
    parser.print_headers = print_headers

    file = sys.argv[1]
    dirname  = sys.argv[2]
    parser.setdirname(dirname)
    parser.setincludedir(os.path.dirname(file))

    htmlhelp = HTMLHelp(helpbase, dirname)
    parser.sethtmlhelp(htmlhelp)

    try:
        fp = open(file, 'r')
    except IOError, msg:
        print file, ':', msg
        sys.exit(1)

    parser.parse(fp)
    fp.close()
    parser.report()

    htmlhelp.finalize()


if __name__ == "__main__":
    test()
PK!”©ü‹	‹		nm2def.pynuÈ¯Ýí#! /usr/bin/python2.7
"""nm2def.py

Helpers to extract symbols from Unix libs and auto-generate
Windows definition files from them. Depends on nm(1). Tested
on Linux and Solaris only (-p option to nm is for Solaris only).

By Marc-Andre Lemburg, Aug 1998.

Additional notes: the output of nm is supposed to look like this:

acceler.o:
000001fd T PyGrammar_AddAccelerators
         U PyGrammar_FindDFA
00000237 T PyGrammar_RemoveAccelerators
         U _IO_stderr_
         U exit
         U fprintf
         U free
         U malloc
         U printf

grammar1.o:
00000000 T PyGrammar_FindDFA
00000034 T PyGrammar_LabelRepr
         U _PyParser_TokenNames
         U abort
         U printf
         U sprintf

...

Even if this isn't the default output of your nm, there is generally an
option to produce this format (since it is the original v7 Unix format).

"""
import os, sys

PYTHONLIB = 'libpython'+sys.version[:3]+'.a'
PC_PYTHONLIB = 'Python'+sys.version[0]+sys.version[2]+'.dll'
NM = 'nm -p -g %s'                      # For Linux, use "nm -g %s"

def symbols(lib=PYTHONLIB,types=('T','C','D')):

    lines = os.popen(NM % lib).readlines()
    lines = [s.strip() for s in lines]
    symbols = {}
    for line in lines:
        if len(line) == 0 or ':' in line:
            continue
        items = line.split()
        if len(items) != 3:
            continue
        address, type, name = items
        if type not in types:
            continue
        symbols[name] = address,type
    return symbols

def export_list(symbols):

    data = []
    code = []
    for name,(addr,type) in symbols.items():
        if type in ('C','D'):
            data.append('\t'+name)
        else:
            code.append('\t'+name)
    data.sort()
    data.append('')
    code.sort()
    return ' DATA\n'.join(data)+'\n'+'\n'.join(code)

# Definition file template
DEF_TEMPLATE = """\
EXPORTS
%s
"""

# Special symbols that have to be included even though they don't
# pass the filter
SPECIALS = (
    )

def filter_Python(symbols,specials=SPECIALS):

    for name in symbols.keys():
        if name[:2] == 'Py' or name[:3] == '_Py':
            pass
        elif name not in specials:
            del symbols[name]

def main():

    s = symbols(PYTHONLIB)
    filter_Python(s)
    exports = export_list(s)
    f = sys.stdout # open('PC/python_nt.def','w')
    f.write(DEF_TEMPLATE % (exports))
    f.close()

if __name__ == '__main__':
    main()
PK!:OrG%%reindent.pycnu„[µü¤ó
fc@sÒdZdZddlZddlZddlZddlZddlZdadada	e
add„Z
d„Zd„Zd„Zd	„Zd
d„Zddd
„ƒYZd„ZedkrÎeƒndS(sAreindent [-d][-r][-v] [ path ... ]

-d (--dryrun)   Dry run.   Analyze, but don't make any changes to, files.
-r (--recurse)  Recurse.   Search for all .py files in subdirectories too.
-n (--nobackup) No backup. Does not make a ".bak" file before reindenting.
-v (--verbose)  Verbose.   Print informative msgs; else no output.
-h (--help)     Help.      Print this usage information and exit.

Change Python (.py) files to use 4-space indents and no hard tab characters.
Also trim excess spaces and tabs from ends of lines, and remove empty lines
at the end of files.  Also ensure the last line ends with a newline.

If no paths are given on the command line, reindent operates as a filter,
reading a single source file from standard input and writing the transformed
source to standard output.  In this case, the -d, -r and -v flags are
ignored.

You can pass one or more file and/or directory paths.  When a directory
path, all .py files within the directory will be examined, and, if the -r
option is given, likewise recursively for subdirectories.

If output is not to standard output, reindent overwrites files in place,
renaming the originals with a .bak extension.  If it finds nothing to
change, the file is left alone.  If reindent does change a file, the changed
file is a fixed-point for future runs (i.e., running reindent on the
resulting .py file won't change it again).

The hard part of reindenting is figuring out what to do with comment
lines.  So long as the input files get a clean bill of health from
tabnanny.py, reindent should do a good job.

The backup file is a copy of the one that is being reindented. The ".bak"
file is generated with shutil.copy(), but some corner cases regarding
user/group and permissions could leave the backup file more readable than
you'd prefer. You can always use the --nobackup option to prevent this.
t1iÿÿÿÿNicCs-|dk	rtj|IJntjtIJdS(N(tNonetsyststderrt__doc__(tmsg((s./usr/lib64/python2.7/Tools/scripts/reindent.pytusage6scGsKd}x.|D]&}tjj|t|ƒƒd}q
WtjjdƒdS(Ntt s
(RRtwritetstr(targstseptarg((s./usr/lib64/python2.7/Tools/scripts/reindent.pyterrprint;s


cCsEddl}y5|jtjdddddddgƒ\}}Wn!|jk
rd}t|ƒdSXx‹|D]ƒ\}}|dkr‘td7aql|dkrªtd7aql|dkr¿taql|dkrØt	d7a	ql|dkrltƒdSqlW|s&t
tjƒ}|jƒ|j
tjƒdSx|D]}t|ƒq-WdS(Niÿÿÿÿitdrnvhtdryruntrecursetnobackuptverbosethelps-ds--dryruns-rs	--recurses-ns
--nobackups-vs	--verboses-hs--help(s-ds--dryrun(s-rs	--recurse(s-ns
--nobackup(s-vs	--verbose(s-hs--help(tgetoptRtargvterrorRRRtFalset
makebackupRt
ReindentertstdintrunR	tstdouttcheck(RtoptsRRtotatrR
((s./usr/lib64/python2.7/Tools/scripts/reindent.pytmainBs4"


	


c	Cs6tjj|ƒrÝtjj|ƒrÝtr7dG|GHntj|ƒ}x|D]ˆ}tjj||ƒ}tr³tjj|ƒr³tjj|ƒr³tjj|ƒdj	dƒsÈ|j
ƒjdƒrMt|ƒqMqMWdStròdG|GdGnyt
|dƒ}Wn.tk
r5}td|t|ƒfƒdSXt|ƒ}|jƒ|j}t|tƒrvtd	|ƒdS|jƒr tržd
GHtrždGHqžnts|d}trátj||ƒtrád
G|GdG|GHqánt
|dƒ}|j|ƒ|jƒtrdG|GHqntStr.dGHntSdS(Nslisting directoryit.s.pytcheckings...trbs%s: I/O Error: %ss0%s: mixed newlines detected; cannot process fileschanged.s+But this is a dry run, so leaving it alone.s.baks	backed upttotwbs	wrote news
unchanged.(tostpathtisdirtislinkRtlistdirtjoinRtsplitt
startswithtlowertendswithRtopentIOErrorRR
Rtclosetnewlinest
isinstancettupleRRRtshutiltcopyfileR	tTrueR(	tfiletnamestnametfullnametfRR"tnewlinetbak((s./usr/lib64/python2.7/Tools/scripts/reindent.pyR_sZ%
 
	

cCsWd„|Dƒ}|jdƒtt|ƒƒ}|s9dSt|ƒdkrS|dS|S(NcSsXh|]N}|ddkr"dn/|ddkr8dn|ddkrNdnd’qS(iþÿÿÿs
iÿÿÿÿs
s
R((t.0tline((s./usr/lib64/python2.7/Tools/scripts/reindent.pys	”s	Rs
ii(tdiscardR8tsortedtlen(tlinesR6((s./usr/lib64/python2.7/Tools/scripts/reindent.pyt_detect_newlines“s

s
 	cCsEt|ƒ}x.|dkr<||d|kr<|d8}qW|| S(sReturn line stripped of trailing spaces, tabs, newlines.

    Note that line.rstrip() instead also strips sundry control characters,
    but at least one known Emacs user expects to keep junk like that, not
    mentioning Barry by name or anything .
    ii(RG(RDtJUNKti((s./usr/lib64/python2.7/Tools/scripts/reindent.pyt_rstrip¡s#RcBsSeZd„Zd„Zd„Zd„Zejejej	ej
ejd„ZRS(cCs¿d|_d|_|jƒ|_t|jƒ|_t|jtƒrX|jd|_n|j|_g|jD]}t	|ƒj
ƒ|j^qn|_|jjddƒd|_g|_dS(Nii(t	find_stmttlevelt	readlinestrawRIR6R7R8RARLt
expandtabsRHtinsertRtindextstats(tselfR@RD((s./usr/lib64/python2.7/Tools/scripts/reindent.pyt__init__°s		/	cCstj|j|jƒ|j}x'|rH|d|jkrH|jƒq"W|j}|jt|ƒdfƒi}g}|_	|dd}|j
|d|!ƒxftt|ƒdƒD]N}||\}}||dd}t||ƒ}	|d}
|
dkr.|	r%|j
|	dƒ}
|
dkr—xkt|dt|ƒdƒD]I}||\}}
|
dkrG|	t||ƒkrŒ|
d}
nPqGqGWn|
dkr
xgt|dddƒD]L}||\}}
|
dkrº|	t||dƒt||ƒ}
PqºqºWn|
dkr+|	}
q+q.d}
n|
dks@t‚|
||	<|
|	}|dksl|	dkrƒ|j
|||!ƒq·x|||!D]p}|dkrÚ||jkrÂ|j|ƒq|jd||ƒq‘tt|ƒ|ƒ}|j||ƒq‘Wq·W|j|j	kS(NiÿÿÿÿiiiR(ttokenizetgetlinet
tokeneaterRHRAtpopRTtappendRGtaftertextendtranget	getlspacetgettxrangetAssertionErrortminRP(RURHRTt	have2wantR\RKtthisstmtt	thisleveltnextstmtthavetwanttjtjlinetjleveltdiffRDtremove((s./usr/lib64/python2.7/Tools/scripts/reindent.pyRÍs`		

$
	

cCs|j|jƒdS(N(t
writelinesR\(RUR@((s./usr/lib64/python2.7/Tools/scripts/reindent.pyR	scCsD|jt|jƒkr!d}n|j|j}|jd7_|S(NRi(RSRGRH(RURD((s./usr/lib64/python2.7/Tools/scripts/reindent.pyRXs
	c
Csí|\}}||kr$d|_nÅ||krKd|_|jd7_nž||krrd|_|jd8_nw||	kr£|jré|jj|dfƒqénF||
kr²n7|jréd|_|ré|jj||jfƒqéndS(Niiÿÿÿÿi(RMRNRTR[(
RUttypettokent.3tendRDtINDENTtDEDENTtNEWLINEtCOMMENTtNLtslinetscol((s./usr/lib64/python2.7/Tools/scripts/reindent.pyRYs$						(
t__name__t
__module__RVRR	RXRWRtRuRvRwRxRY(((s./usr/lib64/python2.7/Tools/scripts/reindent.pyR®s		E		
cCsDdt|ƒ}}x*||kr?||dkr?|d7}qW|S(NiRi(RG(RDRKtn((s./usr/lib64/python2.7/Tools/scripts/reindent.pyR_Fst__main__((Rt__version__RWR)R9RtioRRRR;RRRRR#RRIRLRR_R{(((s./usr/lib64/python2.7/Tools/scripts/reindent.pyt(s&			4	
˜	PK!Q<`©
©

db2pickle.pyonu„[µü¤ó
fc@sBdZddlZyddlZWnek
r;dZnXyddlZWnek
redZnXyddlZWnek
rdZnXyddlZWnek
r¹dZnXddlZyddl	Z
Wnek
rõddl
Z
nXejdZd„Z
d„Zedkr>ejeejdƒƒndS(s5
Synopsis: %(prog)s [-h|-g|-b|-r|-a] dbfile [ picklefile ]

Convert the database file given on the command line to a pickle
representation.  The optional flags indicate the type of the database:

    -a - open using anydbm
    -b - open as bsddb btree file
    -d - open as dbm file
    -g - open as gdbm file
    -h - open as bsddb hash file
    -r - open as bsddb recno file

The default is hash.  If a pickle file is named it is opened for write
access (deleting any existing data).  If no pickle file is named, the pickle
output is written to standard output.

iÿÿÿÿNicCstjjttƒƒdS(N(tsyststderrtwritet__doc__tglobals(((s//usr/lib64/python2.7/Tools/scripts/db2pickle.pytusage/sc		Csy1tj|dddddddgƒ\}}Wntjk
rOtƒdSXt|ƒd	kstt|ƒd
krtƒdSt|ƒdkr§|d	}tj}nN|d	}yt|ddƒ}Wn*tk
rôtjj	d|dƒdSXd}xš|D]’\}}|d"krOy
tj}Wq”t
k
rKtjj	dƒdSXq|d#kry
tj}Wq”t
k
rŒtjj	dƒdSXq|d$krÑy
tj}Wq”t
k
rÍtjj	dƒdSXq|d%kry
tj}Wq”t
k
rtjj	dƒdSXq|d&krSy
tj}Wq”t
k
rOtjj	dƒdSXq|d'kry
tj}Wq”t
k
rtjj	dƒdSXqqW|dkràtdkrÔtjj	dƒtjj	dƒdStj}ny||dƒ}Wn9tjk
r.tjj	d |ƒtjj	d!ƒdSXx7|jƒD])}tj|||f|ddkƒqs6





		TPK! Z¸Q	Q		md5sum.pynuÈ¯Ýí#! /usr/bin/python2.7

"""Python utility to print MD5 checksums of argument files.
"""


bufsize = 8096
fnfilter = None
rmode = 'rb'

usage = """
usage: sum5 [-b] [-t] [-l] [-s bufsize] [file ...]
-b        : read files in binary mode (default)
-t        : read files in text mode (you almost certainly don't want this!)
-l        : print last pathname component only
-s bufsize: read buffer size (default %d)
file ...  : files to sum; '-' or no files means stdin
""" % bufsize

import sys
import os
import getopt
import md5

def sum(*files):
    sts = 0
    if files and isinstance(files[-1], file):
        out, files = files[-1], files[:-1]
    else:
        out = sys.stdout
    if len(files) == 1 and not isinstance(files[0], str):
        files = files[0]
    for f in files:
        if isinstance(f, str):
            if f == '-':
                sts = printsumfp(sys.stdin, '', out) or sts
            else:
                sts = printsum(f, out) or sts
        else:
            sts = sum(f, out) or sts
    return sts

def printsum(filename, out=sys.stdout):
    try:
        fp = open(filename, rmode)
    except IOError, msg:
        sys.stderr.write('%s: Can\'t open: %s\n' % (filename, msg))
        return 1
    if fnfilter:
        filename = fnfilter(filename)
    sts = printsumfp(fp, filename, out)
    fp.close()
    return sts

def printsumfp(fp, filename, out=sys.stdout):
    m = md5.new()
    try:
        while 1:
            data = fp.read(bufsize)
            if not data:
                break
            m.update(data)
    except IOError, msg:
        sys.stderr.write('%s: I/O error: %s\n' % (filename, msg))
        return 1
    out.write('%s %s\n' % (m.hexdigest(), filename))
    return 0

def main(args = sys.argv[1:], out=sys.stdout):
    global fnfilter, rmode, bufsize
    try:
        opts, args = getopt.getopt(args, 'blts:')
    except getopt.error, msg:
        sys.stderr.write('%s: %s\n%s' % (sys.argv[0], msg, usage))
        return 2
    for o, a in opts:
        if o == '-l':
            fnfilter = os.path.basename
        elif o == '-b':
            rmode = 'rb'
        elif o == '-t':
            rmode = 'r'
        elif o == '-s':
            bufsize = int(a)
    if not args:
        args = ['-']
    return sum(args, out)

if __name__ == '__main__' or __name__ == sys.argv[0]:
    sys.exit(main(sys.argv[1:], sys.stdout))
PK!!†æº™,™,reindent.pynuÈ¯Ýí#! /usr/bin/python2.7

# Released to the public domain, by Tim Peters, 03 October 2000.

"""reindent [-d][-r][-v] [ path ... ]

-d (--dryrun)   Dry run.   Analyze, but don't make any changes to, files.
-r (--recurse)  Recurse.   Search for all .py files in subdirectories too.
-n (--nobackup) No backup. Does not make a ".bak" file before reindenting.
-v (--verbose)  Verbose.   Print informative msgs; else no output.
-h (--help)     Help.      Print this usage information and exit.

Change Python (.py) files to use 4-space indents and no hard tab characters.
Also trim excess spaces and tabs from ends of lines, and remove empty lines
at the end of files.  Also ensure the last line ends with a newline.

If no paths are given on the command line, reindent operates as a filter,
reading a single source file from standard input and writing the transformed
source to standard output.  In this case, the -d, -r and -v flags are
ignored.

You can pass one or more file and/or directory paths.  When a directory
path, all .py files within the directory will be examined, and, if the -r
option is given, likewise recursively for subdirectories.

If output is not to standard output, reindent overwrites files in place,
renaming the originals with a .bak extension.  If it finds nothing to
change, the file is left alone.  If reindent does change a file, the changed
file is a fixed-point for future runs (i.e., running reindent on the
resulting .py file won't change it again).

The hard part of reindenting is figuring out what to do with comment
lines.  So long as the input files get a clean bill of health from
tabnanny.py, reindent should do a good job.

The backup file is a copy of the one that is being reindented. The ".bak"
file is generated with shutil.copy(), but some corner cases regarding
user/group and permissions could leave the backup file more readable than
you'd prefer. You can always use the --nobackup option to prevent this.
"""

__version__ = "1"

import tokenize
import os, shutil
import sys
import io

verbose    = 0
recurse    = 0
dryrun     = 0
makebackup = True

def usage(msg=None):
    if msg is not None:
        print >> sys.stderr, msg
    print >> sys.stderr, __doc__

def errprint(*args):
    sep = ""
    for arg in args:
        sys.stderr.write(sep + str(arg))
        sep = " "
    sys.stderr.write("\n")

def main():
    import getopt
    global verbose, recurse, dryrun, makebackup
    try:
        opts, args = getopt.getopt(sys.argv[1:], "drnvh",
                        ["dryrun", "recurse", "nobackup", "verbose", "help"])
    except getopt.error, msg:
        usage(msg)
        return
    for o, a in opts:
        if o in ('-d', '--dryrun'):
            dryrun += 1
        elif o in ('-r', '--recurse'):
            recurse += 1
        elif o in ('-n', '--nobackup'):
            makebackup = False
        elif o in ('-v', '--verbose'):
            verbose += 1
        elif o in ('-h', '--help'):
            usage()
            return
    if not args:
        r = Reindenter(sys.stdin)
        r.run()
        r.write(sys.stdout)
        return
    for arg in args:
        check(arg)

def check(file):
    if os.path.isdir(file) and not os.path.islink(file):
        if verbose:
            print "listing directory", file
        names = os.listdir(file)
        for name in names:
            fullname = os.path.join(file, name)
            if ((recurse and os.path.isdir(fullname) and
                 not os.path.islink(fullname) and
                 not os.path.split(fullname)[1].startswith("."))
                or name.lower().endswith(".py")):
                check(fullname)
        return

    if verbose:
        print "checking", file, "...",
    try:
        f = open(file, "rb")
    except IOError, msg:
        errprint("%s: I/O Error: %s" % (file, str(msg)))
        return

    r = Reindenter(f)
    f.close()

    newline = r.newlines
    if isinstance(newline, tuple):
        errprint("%s: mixed newlines detected; cannot process file" % file)
        return

    if r.run():
        if verbose:
            print "changed."
            if dryrun:
                print "But this is a dry run, so leaving it alone."
        if not dryrun:
            bak = file + ".bak"
            if makebackup:
                shutil.copyfile(file, bak)
                if verbose:
                    print "backed up", file, "to", bak
            f = open(file, "wb")
            r.write(f)
            f.close()
            if verbose:
                print "wrote new", file
        return True
    else:
        if verbose:
            print "unchanged."
        return False

def _detect_newlines(lines):
    newlines = {'\r\n' if line[-2:] == '\r\n' else
                '\n' if line[-1:] == '\n' else
                '\r' if line[-1:] == '\r' else
                ''
                for line in lines}
    newlines.discard('')
    newlines = tuple(sorted(newlines))
    if not newlines:
        return '\n'
    if len(newlines) == 1:
        return newlines[0]
    return newlines

def _rstrip(line, JUNK='\r\n \t'):
    """Return line stripped of trailing spaces, tabs, newlines.

    Note that line.rstrip() instead also strips sundry control characters,
    but at least one known Emacs user expects to keep junk like that, not
    mentioning Barry by name or anything .
    """

    i = len(line)
    while i > 0 and line[i-1] in JUNK:
        i -= 1
    return line[:i]

class Reindenter:

    def __init__(self, f):
        self.find_stmt = 1  # next token begins a fresh stmt?
        self.level = 0      # current indent level

        # Raw file lines.
        self.raw = f.readlines()

        # Save the newlines found in the file so they can be used to
        #  create output without mutating the newlines.
        self.newlines = _detect_newlines(self.raw)
        if isinstance(self.newlines, tuple):
            self.newline = self.newlines[0]
        else:
            self.newline = self.newlines

        # File lines, rstripped & tab-expanded.  Dummy at start is so
        # that we can use tokenize's 1-based line numbering easily.
        # Note that a line is all-blank iff it's newline.
        self.lines = [_rstrip(line).expandtabs() + self.newline
                      for line in self.raw]
        self.lines.insert(0, None)
        self.index = 1  # index into self.lines of next line

        # List of (lineno, indentlevel) pairs, one for each stmt and
        # comment line.  indentlevel is -1 for comment lines, as a
        # signal that tokenize doesn't know what to do about them;
        # indeed, they're our headache!
        self.stats = []

    def run(self):
        tokenize.tokenize(self.getline, self.tokeneater)
        # Remove trailing empty lines.
        lines = self.lines
        while lines and lines[-1] == self.newline:
            lines.pop()
        # Sentinel.
        stats = self.stats
        stats.append((len(lines), 0))
        # Map count of leading spaces to # we want.
        have2want = {}
        # Program after transformation.
        after = self.after = []
        # Copy over initial empty lines -- there's nothing to do until
        # we see a line with *something* on it.
        i = stats[0][0]
        after.extend(lines[1:i])
        for i in range(len(stats)-1):
            thisstmt, thislevel = stats[i]
            nextstmt = stats[i+1][0]
            have = getlspace(lines[thisstmt])
            want = thislevel * 4
            if want < 0:
                # A comment line.
                if have:
                    # An indented comment line.  If we saw the same
                    # indentation before, reuse what it most recently
                    # mapped to.
                    want = have2want.get(have, -1)
                    if want < 0:
                        # Then it probably belongs to the next real stmt.
                        for j in xrange(i+1, len(stats)-1):
                            jline, jlevel = stats[j]
                            if jlevel >= 0:
                                if have == getlspace(lines[jline]):
                                    want = jlevel * 4
                                break
                    if want < 0:           # Maybe it's a hanging
                                           # comment like this one,
                        # in which case we should shift it like its base
                        # line got shifted.
                        for j in xrange(i-1, -1, -1):
                            jline, jlevel = stats[j]
                            if jlevel >= 0:
                                want = have + getlspace(after[jline-1]) - \
                                       getlspace(lines[jline])
                                break
                    if want < 0:
                        # Still no luck -- leave it alone.
                        want = have
                else:
                    want = 0
            assert want >= 0
            have2want[have] = want
            diff = want - have
            if diff == 0 or have == 0:
                after.extend(lines[thisstmt:nextstmt])
            else:
                for line in lines[thisstmt:nextstmt]:
                    if diff > 0:
                        if line == self.newline:
                            after.append(line)
                        else:
                            after.append(" " * diff + line)
                    else:
                        remove = min(getlspace(line), -diff)
                        after.append(line[remove:])
        return self.raw != self.after

    def write(self, f):
        f.writelines(self.after)

    # Line-getter for tokenize.
    def getline(self):
        if self.index >= len(self.lines):
            line = ""
        else:
            line = self.lines[self.index]
            self.index += 1
        return line

    # Line-eater for tokenize.
    def tokeneater(self, type, token, (sline, scol), end, line,
                   INDENT=tokenize.INDENT,
                   DEDENT=tokenize.DEDENT,
                   NEWLINE=tokenize.NEWLINE,
                   COMMENT=tokenize.COMMENT,
                   NL=tokenize.NL):

        if type == NEWLINE:
            # A program statement, or ENDMARKER, will eventually follow,
            # after some (possibly empty) run of tokens of the form
            #     (NL | COMMENT)* (INDENT | DEDENT+)?
            self.find_stmt = 1

        elif type == INDENT:
            self.find_stmt = 1
            self.level += 1

        elif type == DEDENT:
            self.find_stmt = 1
            self.level -= 1

        elif type == COMMENT:
            if self.find_stmt:
                self.stats.append((sline, -1))
                # but we're still looking for a new stmt, so leave
                # find_stmt alone

        elif type == NL:
            pass

        elif self.find_stmt:
            # This is the first "real token" following a NEWLINE, so it
            # must be the first token of the next program statement, or an
            # ENDMARKER.
            self.find_stmt = 0
            if line:   # not endmarker
                self.stats.append((sline, self.level))

# Count number of leading blanks.
def getlspace(line):
    i, n = 0, len(line)
    while i < n and line[i] == " ":
        i += 1
    return i

if __name__ == '__main__':
    main()
PK!8ž‘»ee
md5sum.pycnu„[µü¤ó
fc@sØdZdadadadtZddlZddlZddlZddl	Z	d„Z
ejd„Zejd„Z
ejd	ejd
„Zedks±eejdkrÔejeejd	ejƒƒndS(
s9Python utility to print MD5 checksums of argument files.
i trbs?
usage: sum5 [-b] [-t] [-l] [-s bufsize] [file ...]
-b        : read files in binary mode (default)
-t        : read files in text mode (you almost certainly don't want this!)
-l        : print last pathname component only
-s bufsize: read buffer size (default %d)
file ...  : files to sum; '-' or no files means stdin
iÿÿÿÿNcGsîd}|r7t|dtƒr7|d|d }}n	tj}t|ƒdkrst|dtƒrs|d}nxt|D]l}t|tƒrÑ|dkr¹ttjd|ƒp³|}qæt||ƒpË|}qzt	||ƒpã|}qzW|S(Niiÿÿÿÿit-s(
t
isinstancetfiletsyststdouttlentstrt
printsumfptstdintprintsumtsum(tfilestststouttf((s,/usr/lib64/python2.7/Tools/scripts/md5sum.pyRs	&

cCsyyt|tƒ}Wn.tk
rC}tjjd||fƒdSXtrYt|ƒ}nt|||ƒ}|jƒ|S(Ns%s: Can't open: %s
i(	topentrmodetIOErrorRtstderrtwritetfnfilterRtclose(tfilenameRtfptmsgR
((s,/usr/lib64/python2.7/Tools/scripts/md5sum.pyR
+s
cCstjƒ}y1x*|jtƒ}|s+Pn|j|ƒqWWn.tk
rm}tjjd||fƒdSX|jd|j	ƒ|fƒdS(Ns%s: I/O error: %s
is%s %s
i(
tmd5tnewtreadtbufsizetupdateRRRRt	hexdigest(RRRtmtdataR((s,/usr/lib64/python2.7/Tools/scripts/md5sum.pyR7sicCsðytj|dƒ\}}Wn;tjk
rY}tjjdtjd|tfƒdSXxt|D]l\}}|dkrˆtjj	a
qa|dkrdaqa|dkr²d	aqa|d
krat|ƒa
qaqaW|sãdg}nt||ƒS(Nsblts:s	%s: %s
%siis-ls-bRs-ttrs-sR(tgetoptterrorRRRtargvtusagetostpathtbasenameRRtintRR(targsRtoptsRtota((s,/usr/lib64/python2.7/Tools/scripts/md5sum.pytmainEs"$		t__main__i(t__doc__RtNoneRRR&RR'R#RRRR
RR%R/t__name__texit(((s,/usr/lib64/python2.7/Tools/scripts/md5sum.pyts	
	PK!l:E
google.pycnu„[µü¤ó
fc@s;ddlZddlZd„Zedkr7eƒndS(iÿÿÿÿNcCsÁtjd}|s'dtjdGHdSg}xg|D]_}d|kr[|jddƒ}nd|krtd|}n|jddƒ}|j|ƒq4Wdj|ƒ}d|}tj|ƒdS(	NisUsage: %s querystringit+s%2Bt s"%s"s!http://www.google.com/search?q=%s(tsystargvtreplacetappendtjoint
webbrowsertopen(targstlisttargtsturl((s,/usr/lib64/python2.7/Tools/scripts/google.pytmains



t__main__(RRRt__name__(((s,/usr/lib64/python2.7/Tools/scripts/google.pyts	PK!A_’±±xxci.pyonu„[µü¤ó
fc@s8ddlZddlZddlTddlZdZd*Zd„Zd„Zdd	d
ddgZd
ddddgZ	ddddddddddddddgZ
gZd „Zd!„Z
d"„Zd#„Zd$„Zd%„Zd&„Zd'„Zed(kr4yeƒeeƒƒWq4ek
r0d)GHq4XndS(+iÿÿÿÿN(t*s`iÈicCsÈtjd}|r|SdGHg}xBtjtjƒD].}t|ƒs5|jt|ƒ|fƒq5q5W|jƒ|sŒdGHtj	dƒn|jƒ|j
ƒx!|D]\}}|j|ƒq§W|S(Nis1No arguments, checking almost *, in "ls -t" ordersNothing to do -- exit 1(tsystargvtostlistdirtcurdirtskipfiletappendtgetmtimetsorttexittreverse(targstlisttfiletmtime((s*/usr/lib64/python2.7/Tools/scripts/xxci.pytgetargss"
 


cCs7ytj|ƒ}|tSWntjk
r2dSXdS(Niÿÿÿÿ(RtstattST_MTIMEterror(Rtst((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyR"s
ttagstTAGStxyzzys	nohup.outtcoret.t,t@t#so.t~s.as.os.olds.baks.origs.news.prevs.nots.pycs.fdcs.rgbs.elcs,vcCsŽtt(xtD]}tj|dƒqWxtD]}tjd|ƒq0Wytddƒ}Wntk
rrdSXt|jƒjƒt(dS(NRs.xxcigntr(	tbadnamestignoretbadprefixesRtbadsuffixestopentIOErrortreadtsplit(tptf((s*/usr/lib64/python2.7/Tools/scripts/xxci.pytsetup0s


cCsºx$tD]}tj||ƒrdSqWytj|ƒ}Wntjk
rQdSXt|tƒsfdS|ttkrzdSy2t	|dƒj
ttƒƒ}|tkr«dSWnnXdS(NiRi(
R tfnmatchRtlstatRtS_ISREGtST_MODEtST_SIZEtMAXSIZER#R%tlent	EXECMAGIC(RR'Rtdata((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyR<s$
cCs/x(tD] }|t|ƒ |krdSqWdS(Nii(R!R0(Rtbad((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyt	badprefixOs
cCs0x)tD]!}|t|ƒ|krdSqWdS(Nii(R"R0(RR3((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyt	badsuffixTs
cCstxm|D]e}|dGHt|ƒrt|ƒtd|dƒrltjd|ƒ}tjd|ƒ}qlqqWdS(Nt:s	Check in s ? srcs -l sci -l (t	differingt	showdiffstaskyesnoRtsystem(RRtsts((s*/usr/lib64/python2.7/Tools/scripts/xxci.pytgoYs
	
cCs+d|d|}tj|ƒ}|dkS(Nsco -p s 2>/dev/null | cmp -s - i(RR:(RtcmdR;((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyR7bscCs!d|d}tj|ƒ}dS(Nsrcsdiff s 2>&1 | ${PAGER-more}(RR:(RR=R;((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyR8gscCst|ƒ}|dkS(Ntytyes(R>R?(t	raw_input(tpromptts((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyR9kst__main__s[Intr]i (RRRR*R1R/RRRR!R"R R)RR4R5R<R7R8R9t__name__tKeyboardInterrupt(((s*/usr/lib64/python2.7/Tools/scripts/xxci.pyts4
											
PK!A ¨b‘‘findlinksto.pyonu„[µü¤ó
fc@s\ddlZddlZddlZddlZd„Zd„ZedkrXeƒndS(iÿÿÿÿNcCsÕyJtjtjddƒ\}}t|ƒdkrItjddƒ‚nWn9tjk
r…}tjt_|GHdGHtjdƒnX|d|d}}t	j
|ƒ}x$|D]}tjj
|t|ƒq±WdS(Nitisnot enough argumentss(usage: findlinksto pattern directory ...i(tgetopttsystargvtlentGetoptErrortNonetstderrtstdouttexittretcompiletostpathtwalktvisit(toptstargstmsgtpattdirstprogtdirname((s1/usr/lib64/python2.7/Tools/scripts/findlinksto.pytmains
cCs´tjj|ƒrg|(dStjj|ƒr;dG|GHnxr|D]j}tjj||ƒ}y8tj|ƒ}|j|ƒdk	r”|GdG|GHnWqBtjk
r«qBXqBWdS(Nsdescend intos->(	RR
tislinktismounttjointreadlinktsearchRterror(RRtnamestnametlinkto((s1/usr/lib64/python2.7/Tools/scripts/findlinksto.pyRs
t__main__(RRR
RRRt__name__(((s1/usr/lib64/python2.7/Tools/scripts/findlinksto.pyts		PK!Qœ€Z¸ ¸ texcheck.pyonu„[µü¤ó
fc@sœdZddlZddlZddlZddlmZmZmZddlZdZ	d„Z
gd„Zdd„Z
edkr˜eje
ƒƒndS(	sá TeXcheck.py -- rough syntax checking on Python style LaTeX documents.

   Written by Raymond D. Hettinger 
   Copyright (c) 2003 Python Software Foundation.  All rights reserved.

Designed to catch common markup errors including:
* Unbalanced or mismatched parenthesis, brackets, and braces.
* Unbalanced or mismatched \begin and \end blocks.
* Misspelled or invalid LaTeX commands.
* Use of forward slashes instead of backslashes for commands.
* Table line size mismatches.

Sample command line usage:
    python texcheck.py -k chapterheading -m lib/librandomtex *.tex

Options:
    -m          Munge parenthesis and brackets. [0,n) would normally mismatch.
    -k keyword: Keyword is a valid LaTeX command. Do not include the backslash.
    -d:         Delimiter check only (useful for non-LaTeX files).
    -h:         Help
    -s lineno:  Start at lineno (useful for skipping complex sections).
    -v:         Verbose.  Trace the matching of //begin and //end blocks.
iÿÿÿÿN(tiziptcounttislicesù
    \section \module \declaremodule \modulesynopsis \moduleauthor
    \sectionauthor \versionadded \code \class \method \begin
    \optional \var \ref \end \subsection \lineiii \hline \label
    \indexii \textrm \ldots \keyword \stindex \index \item \note
    \withsubitem \ttindex \footnote \citetitle \samp \opindex
    \noindent \exception \strong \dfn \ctype \obindex \character
    \indexiii \function \bifuncindex \refmodule \refbimodindex
    \subsubsection \nodename \member \chapter \emph \ASCII \UNIX
    \regexp \program \production \token \productioncont \term
    \grammartoken \lineii \seemodule \file \EOF \documentclass
    \usepackage \title \input \maketitle \ifhtml \fi \url \Cpp
    \tableofcontents \kbd \programopt \envvar \refstmodindex
    \cfunction \constant \NULL \moreargs \cfuncline \cdata
    \textasciicircum \n \ABC \setindexsubitem \versionchanged
    \deprecated \seetext \newcommand \POSIX \pep \warning \rfc
    \verbatiminput \methodline \textgreater \seetitle \lineiv
    \funclineni \ulink \manpage \funcline \dataline \unspecified
    \textbackslash \mimetype \mailheader \seepep \textunderscore
    \longprogramopt \infinity \plusminus \shortversion \version
    \refmodindex \seerfc \makeindex \makemodindex \renewcommand
    \indexname \appendix \protect \indexiv \mbox \textasciitilde
    \platform \seeurl \leftmargin \labelwidth \localmoduletable
    \LaTeX \copyright \memberline \backslash \pi \centerline
    \caption \vspace \textwidth \menuselection \textless
    \makevar \csimplemacro \menuselection \bfcode \sub \release
    \email \kwindex \refexmodindex \filenq \e \menuselection
    \exindex \linev \newsgroup \verbatim \setshortversion
    \author \authoraddress \paragraph \subparagraph \cmemberline
    \textbar \C \seelink
cCsry|jƒ\}}Wn!tk
r9d||fGHdSX||j||gƒkrYdSd||||fGHdS(sCVerify that closing delimiter matches most recent opening delimitersU
Delimiter mismatch.  On line %d, encountered closing '%s' without corresponding openNsJ
Opener '%s' on line %d was not closed before encountering '%s' on line %d(tpopt
IndexErrortget(tc_linenotc_symboltopenerstpairmapto_linenoto_symbol((s./usr/lib64/python2.7/Tools/scripts/texcheck.pyt
matchclose?s
c#CsPtjdƒ}tjdƒ}ttjƒƒ}x|D]}|jd|ƒq7Wd|kruidd6dd6}nid	d6d
d6}tdƒ}tjdƒ}	tjdƒ}
tjd
ƒ}tjdƒ}g}
g}tjdƒ}tjdƒ}tjdƒ}d}d}t|jddƒƒ}d}xÀtt	|ƒt
||dd/ƒƒD]™\}}|jƒ}xû|	j
|ƒD]ê\}}}d|kr´|GdG|G|G|Gn|dkrâd|krâ|
j||fƒnr||kr|
j||fƒnP|dkr2d|kr2t|||
|ƒn"||krTt|||
|ƒnd|kr‚dG|
GHq‚q‚Wxv|
j
|ƒD]e\}}|dkr¨|j|ƒn|dkr€y|jƒWqåtk
rád|fGHqåXq€q€Wd|krûqZnxW|j
|ƒD]F}d |ksd!|kr/qnd||krd"||fGHqqWx)|j
|ƒD]}d#|||fGHqeW|jd$ƒ}|d%krÛ|jd|ƒ}|jd|ƒ}|j||d|!ƒnx5|j
|ƒD]$}||krëd&||fGHqëqëW|j|ƒ}|r@|jdƒ}|}n|j|ƒ}|r‹|jdƒ|kr‹d'|jdƒ|||fGHn|j|ƒr£d}nd(|ks»d)|krÊd*|fGHnx&|j
|ƒD]} d+| |fGHqÚWqZW|}!x#|
D]\}}"d,|"|fGHqWx|D]}d-|fGHq*Wd.|!fGHdS(0s¼Check the LaTeX formatting in a sequence of lines.

    Opts is a mapping of options to option values if any:
        -m          munge parenthesis and brackets
        -d          delimiters only checking
        -v          verbose trace of delimiter matching
        -s lineno:  linenumber to start scan (default is 1).

    Morecmds is a sequence of LaTeX commands (without backslashes) that
    are to be considered valid in the scan.
    s\\[A-Za-z]+s
\/([A-Za-z]+)s\s-ms[(t]s([t)t[t(s&\\(begin|end){([_a-zA-Z]+)}|([()\[\]])s({)|(})s(\b[A-za-z]+\b) \b\1\bs<\\(ABC|ASCII|C|Cpp|EOF|infinity|NULL|plusminus|POSIX|UNIX)\ss\\begin{(?:long)?table([iv]+)}s\\line([iv]+){s\\end{(?:long)?table([iv]+)}tis-st1is-vt|tbegins-dtends   --> t{t}s Warning, unmatched } on line %s.t822s.htmls4Warning, forward slash used on line %d with cmd: /%ss2Warning, \%s should be written as \%s{} on line %ds\newcommandiÿÿÿÿs(Warning, unknown tex cmd on line %d: \%ss>Warning, \line%s on line %d does not match \table%s on line %dse.g.si.e.s2Style warning, avoid use of i.e or e.g. on line %ds&Doubled word warning.  "%s" on line %ds(Unmatched open delimiter '%s' on line %dsUnmatched { on line %dsDone checking %d lines.N(tretcompiletsettcmdstrtsplittaddtintRRRRtNonetrstriptfindalltappendRRRtfindtsearchtgroup(#tsourcetoptstmorecmdsttexcmdtfalsetexcmdt	validcmdstcmdR	t	openpunctt
delimiterstbracestdoubledwordst
spacingmarkupRt
bracestackt
tablestartt	tablelinettableendt
tablelevelttablestartlinet	startlinetlinenotlinetbegendtnametpuncttopentclosetnctstartRtmtdwtlastlinetsymbol((s./usr/lib64/python2.7/Tools/scripts/texcheck.pytcheckitJs¤

2
	!	
cCs‰|dkrtjd}ntj|dƒ\}}t|ƒ}d|ksX|gkratGHdSt|ƒdkr|dGHdSxOt|ƒD]A\}}d|ksd|kr‰tj|ƒ|||d+q‰q‰Wg|D]\}}|dkrÕ|^qÕ}g}	x}|D]u}
d	d
GHdG|
GHyt	|
ƒ}Wnt
k
rOd|dGHd
SXz|	jt|||ƒƒWd|j
ƒXqWt|	ƒS(Nisk:mdhs:vs-his#Please specify a file to be checkedt*t?s-kt=itCheckingsCannot open file %s.i(R tsystargvtgetopttdictt__doc__tlent	enumeratetglobR?tIOErrorR#RGR@tmax(targstoptitemstarglistR(titfilespectktvR)terrtfilenametf((s./usr/lib64/python2.7/Tools/scripts/texcheck.pytmainÄs6!+
		

t__main__(RPRRLRNt	itertoolsRRRRSRRRGR R`t__name__texit(((s./usr/lib64/python2.7/Tools/scripts/texcheck.pyts 	z$PK!«½Æ——treesync.pynuÈ¯Ýí#! /usr/bin/python2.7

"""Script to synchronize two source trees.

Invoke with two arguments:

python treesync.py slave master

The assumption is that "master" contains CVS administration while
slave doesn't.  All files in the slave tree that have a CVS/Entries
entry in the master tree are synchronized.  This means:

    If the files differ:
        if the slave file is newer:
            normalize the slave file
            if the files still differ:
                copy the slave to the master
        else (the master is newer):
            copy the master to the slave

    normalizing the slave means replacing CRLF with LF when the master
    doesn't use CRLF

"""

import os, sys, stat, getopt

# Interactivity options
default_answer = "ask"
create_files = "yes"
create_directories = "no"
write_slave = "ask"
write_master = "ask"

def main():
    global always_no, always_yes
    global create_directories, write_master, write_slave
    opts, args = getopt.getopt(sys.argv[1:], "nym:s:d:f:a:")
    for o, a in opts:
        if o == '-y':
            default_answer = "yes"
        if o == '-n':
            default_answer = "no"
        if o == '-s':
            write_slave = a
        if o == '-m':
            write_master = a
        if o == '-d':
            create_directories = a
        if o == '-f':
            create_files = a
        if o == '-a':
            create_files = create_directories = write_slave = write_master = a
    try:
        [slave, master] = args
    except ValueError:
        print "usage: python", sys.argv[0] or "treesync.py",
        print "[-n] [-y] [-m y|n|a] [-s y|n|a] [-d y|n|a] [-f n|y|a]",
        print "slavedir masterdir"
        return
    process(slave, master)

def process(slave, master):
    cvsdir = os.path.join(master, "CVS")
    if not os.path.isdir(cvsdir):
        print "skipping master subdirectory", master
        print "-- not under CVS"
        return
    print "-"*40
    print "slave ", slave
    print "master", master
    if not os.path.isdir(slave):
        if not okay("create slave directory %s?" % slave,
                    answer=create_directories):
            print "skipping master subdirectory", master
            print "-- no corresponding slave", slave
            return
        print "creating slave directory", slave
        try:
            os.mkdir(slave)
        except os.error, msg:
            print "can't make slave directory", slave, ":", msg
            return
        else:
            print "made slave directory", slave
    cvsdir = None
    subdirs = []
    names = os.listdir(master)
    for name in names:
        mastername = os.path.join(master, name)
        slavename = os.path.join(slave, name)
        if name == "CVS":
            cvsdir = mastername
        else:
            if os.path.isdir(mastername) and not os.path.islink(mastername):
                subdirs.append((slavename, mastername))
    if cvsdir:
        entries = os.path.join(cvsdir, "Entries")
        for e in open(entries).readlines():
            words = e.split('/')
            if words[0] == '' and words[1:]:
                name = words[1]
                s = os.path.join(slave, name)
                m = os.path.join(master, name)
                compare(s, m)
    for (s, m) in subdirs:
        process(s, m)

def compare(slave, master):
    try:
        sf = open(slave, 'r')
    except IOError:
        sf = None
    try:
        mf = open(master, 'rb')
    except IOError:
        mf = None
    if not sf:
        if not mf:
            print "Neither master nor slave exists", master
            return
        print "Creating missing slave", slave
        copy(master, slave, answer=create_files)
        return
    if not mf:
        print "Not updating missing master", master
        return
    if sf and mf:
        if identical(sf, mf):
            return
    sft = mtime(sf)
    mft = mtime(mf)
    if mft > sft:
        # Master is newer -- copy master to slave
        sf.close()
        mf.close()
        print "Master             ", master
        print "is newer than slave", slave
        copy(master, slave, answer=write_slave)
        return
    # Slave is newer -- copy slave to master
    print "Slave is", sft-mft, "seconds newer than master"
    # But first check what to do about CRLF
    mf.seek(0)
    fun = funnychars(mf)
    mf.close()
    sf.close()
    if fun:
        print "***UPDATING MASTER (BINARY COPY)***"
        copy(slave, master, "rb", answer=write_master)
    else:
        print "***UPDATING MASTER***"
        copy(slave, master, "r", answer=write_master)

BUFSIZE = 16*1024

def identical(sf, mf):
    while 1:
        sd = sf.read(BUFSIZE)
        md = mf.read(BUFSIZE)
        if sd != md: return 0
        if not sd: break
    return 1

def mtime(f):
    st = os.fstat(f.fileno())
    return st[stat.ST_MTIME]

def funnychars(f):
    while 1:
        buf = f.read(BUFSIZE)
        if not buf: break
        if '\r' in buf or '\0' in buf: return 1
    return 0

def copy(src, dst, rmode="rb", wmode="wb", answer='ask'):
    print "copying", src
    print "     to", dst
    if not okay("okay to copy? ", answer):
        return
    f = open(src, rmode)
    g = open(dst, wmode)
    while 1:
        buf = f.read(BUFSIZE)
        if not buf: break
        g.write(buf)
    f.close()
    g.close()

def okay(prompt, answer='ask'):
    answer = answer.strip().lower()
    if not answer or answer[0] not in 'ny':
        answer = raw_input(prompt)
        answer = answer.strip().lower()
        if not answer:
            answer = default_answer
    if answer[:1] == 'y':
        return 1
    if answer[:1] == 'n':
        return 0
    print "Yes or No please -- try again:"
    return okay(prompt)

if __name__ == '__main__':
    main()
PK!h>ßõ11checkappend.pynuÈ¯Ýí#! /usr/bin/python2.7

# Released to the public domain, by Tim Peters, 28 February 2000.

"""checkappend.py -- search for multi-argument .append() calls.

Usage:  specify one or more file or directory paths:
    checkappend [-v] file_or_dir [file_or_dir] ...

Each file_or_dir is checked for multi-argument .append() calls.  When
a directory, all .py files in the directory, and recursively in its
subdirectories, are checked.

Use -v for status msgs.  Use -vv for more status msgs.

In the absence of -v, the only output is pairs of the form

    filename(linenumber):
    line containing the suspicious append

Note that this finds multi-argument append calls regardless of whether
they're attached to list objects.  If a module defines a class with an
append method that takes more than one argument, calls to that method
will be listed.

Note that this will not find multi-argument list.append calls made via a
bound method object.  For example, this is not caught:

    somelist = []
    push = somelist.append
    push(1, 2, 3)
"""

__version__ = 1, 0, 0

import os
import sys
import getopt
import tokenize

verbose = 0

def errprint(*args):
    msg = ' '.join(args)
    sys.stderr.write(msg)
    sys.stderr.write("\n")

def main():
    args = sys.argv[1:]
    global verbose
    try:
        opts, args = getopt.getopt(sys.argv[1:], "v")
    except getopt.error, msg:
        errprint(str(msg) + "\n\n" + __doc__)
        return
    for opt, optarg in opts:
        if opt == '-v':
            verbose = verbose + 1
    if not args:
        errprint(__doc__)
        return
    for arg in args:
        check(arg)

def check(file):
    if os.path.isdir(file) and not os.path.islink(file):
        if verbose:
            print "%r: listing directory" % (file,)
        names = os.listdir(file)
        for name in names:
            fullname = os.path.join(file, name)
            if ((os.path.isdir(fullname) and
                 not os.path.islink(fullname))
                or os.path.normcase(name[-3:]) == ".py"):
                check(fullname)
        return

    try:
        f = open(file)
    except IOError, msg:
        errprint("%r: I/O Error: %s" % (file, msg))
        return

    if verbose > 1:
        print "checking %r ..." % (file,)

    ok = AppendChecker(file, f).run()
    if verbose and ok:
        print "%r: Clean bill of health." % (file,)

[FIND_DOT,
 FIND_APPEND,
 FIND_LPAREN,
 FIND_COMMA,
 FIND_STMT]   = range(5)

class AppendChecker:
    def __init__(self, fname, file):
        self.fname = fname
        self.file = file
        self.state = FIND_DOT
        self.nerrors = 0

    def run(self):
        try:
            tokenize.tokenize(self.file.readline, self.tokeneater)
        except tokenize.TokenError, msg:
            errprint("%r: Token Error: %s" % (self.fname, msg))
            self.nerrors = self.nerrors + 1
        return self.nerrors == 0

    def tokeneater(self, type, token, start, end, line,
                NEWLINE=tokenize.NEWLINE,
                JUNK=(tokenize.COMMENT, tokenize.NL),
                OP=tokenize.OP,
                NAME=tokenize.NAME):

        state = self.state

        if type in JUNK:
            pass

        elif state is FIND_DOT:
            if type is OP and token == ".":
                state = FIND_APPEND

        elif state is FIND_APPEND:
            if type is NAME and token == "append":
                self.line = line
                self.lineno = start[0]
                state = FIND_LPAREN
            else:
                state = FIND_DOT

        elif state is FIND_LPAREN:
            if type is OP and token == "(":
                self.level = 1
                state = FIND_COMMA
            else:
                state = FIND_DOT

        elif state is FIND_COMMA:
            if type is OP:
                if token in ("(", "{", "["):
                    self.level = self.level + 1
                elif token in (")", "}", "]"):
                    self.level = self.level - 1
                    if self.level == 0:
                        state = FIND_DOT
                elif token == "," and self.level == 1:
                    self.nerrors = self.nerrors + 1
                    print "%s(%d):\n%s" % (self.fname, self.lineno,
                                           self.line)
                    # don't gripe about this stmt again
                    state = FIND_STMT

        elif state is FIND_STMT:
            if type is NEWLINE:
                state = FIND_DOT

        else:
            raise SystemError("unknown internal state '%r'" % (state,))

        self.state = state

if __name__ == '__main__':
    main()
PK!d³ºv··parseentities.pynuÈ¯Ýí#! /usr/bin/python2.7
""" Utility for parsing HTML entity definitions available from:

      http://www.w3.org/ as e.g.
      http://www.w3.org/TR/REC-html40/HTMLlat1.ent

    Input is read from stdin, output is written to stdout in form of a
    Python snippet defining a dictionary "entitydefs" mapping literal
    entity name to character or numeric entity.

    Marc-Andre Lemburg, mal@lemburg.com, 1999.
    Use as you like. NO WARRANTIES.

"""
import re,sys
import TextTools

entityRE = re.compile('')

def parse(text,pos=0,endpos=None):

    pos = 0
    if endpos is None:
        endpos = len(text)
    d = {}
    while 1:
        m = entityRE.search(text,pos,endpos)
        if not m:
            break
        name,charcode,comment = m.groups()
        d[name] = charcode,comment
        pos = m.end()
    return d

def writefile(f,defs):

    f.write("entitydefs = {\n")
    items = defs.items()
    items.sort()
    for name,(charcode,comment) in items:
        if charcode[:2] == '&#':
            code = int(charcode[2:-1])
            if code < 256:
                charcode = "'\%o'" % code
            else:
                charcode = repr(charcode)
        else:
            charcode = repr(charcode)
        comment = TextTools.collapse(comment)
        f.write("    '%s':\t%s,  \t# %s\n" % (name,charcode,comment))
    f.write('\n}\n')

if __name__ == '__main__':
    if len(sys.argv) > 1:
        infile = open(sys.argv[1])
    else:
        infile = sys.stdin
    if len(sys.argv) > 2:
        outfile = open(sys.argv[2],'w')
    else:
        outfile = sys.stdout
    text = infile.read()
    defs = parse(text)
    writefile(outfile,defs)
PK!Tìááreindent-rst.pyonu„[µü¤ó
fc@sJddlZddlZejd„ZedkrFejeƒƒndS(iÿÿÿÿNcCstj|dƒdS(Ni(t
patchchecktnormalize_docs_whitespace(targv((s2/usr/lib64/python2.7/Tools/scripts/reindent-rst.pytmain
st__main__(tsysRRRt__name__texit(((s2/usr/lib64/python2.7/Tools/scripts/reindent-rst.pytsPK!Hò9«checkpip.pycnu„[µü¤ó
fc@sYdZddlZddlZddlZddlZd„ZedkrUeƒndS(sa
Checks that the version of the projects bundled in ensurepip are the latest
versions available.
iÿÿÿÿNcCs¡t}x~tjD]s\}}tjtjdj|ƒƒjƒj	dƒƒ}|dd}||krt
}dj|||ƒGHqqW|rtjdƒndS(Ns$https://pypi.python.org/pypi/{}/jsontutf8tinfotversions<The latest version of {} on PyPI is {}, but ensurepip has {}i(
tFalset	ensurepipt	_PROJECTStjsontloadsturllib2turlopentformattreadtdecodetTruetsystexit(t	outofdatetprojectRtdatatupstream_version((s./usr/lib64/python2.7/Tools/scripts/checkpip.pytmainst__main__(t__doc__RRRRRt__name__(((s./usr/lib64/python2.7/Tools/scripts/checkpip.pyts	PK!S•;findnocoding.pyonu„[µü¤ó
fc@sùdZdZddlZddlZddlZddlZyddlZWn:ek
rˆddd„ƒYZeƒZejdIJnXej	dƒZ
ej	dƒZd	„Zd
„Z
d„Zdejd
Zy#ejejddƒ\ZZWn=ejk
r5ZejeIJejeIJejdƒnXejZeZxAeD]9\ZZedkrpejZqLedkrLeZqLqLWes¬ejeIJejdƒnxFejeeƒD]2Zer×deGHneeƒZ e r¿eGHq¿q¿WdS(s_List all those Python files that require a coding directive

Usage: nocoding.py dir1 [dir2...]
sOleg Broytmann, Georg BrandliÿÿÿÿNtpysourcecBseZdZZZd„ZRS(c	os§x |D]˜}tjj|ƒr0|jdƒVqtjj|ƒrxZtj|ƒD]F\}}}x4|D],}|jdƒrhtjj||ƒVqhqhWqRWqqWdS(Ns.py(tostpathtisfiletendswithtisdirtwalktjoin(	tselftpathstargstkwargsRtroottdirstfilestfilename((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pytwalk_python_filess

N(t__name__t
__module__tNonethas_python_exttlooks_like_pythontcan_be_compiledR(((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pyRss^The pysource module is not available; no sophisticated Python source file search will be done.s&^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)s^[ \t\f]*(?:[#\r\n]|$)cCs&tj|ƒ}|r"|jdƒSdS(Nit(tdecl_retmatchtgroup(tlineR((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pytget_declaration&s
cCs.yt||ƒWntk
r%tSXtSdS(N(tunicodetUnicodeDecodeErrortFalsetTrue(ttexttcodec((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pythas_correct_encoding,s

cCsªyt|dƒ}Wntk
r'dSX|jƒ}|jƒ}t|ƒsgtj|ƒrut|ƒru|jƒtS|j	ƒ}|jƒt
|||dƒr¦tStS(NtrUtascii(topentIOErrorRtreadlineRtblank_reRtcloseRtreadR#R (tfullpathtinfiletline1tline2trest((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pytneeds_declaration4s


sjUsage: %s [-cd] paths...
    -c: recognize Python source files trying to compile them
    -d: debug outputiitcds-cs-dsTesting for coding: %s((!t__doc__t
__author__tsysRtretgetoptRtImportErrortstderrtcompileRR)RR#R1targvtusagetoptsR
terrortmsgtexitRt	is_pythonRtdebugtotaRR RR,tresult(((s2/usr/lib64/python2.7/Tools/scripts/findnocoding.pytsH0
				#

	

PK!w/=L¬
¬

fixnotice.pyonu„[µü¤ó
fc@szdZdaddlZddlZddlZdadadadd„Zd„Z	d„Z
ed	krve	ƒndS(
sæ(Ostensibly) fix copyright notices in files.

Actually, this script will simply replace a block of text in a file from one
string to another.  It will only do this once though, i.e. not globally
throughout the file.  It writes a backup file and then does an os.rename()
dance for atomicity.

Usage: fixnotices.py [options] [filenames]
Options:
    -h / --help
        Print this message and exit

    --oldnotice=file
        Use the notice in the file as the old (to be replaced) string, instead
        of the hard coded value in the script.

    --newnotice=file
        Use the notice in the file as the new (replacement) string, instead of
        the hard coded value in the script.

    --dry-run
        Don't actually make the changes, but print out the list of files that
        would change.  When used with -v, a status will be printed for every
        file.

    -v / --verbose
        Print a message for every file looked at, indicating whether the file
        is changed or not.
s¸/***********************************************************
Copyright (c) 2000, BeOpen.com.
Copyright (c) 1995-2000, Corporation for National Research Initiatives.
Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
All rights reserved.

See the file "Misc/COPYRIGHT" for information on usage and
redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
******************************************************************/
iÿÿÿÿNticCs+ttƒGH|r|GHntj|ƒdS(N(t__doc__tglobalstsystexit(tcodetmsg((s//usr/lib64/python2.7/Tools/scripts/fixnotice.pytusage4scCs6y5tjtjdddddddgƒ\}}Wn#tjk
rZ}td|ƒnXx¹|D]±\}}|dkr‡td
ƒqb|dkrœdaqb|d
kr±daqb|dkrât|ƒ}|jƒa	|j
ƒqb|dkrbt|ƒ}|jƒa|j
ƒqbqbWx|D]}t|ƒqWdS(Nithvthelps
oldnotice=s
newnotice=sdry-runtverboses-hs--helpis-vs	--verboses	--dry-runs--oldnotices--newnotice(s-hs--help(s-vs	--verbose(
tgetoptRtargvterrorRtVERBOSEtDRYRUNtopentreadt
OLD_NOTICEtcloset
NEW_NOTICEtprocess(toptstargsRtopttargtfp((s//usr/lib64/python2.7/Tools/scripts/fixnotice.pytmain;s.	
		

cCsót|ƒ}|jƒ}|jƒ|jtƒ}|dkrStrOdG|GHndSts_trkdG|GHntrudS|| t||ttƒ}|d}|d}t|dƒ}|j	|ƒ|jƒt
j||ƒt
j||ƒdS(Nis
no change:s
   change:s.news.baktw(RRRtfindRRRRtlentwritetostrename(tfiletftdatatitnewtbackup((s//usr/lib64/python2.7/Tools/scripts/fixnotice.pyRXs(
 


t__main__(RRR RRRRRRRRt__name__(((s//usr/lib64/python2.7/Tools/scripts/fixnotice.pyts		PK!%»dobjgraph.pynuÈ¯Ýí#! /usr/bin/python2.7

# objgraph
#
# Read "nm -o" input (on IRIX: "nm -Bo") of a set of libraries or modules
# and print various interesting listings, such as:
#
# - which names are used but not defined in the set (and used where),
# - which names are defined in the set (and where),
# - which modules use which other modules,
# - which modules are used by which other modules.
#
# Usage: objgraph [-cdu] [file] ...
# -c: print callers per objectfile
# -d: print callees per objectfile
# -u: print usage of undefined symbols
# If none of -cdu is specified, all are assumed.
# Use "nm -o" to generate the input (on IRIX: "nm -Bo"),
# e.g.: nm -o /lib/libc.a | objgraph


import sys
import os
import getopt
import re

# Types of symbols.
#
definitions = 'TRGDSBAEC'
externals = 'UV'
ignore = 'Nntrgdsbavuc'

# Regular expression to parse "nm -o" output.
#
matcher = re.compile('(.*):\t?........ (.) (.*)$')

# Store "item" in "dict" under "key".
# The dictionary maps keys to lists of items.
# If there is no list for the key yet, it is created.
#
def store(dict, key, item):
    if dict.has_key(key):
        dict[key].append(item)
    else:
        dict[key] = [item]

# Return a flattened version of a list of strings: the concatenation
# of its elements with intervening spaces.
#
def flat(list):
    s = ''
    for item in list:
        s = s + ' ' + item
    return s[1:]

# Global variables mapping defined/undefined names to files and back.
#
file2undef = {}
def2file = {}
file2def = {}
undef2file = {}

# Read one input file and merge the data into the tables.
# Argument is an open file.
#
def readinput(fp):
    while 1:
        s = fp.readline()
        if not s:
            break
        # If you get any output from this line,
        # it is probably caused by an unexpected input line:
        if matcher.search(s) < 0: s; continue # Shouldn't happen
        (ra, rb), (r1a, r1b), (r2a, r2b), (r3a, r3b) = matcher.regs[:4]
        fn, name, type = s[r1a:r1b], s[r3a:r3b], s[r2a:r2b]
        if type in definitions:
            store(def2file, name, fn)
            store(file2def, fn, name)
        elif type in externals:
            store(file2undef, fn, name)
            store(undef2file, name, fn)
        elif not type in ignore:
            print fn + ':' + name + ': unknown type ' + type

# Print all names that were undefined in some module and where they are
# defined.
#
def printcallee():
    flist = file2undef.keys()
    flist.sort()
    for filename in flist:
        print filename + ':'
        elist = file2undef[filename]
        elist.sort()
        for ext in elist:
            if len(ext) >= 8:
                tabs = '\t'
            else:
                tabs = '\t\t'
            if not def2file.has_key(ext):
                print '\t' + ext + tabs + ' *undefined'
            else:
                print '\t' + ext + tabs + flat(def2file[ext])

# Print for each module the names of the other modules that use it.
#
def printcaller():
    files = file2def.keys()
    files.sort()
    for filename in files:
        callers = []
        for label in file2def[filename]:
            if undef2file.has_key(label):
                callers = callers + undef2file[label]
        if callers:
            callers.sort()
            print filename + ':'
            lastfn = ''
            for fn in callers:
                if fn <> lastfn:
                    print '\t' + fn
                lastfn = fn
        else:
            print filename + ': unused'

# Print undefined names and where they are used.
#
def printundef():
    undefs = {}
    for filename in file2undef.keys():
        for ext in file2undef[filename]:
            if not def2file.has_key(ext):
                store(undefs, ext, filename)
    elist = undefs.keys()
    elist.sort()
    for ext in elist:
        print ext + ':'
        flist = undefs[ext]
        flist.sort()
        for filename in flist:
            print '\t' + filename

# Print warning messages about names defined in more than one file.
#
def warndups():
    savestdout = sys.stdout
    sys.stdout = sys.stderr
    names = def2file.keys()
    names.sort()
    for name in names:
        if len(def2file[name]) > 1:
            print 'warning:', name, 'multiply defined:',
            print flat(def2file[name])
    sys.stdout = savestdout

# Main program
#
def main():
    try:
        optlist, args = getopt.getopt(sys.argv[1:], 'cdu')
    except getopt.error:
        sys.stdout = sys.stderr
        print 'Usage:', os.path.basename(sys.argv[0]),
        print           '[-cdu] [file] ...'
        print '-c: print callers per objectfile'
        print '-d: print callees per objectfile'
        print '-u: print usage of undefined symbols'
        print 'If none of -cdu is specified, all are assumed.'
        print 'Use "nm -o" to generate the input (on IRIX: "nm -Bo"),'
        print 'e.g.: nm -o /lib/libc.a | objgraph'
        return 1
    optu = optc = optd = 0
    for opt, void in optlist:
        if opt == '-u':
            optu = 1
        elif opt == '-c':
            optc = 1
        elif opt == '-d':
            optd = 1
    if optu == optc == optd == 0:
        optu = optc = optd = 1
    if not args:
        args = ['-']
    for filename in args:
        if filename == '-':
            readinput(sys.stdin)
        else:
            readinput(open(filename, 'r'))
    #
    warndups()
    #
    more = (optu + optc + optd > 1)
    if optd:
        if more:
            print '---------------All callees------------------'
        printcallee()
    if optu:
        if more:
            print '---------------Undefined callees------------'
        printundef()
    if optc:
        if more:
            print '---------------All Callers------------------'
        printcaller()
    return 0

# Call the main program.
# Use its return value as exit status.
# Catch interrupts to avoid stack trace.
#
if __name__ == '__main__':
    try:
        sys.exit(main())
    except KeyboardInterrupt:
        sys.exit(1)
PK!Í—[»ëë
pickle2db.pyonu„[µü¤ó
fc@sBdZddlZyddlZWnek
r;dZnXyddlZWnek
redZnXyddlZWnek
rdZnXyddlZWnek
r¹dZnXddlZyddl	Z
Wnek
rõddl
Z
nXejdZd„Z
d„Zedkr>ejeejdƒƒndS(s,
Synopsis: %(prog)s [-h|-b|-g|-r|-a|-d] [ picklefile ] dbfile

Read the given picklefile as a series of key/value pairs and write to a new
database.  If the database already exists, any contents are deleted.  The
optional flags indicate the type of the output database:

    -a - open using anydbm
    -b - open as bsddb btree file
    -d - open as dbm file
    -g - open as gdbm file
    -h - open as bsddb hash file
    -r - open as bsddb recno file

The default is hash.  If a pickle file is named it is opened for read
access.  If no pickle file is named, the pickle input is read from standard
input.

Note that recno databases can only contain integer keys, so you can't dump a
hash or btree database using db2pickle.py and reconstitute it to a recno
database with %(prog)s unless your keys are integers.

iÿÿÿÿNicCstjjttƒƒdS(N(tsyststderrtwritet__doc__tglobals(((s//usr/lib64/python2.7/Tools/scripts/pickle2db.pytusage4sc	Cs¤y1tj|dddddddgƒ\}}Wntjk
rOtƒdSXt|ƒd	kstt|ƒd
krtƒdSt|ƒdkr§tj}|d	}nNyt|d	dƒ}Wn*tk
rêtjj	d|d	ƒdSX|d}d}xš|D]’\}}|d"krOy
tj}Wq”t
k
rKtjj	dƒdSXq|d#kry
tj}Wq”t
k
rŒtjj	dƒdSXq|d$krÑy
tj}Wq”t
k
rÍtjj	dƒdSXq|d%kry
tj}Wq”t
k
rtjj	dƒdSXq|d&krSy
tj}Wq”t
k
rOtjj	dƒdSXq|d'kry
tj}Wq”t
k
rtjj	dƒdSXqqW|dkràtdkrÔtjj	dƒtjj	dƒdStj}ny||dƒ}Wn9tjk
r.tjj	d |ƒtjj	d!ƒdSXx|jƒD]
}||=qs6





		[PK!Š
—¦®®lll.pycnu„[µü¤ó
fc@sNddlZddlZd„Zd„ZedkrJeejdƒndS(iÿÿÿÿNcCsyxrtj|ƒD]a}|tjtjfkrtjj||ƒ}tjj|ƒrq|GdGtj|ƒGHqqqqWdS(Ns->(tostlistdirtcurdirtpardirtpathtjointislinktreadlink(tdirnametnametfull((s)/usr/lib64/python2.7/Tools/scripts/lll.pytlll
s
cCsh|stjg}nd}xF|D]>}t|ƒdkrV|sDHnd}|dGHnt|ƒq"WdS(Niit:(RRtlenR(targstfirsttarg((s)/usr/lib64/python2.7/Tools/scripts/lll.pytmains
t__main__i(tsysRRRt__name__targv(((s)/usr/lib64/python2.7/Tools/scripts/lll.pyts		
PK!´héxmmanalyze_dxp.pynuÈ¯Ýí#! /usr/bin/python2.7
"""
Some helper functions to analyze the output of sys.getdxp() (which is
only available if Python was built with -DDYNAMIC_EXECUTION_PROFILE).
These will tell you which opcodes have been executed most frequently
in the current process, and, if Python was also built with -DDXPAIRS,
will tell you which instruction _pairs_ were executed most frequently,
which may help in choosing new instructions.

If Python was built without -DDYNAMIC_EXECUTION_PROFILE, importing
this module will raise a RuntimeError.

If you're running a script you want to profile, a simple way to get
the common pairs is:

$ PYTHONPATH=$PYTHONPATH:/Tools/scripts \
./python -i -O the_script.py --args
...
> from analyze_dxp import *
> s = render_common_pairs()
> open('/tmp/some_file', 'w').write(s)
"""

import copy
import opcode
import operator
import sys
import threading

if not hasattr(sys, "getdxp"):
    raise RuntimeError("Can't import analyze_dxp: Python built without"
                       " -DDYNAMIC_EXECUTION_PROFILE.")


_profile_lock = threading.RLock()
_cumulative_profile = sys.getdxp()

# If Python was built with -DDXPAIRS, sys.getdxp() returns a list of
# lists of ints.  Otherwise it returns just a list of ints.
def has_pairs(profile):
    """Returns True if the Python that produced the argument profile
    was built with -DDXPAIRS."""

    return len(profile) > 0 and isinstance(profile[0], list)


def reset_profile():
    """Forgets any execution profile that has been gathered so far."""
    with _profile_lock:
        sys.getdxp()  # Resets the internal profile
        global _cumulative_profile
        _cumulative_profile = sys.getdxp()  # 0s out our copy.


def merge_profile():
    """Reads sys.getdxp() and merges it into this module's cached copy.

    We need this because sys.getdxp() 0s itself every time it's called."""

    with _profile_lock:
        new_profile = sys.getdxp()
        if has_pairs(new_profile):
            for first_inst in range(len(_cumulative_profile)):
                for second_inst in range(len(_cumulative_profile[first_inst])):
                    _cumulative_profile[first_inst][second_inst] += (
                        new_profile[first_inst][second_inst])
        else:
            for inst in range(len(_cumulative_profile)):
                _cumulative_profile[inst] += new_profile[inst]


def snapshot_profile():
    """Returns the cumulative execution profile until this call."""
    with _profile_lock:
        merge_profile()
        return copy.deepcopy(_cumulative_profile)


def common_instructions(profile):
    """Returns the most common opcodes in order of descending frequency.

    The result is a list of tuples of the form
      (opcode, opname, # of occurrences)

    """
    if has_pairs(profile) and profile:
        inst_list = profile[-1]
    else:
        inst_list = profile
    result = [(op, opcode.opname[op], count)
              for op, count in enumerate(inst_list)
              if count > 0]
    result.sort(key=operator.itemgetter(2), reverse=True)
    return result


def common_pairs(profile):
    """Returns the most common opcode pairs in order of descending frequency.

    The result is a list of tuples of the form
      ((1st opcode, 2nd opcode),
       (1st opname, 2nd opname),
       # of occurrences of the pair)

    """
    if not has_pairs(profile):
        return []
    result = [((op1, op2), (opcode.opname[op1], opcode.opname[op2]), count)
              # Drop the row of single-op profiles with [:-1]
              for op1, op1profile in enumerate(profile[:-1])
              for op2, count in enumerate(op1profile)
              if count > 0]
    result.sort(key=operator.itemgetter(2), reverse=True)
    return result


def render_common_pairs(profile=None):
    """Renders the most common opcode pairs to a string in order of
    descending frequency.

    The result is a series of lines of the form:
      # of occurrences: ('1st opname', '2nd opname')

    """
    if profile is None:
        profile = snapshot_profile()
    def seq():
        for _, ops, count in common_pairs(profile):
            yield "%s: %s\n" % (count, ops)
    return ''.join(seq())
PK!!=e	ndiff.pycnu„[µü¤ó
fc@sídZdZddlZddlZd„Zd„Zd„Zd	„Zd
„Ze	dkréej
dZdekrÜddlZddl
Z
ejdƒd
Zejdeƒe
jeƒZejƒjdƒjƒqéeeƒndS(s‡ndiff [-q] file1 file2
    or
ndiff (-r1 | -r2) < ndiff_output > file1_or_file2

Print a human-friendly file difference report to stdout.  Both inter-
and intra-line differences are noted.  In the second form, recreate file1
(-r1) or file2 (-r2) on stdout, from an ndiff report on stdin.

In the first form, if -q ("quiet") is not specified, the first two lines
of output are

-: file1
+: file2

Each remaining line begins with a two-letter code:

    "- "    line unique to file1
    "+ "    line unique to file2
    "  "    line common to both files
    "? "    line not present in either input file

Lines beginning with "? " attempt to guide the eye to intraline
differences, and were not present in either input file.  These lines can be
confusing if the source files contain tab characters.

The first file can be recovered by retaining only lines that begin with
"  " or "- ", and deleting those 2-character prefixes; use ndiff with -r1.

The second file can be recovered similarly, but by retaining only "  " and
"+ " lines; use ndiff with -r2; or, on Unix, the second file can be
recovered by piping the output through

    sed -n '/^[+ ] /s/^..//p'
iiiiÿÿÿÿNcCs(tjj}||dƒ|tƒdS(Ns

i(tsyststderrtwritet__doc__(tmsgtout((s+/usr/lib64/python2.7/Tools/scripts/ndiff.pytfail5s
cCsDyt|dƒSWn,tk
r?}td|dt|ƒƒSXdS(NtUscouldn't open s: (topentIOErrorRtstr(tfnametdetail((s+/usr/lib64/python2.7/Tools/scripts/ndiff.pytfopen=scCs{t|ƒ}t|ƒ}|s&|r*dS|jƒ}|jƒ|jƒ}|jƒxtj||ƒD]
}|GqiWdS(Nii(R
t	readlinestclosetdifflibtndiff(tf1nametf2nametf1tf2tatbtline((s+/usr/lib64/python2.7/Tools/scripts/ndiff.pytfcompareDs

cCsKddl}y|j|dƒ\}}Wn#|jk
rM}tt|ƒƒSXd}d}}xJ|D]B\}}|dkrŒd}d}qe|dkred}|}	qeqeW|rÁ|rÁtdƒS|rû|r×tdƒS|	dkrñt|	ƒdStdƒSt|ƒdkrtd
ƒS|\}
}|r>dG|
GHdG|GHnt|
|ƒS(Niÿÿÿÿsqr:iis-qs-rscan't specify both -q and -rsno args allowed with -r optiont1t2s-r value must be 1 or 2isneed 2 filename argss-:s+:(RR(tgetoptterrorRR
trestoretlenR(targsRtoptsRtnoisytqseentrseentopttvalt	whichfileRR((s+/usr/lib64/python2.7/Tools/scripts/ndiff.pytmainTs<
	





	cCs/tjtjjƒ|ƒ}tjj|ƒdS(N(RRRtstdinRtstdoutt
writelines(twhichtrestored((s+/usr/lib64/python2.7/Tools/scripts/ndiff.pyRwst__main__s-profiles	ndiff.pros
main(args)ttime(iii(Rt__version__RRRR
RR(Rt__name__targvR tprofiletpstatstremovetstatftruntStatststatst
strip_dirst
sort_statstprint_stats(((s+/usr/lib64/python2.7/Tools/scripts/ndiff.pyt/s"				#	

PK!ÿï’//untabify.pycnu„[µü¤ó
fc@sYdZddlZddlZddlZd„Zed„ZedkrUeƒndS(sJReplace tabs with spaces in argument files.  Print names of changed files.iÿÿÿÿNcCsÅd}y8tjtjddƒ\}}|s=tjd‚nWn0tjk
rp}|GHdGtjdGdGHdSXx/|D]'\}}|dkrxt|ƒ}qxqxWx|D]}t||ƒqªWdS(	Niist:s#At least one file argument requiredsusage:is[-t tabwidth] file ...s-t(tgetopttsystargvterrortinttprocess(ttabsizetoptstargstmsgtoptnametoptvaluetfilename((s./usr/lib64/python2.7/Tools/scripts/untabify.pytmain	s
cCsÿy&t|ƒ}|jƒ}|jƒWn#tk
rK}d||fGHdSX|j|ƒ}||krkdS|d}ytj|ƒWntjk
rœnXytj||ƒWntjk
rÇnXt|dƒ}|j	|ƒWdQX|rû|GHndS(Ns%r: I/O error: %st~tw(
topentreadtclosetIOErrort
expandtabstostunlinkRtrenametwrite(RRtverbosetfttextR	tnewtexttbackup((s./usr/lib64/python2.7/Tools/scripts/untabify.pyRs.
t__main__(t__doc__RRRR
tTrueRt__name__(((s./usr/lib64/python2.7/Tools/scripts/untabify.pyts	PK!á3R==	serve.pycnu„[µü¤ó
fc@sâdZddlZddlZddlZddlmZmZd„ZedkrÞej	dZ
eej	ƒdkrŠeej	dƒndZ
ejd	e
eƒZd
e
e
fGHyejƒWqÞek
rÚdGHqÞXndS(s

Small wsgiref based web server. Takes a path to serve from and an
optional port number (defaults to 8000), then tries to serve files.
Mime types are guessed from the file names, 404 errors are raised
if the file is not found. Used for the make serve target in Doc.
iÿÿÿÿN(t
simple_servertutilcCs½tjjt|ddƒ}d|jtjjƒdkrTtjj|dƒ}ntj|ƒd}tjj|ƒr¢|dd|fgƒtj	t
|ƒƒS|d	dgƒdgSdS(
Nt	PATH_INFOit.iÿÿÿÿs
index.htmlis200 OKsContent-Types
404 Not Founds
text/plains	not found(sContent-Types
text/plain(tostpathtjointsplittsept	mimetypest
guess_typetexistsRtFileWrappertopen(tenvirontrespondtfnttype((s+/usr/lib64/python2.7/Tools/scripts/serve.pytapp
st__main__iii@ts(Serving %s on port %s, control-C to stopsShutting down.(t__doc__tsysRR	twsgirefRRRt__name__targvRtlentinttporttmake_serverthttpdt
serve_forevertKeyboardInterrupt(((s+/usr/lib64/python2.7/Tools/scripts/serve.pyts	
.
PK!)ML{E{E
texi2html.pycnu„[µü¤ó
fc@sbddlZddlZddlZddlZdZejdƒZejdƒZejdƒZejdƒZ	ejdƒZ
dfd	„ƒYZd
efd„ƒYZdfd
„ƒYZ
de
fd„ƒYZdfd„ƒYZd„Zd„ZejdƒZd„Zd„ZejejdZd„Zd„Zd„Zedkr^eƒndS(iÿÿÿÿNs\input texinfos^@([a-z]+)([ 	]|$)s^[ 	]*$s@[a-z]+s	[
@{}&<>]s.^\* ([^:]*):(:|[ 	]*([^	,
.]+)([^ 	
]*))[ 	
]*tHTMLNodecBsteZdZdZdZdZdZd„Zd„Zd„Z	d
d
d„Zd	„Zd
„Z
d„Zd„ZRS(sÓSome of the parser's functionality is separated into this class.

    A Node accumulates its contents, takes care of links to other Nodes
    and saves itself when it is finished and all links are resolved.
    s2its
cCs^||_||_|r$||_n	||_||_||_||_||_g|_dS(N(tdirnametnamettopnamettitletnexttprevtuptlines(tselftdirRRRRRR((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt__init__gs							cGst|jj|ƒdS(N(tmapR	tappend(R
R	((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytwritetscCsat|jdt|jƒdƒ}|j|jƒ|j|jƒ|j|jƒ|jƒdS(Nt/tw(	topenRtmakefileRRtprologuettexttepiloguetclose(R
tfp((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytflushws
#cCsŒ|rˆ|jƒdkr'd}d}nt|ƒ}d|}|j|d|d|r_d|pbd|rrd|pud|d	|d
ƒ
ndS(Ns(dir)s../dir.htmlRs TITLE="%s"s: s  
(tlowerRR(R
tlabeltnodenametreltrevtaddrR((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytlink~s	
cCsùt|jƒ}dj|jƒ|_g|_|jƒ|jƒ|jƒdj|jƒ}g|_|jd|jdt	|j
ƒd|j
dt	|jƒd|jdt	|jƒd|jd||_
|dkrõd	||_ndS(
NRsF

  
  s ���
  
  
  

is
%s
(tlenR	tjoinRt
open_linkstoutput_linkstclose_linkstDOCTYPERRRRRRR(R
tlengthtlinks((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytfinalize‹s	


	i
cCs|jdƒdS(Ns

(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR%¤scCs|jdƒdS(Ns
(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR'§scCsŸ|j|jkr(|jd|jƒn|jd|jddƒ|jd|jddƒ|jd|jddƒ|j|jkr›|jd	|jƒndS(
Ns  Conts  NextRtNexts  PrevtPreviouss  UptUps  Top(tcontRR"RRRR(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR&ªsN(t__name__t
__module__t__doc__R(ttypeR/RRRRtNoneR"R+R%R'R&(((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRZs	
		
			t	HTML3NodecBs eZdZd„Zd„ZRS(s;cCs|jdƒdS(Ns
 
(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR%¸scCs|jdƒdS(Ns
 

(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR'»s(R0R1R(R%R'(((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR5´s	t
TexinfoParsercBsž
eZdZdZdedZdedZdZeZd„Z	d„Z
d	„Zd
„Zd„Z
d„Zd
„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Z d„Z!d „Z"d!„Z#d"„Z$d#„Z%d$„Z&d%„Z'd&„Z(d'„Z)d(„Z*d)„Z+d*„Z,d+„Z-d,„Z.d-„Z/d.„Z0d/„Z1d0„Z2d1„Z3d2„Z4d3„Z5d4„Z6d5„Z7d6„Z8d7„Z9d8„Z:d9„Z;d:„Z<d;„Z=d<„Z>d=„Z?d>„Z@d?„ZAd@„ZBdA„ZCdB„ZDdC„ZEdD„ZFdE„ZGdF„ZHdG„ZIdH„ZJdI„ZKdJ„ZLdK„ZMdL„ZNdM„ZOdN„ZPdO„ZQdP„ZRdQ„ZSdR„ZTdS„ZUdT„ZVdU„ZWdV„ZXdW„ZYdX„ZZdY„Z[dZ„Z\d[„Z]d\„Z^e]Z_e^Z`d]„Zad^„Zbd_„Zcd`„Zdda„Zedb„Zfdc„Zgdd„Zhde„Zidf„Zjdg„Zkdh„Zldi„Zmdj„Zndk„Zodl„Zpdm„Zqdn„Zrdo„Zsdp„Ztdq„Zudr„Zvds„Zwdt„Zxdu„Zydv„Zzdw„Z{dx„Z|dy„Z}dz„Z~d{„Zd|„Z€d}„Zd~„Z‚d„Zƒd€„Z„d„Z…d‚„Z†dƒ„Z‡e]Zˆe^Z‰d„„ZŠd…„Z‹d†„ZŒd‡„Zdˆ„ZŽd‰„ZdŠ„ZeZ‘d‹„Z’dŒ„Z“d„Z”dŽ„Z•d„Z–d„Z—d‘„Z˜d’„Z™d“„Zšd”„Z›d•„Zœd–„Zd—„Zžd˜„ZŸd™„Z dš„Z¡eZ¢eZ£eZ¤d›„Z¥dœ„Z¦d„Z§dž„Z¨dŸ„Z©d „Zªd¡„Z«e«Z¬e«Ze«Z®eZ¯eZ°eZ±eZ²eZ£eZ³eZ´eZµeZ¶eZ·eZ¸eZ¹eZºd¢„Z»d£„Z¼d¤„Z½d¥„Z¾d¦„Z¿d§„ZÀd¨„ZÁd©„ZÂdª„ZÃd«„ZÄd¬„ZÅd„ZÆeÆZÇd®„ZÈd¯„ZÉd°„ZÊd±„ZËd²„ZÌd³„ZÍd´„ZÎdµ„ZÏd¶„ZÐd·„ZÑd¸„ZÒd¹„ZÓeÓZÔdº„ZÕd»„ZÖd¼„Z×d½„ZØd¾„ZÙd¿„ZÚdÀ„ZÛdÁ„ZÜdÂ„ZÝdÃ„ZÞdÄ„ZßeÝZàdÅ„ZádÆ„ZâeÝZãdÇ„ZädÈ„ZåeÝZædÉ„ZçdÊ„ZèeÝZédË„ZêdÌ„ZëeéZìdÍ„ZídÎ„ZîeéZïdÏ„ZðdÐ„ZñeÝZòdÑ„ZódÒ„ZôeòZõdÓ„ZödÔ„Z÷eòZødÕ„ZùdÖ„ZúeøZûd×„ZüdØ„ZýeøZþdÙ„ZÿdÚ„ZeþZdÛ„ZdÜ„ZeþZdÝ„ZdÞ„ZeZdß„Zdà„Z	eþZ
dá„Zdâ„Zdã„Z
dä„Zdå„Zdæ„Zdç„Zdè„Zdé„Zdê„Zdë„Zdì„ZeZdí„Zdî„Zdï„Zdð„Zdñ„Zdò„Zdó„Zdô„ZeZ eZ!eZ"eZ#e Z$e!Z%eZ&eZ'e&Z(e'Z)dõ„Z*dö„Z+d÷„Z,dø„Z-dù„Z.dú„Z/dû„Z0dü„Z1dý„Z2dþ„Z3dÿ„Z4d„Z5d„Z6d„Z7d„Z8d„Z9d„Z:d„Z;d„Zd	„Z?d
„Z@RS(s©s(%(id)s)s5ss5s
%(text)s
sJ


Footnotes
cCsi|_i|_d|_d|_d|_d|_d|_d|_g|_	d|_
d|_d|_d|_
d|_d|_|jƒg|_g|_d|_idd6|_i|_g|_d|_d|_d|_d|_g|_d|_d|_dS(Nittmpt.Rithtml(tunknownt	filenamest	debuggingt
print_headersR4tnodefpt
nodelinenoR*tsavetextt	savestackthtmlhelpRt
includedirRRRt
resetindextcontentst	numberingtnofilltvaluest	stackinfot	footnotestitemargt
itemnumbert	itemindextnodet	nodestackR/tincludedepth(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRÐs:															
											cCs
||_dS(N(RB(R
RB((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytsethtmlhelpñscCs
||_dS(N(R(R
R((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
setdirnameõscCs
||_dS(N(RC(R
RC((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
setincludedirùscCs‘|jƒ}d}x?|rS|ddks:tj|ƒrS|jƒ}|d}qW|ttƒ tkr}tdtf‚n|j||ƒdS(Niit%sfile does not begin with %r(treadlinetblprogtmatchR#tMAGICtSyntaxErrort	parserest(R
Rtlinetlineno((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytparseýs(c
Cs<|}d|_d|_g|_g}x’|js»|jƒ}|jd|_|s•|r}|jst|j|ƒng}n|dkr‘dGHnPn|d}tj|ƒ}|r-|jdƒ\}}|||!}	|	dkrò|j	|ƒq¸|r|js|j|ƒng}n|j
||ƒq*tj|ƒr«d|jkr«d|jkr«|r¸|js¨|j|ƒ|jr|j
dƒn
|j
d	ƒg}q¨q¸q*|j	|ƒq*W|jrÍd
GHn|jrêdGHdG|jGHn|jdkr8x<|jr4|jd
jƒ|jd
jƒ|jd
=qüWndS(Niis*** EOF before @byetnoindenttrefilltformattexamples
s

s*** Still skipping at the ends*** Stack not empty at the ends***iÿÿÿÿ(R^R_(tdonetskiptstackRUR?tprocesstcmprogRWtspanRtcommandRVRGRRPROR+R(
R
Rtinitial_linenoR\taccuR[tmotatbtcmd((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRZsb					

			
	
		cCs2|jdkr%|jj|jƒnd|_dS(NR(R@R4RAR(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytstartsaving@scCsN|j}t|jƒdkr;|jd|_|jd=n	d|_|pMdS(NiiÿÿÿÿR(R@R#RAR4(R
R@((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytcollectsavingsGs	
	cGs†ydj|ƒ}Wn|GHt‚nX|jdkrJ|j||_n8|jrf|jj|ƒn|jr‚|jj|ƒndS(NR(R$t	TypeErrorR@R4R>RRN(R
targsR((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRQs
		cCs’|jdkr#dGH|jƒ}n|jr9|jƒn|jr|jdkrß|jdƒ|jd \}}}}|j	d|ƒ|j	d|ƒ|j	d|ƒ|j
|jkrÏ|j	d|jƒn|jdƒn|jd	ƒ|jjƒd|_n€|j
r…|jrf|j
jsI|j
jrf|j
jrf|j
jrf|j
jƒ|j
jƒn|jj|j
ƒd|_
nd
|_
dS(Ns$*** Still saving text at end of nodeis

iR,tPrevR.tTops
R(R@R4RpRJtwritefootnotesR>R?Rt	nodelinksR"RRRRNR/R3RRRR+RROR(R
tdummyRRRR((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytendnode_s6	
	


	

$
c	CsØ|jdkrdd|jGdG|jG|jG|rA|dd Gn|ddsY|dr`dGnHn|jƒr¸xa|D]:}tj|ƒ}|sµ|jƒd}|j|ƒqwn|jdƒ\}}|jdƒ\}}|jdƒ\}}	|jd	ƒ\}
}|jd
ƒ\}}
|||!}|||	!}|ddkrQ|}n
||
|!}|||
!}|j	dt
|ƒd
|d|dƒ|jj|ƒ|j||ƒqwWndj
|ƒ}|j|ƒdS(Nit!sprocess:iis...s
iiit:s  
sR(R<RcRdtinmenutmiprogRWtstriptexpandRgRRRBtmenuitemR$(R
RjR[RktbgntendRlRmtctdtetftgthRRtpunctR((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyResB



	

		
cCss|j}xS|r^|ddkr^y|jt|ƒr<dSWntk
rPnX|d }qW|or|ddkS(Niÿÿÿÿtifsettifclearitmenu(R‰RŠ(RdRIR#tKeyError(R
Rd((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR{¢s	
c
Cs'g}d}t|ƒ}xö||kr|}tj||ƒ}|rT|jƒ}n|j||ƒP|j|||!ƒ||}|d}|dkr|jdƒqn|dkrÌ|jdƒqn|dkrë|jdƒqn|dkr
|jd	ƒqn|d
kr)|jdƒqn|dkr¬|sSd
GH|jdƒqn|d}|d=yt|d|ƒ}	Wn!tk
rž|j|ƒqnX|	ƒqn|dkrÈt	d|‚n|}x-||krý||t
jkrý|d}qÑW||krC|d}|||!}|dkr0q|j|ƒqn|||!}||krË||d
krË|d}|j|ƒyt|d|ƒ}	Wn!tk
r½|j|ƒqnX|	ƒqnyt|d|ƒ}	Wn!tk
r|j
|ƒqnX|	ƒqW|r#dG|GHndS(Niis
t fileiis<-- file(tostpathR$RCRtIOErrortreprR<RbRcRdRPRZR(R
RrtfileRtmsgt	save_donet	save_skipt
save_stack((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
do_include(s&			
			cCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_dmn?RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	close_dmn@RcCs|jdƒdS(Ns...(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	open_dotsBRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
close_dotsCRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_bulletERcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_bulletFRcCs|jdƒdS(NtTeX(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_TeXHRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	close_TeXIRcCs|j|jƒdS(N(RtCOPYRIGHT_SYMBOL(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pythandle_copyrightKRcCs|j|jƒdS(N(RRº(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_copyrightLRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_copyrightMRcCs|jdƒdS(Nt-(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
open_minusORcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_minusPRcCs|jdƒdS(Ns¡(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_exclamdownvRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_exclamdownwRcCs|jdƒdS(Ns¿(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_questiondownxRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_questiondownyRcCs|jdƒdS(Nså(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_aazRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_aa{RcCs|jdƒdS(NsÅ(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_AA|RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_AA}RcCs|jdƒdS(Nsæ(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_ae~RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_aeRcCs|jdƒdS(NsÆ(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_AE€RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_AERcCs|jdƒdS(Nsø(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_o‚RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_oƒRcCs|jdƒdS(NsØ(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_O„RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_O…RcCs|jdƒdS(Nsß(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_ss†RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_ss‡RcCs|jdƒdS(Ntoe(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_oeˆRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_oe‰RcCs|jdƒdS(NtOE(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_OEŠRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_OE‹RcCs|jdƒdS(Nsl/(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_lŒRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_lRcCs|jdƒdS(NsL/(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_LŽRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_LRcCs|jdƒdS(Ns=>(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_result“RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_result”RcCs|jdƒdS(Ns==>(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_expansion–RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_expansion—RcCs|jdƒdS(Ns-|(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
open_print™RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_printšRcCs|jdƒdS(Nserror-->(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
open_errorœRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_errorRcCs|jdƒdS(Ns==(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
open_equivŸRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_equiv RcCs|jdƒdS(Ns-!-(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
open_point¢RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_point£RcCs|jdƒ|jƒdS(Nssee (RRo(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
open_pxref§s
cCs|jƒdS(N(tmakeref(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_pxrefªscCs|jdƒ|jƒdS(NsSee (RRo(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	open_xrefs
cCs|jƒdS(N(Rê(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
close_xref°scCs|jƒdS(N(Ro(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_ref³scCs|jƒdS(N(Rê(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	close_refµscCs|jdƒ|jƒdS(NsSee info file (RRo(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_inforef¸s
cCs‹|jƒ}g|jdƒD]}|jƒ^q}x#t|ƒdkrY|jdƒq7W|d}|d}|jd|d|dƒdS(	Nt,iRiit`s	', node `s'(RptsplitR}R#RR(R
RtsRrRNR«((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
close_inforef»s(

c	Cs×|jƒ}g|jdƒD]}|jƒ^q}x#t|ƒdkrY|jdƒq7W|d}}|dr|d}n|d}|d}t|ƒ}|rºd|d	|}n|jd
|d|dƒdS(
NRñiRiiiis../Rs	s(RpRóR}R#RRR(	R
RRôRrRRR«Rthref((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRêÃs(


cCs|jƒdS(N(Ro(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	open_urefÑscCsš|jƒ}g|jdƒD]}|jƒ^q}x#t|ƒdkrY|jdƒq7W|d}|d}|s}|}n|jd|d|dƒdS(	NRñiRiis	s(RpRóR}R#RR(R
RRôRrRöR((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
close_urefÓs(

	cCs|jƒdS(N(Ro(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
open_imageãscCs|jƒdS(N(t	makeimage(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_imageåsc
Cs~|jƒ}g|jdƒD]}|jƒ^q}x#t|ƒdkrY|jdƒq7W|d}|d}|d}|d}|d}|jd	|}	tjj|	d
ƒrÀ|d
7}nOtjj|	dƒrã|d7}n,tjj|	dƒr|d7}n	d
|	GH|j	d|d|r2d|dp5d|rId|dpLd|r`d|dpcddƒ|j
j|	ƒdS(NRñiRiiiiiRs.pngs.jpgs.gifs*** Cannot find image s
(RpRóR}R#RRR§R¨texistsRRBtaddimage(
R
RRôRrtfilenametwidththeighttalttextt
imagelocation((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRúçs.(







	cCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR“
RcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR‘RcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	open_citeRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
close_citeRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	open_codeRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
close_codeRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_tRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_tRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_dfnRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	close_dfnRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	open_emphRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
close_emph RcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_i"RcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_i#RcCsBt|jƒd}|j|jit|ƒd6ƒ|jƒdS(Nitid(R#RJRtFN_SOURCE_PATTERNRªRo(R
R((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
open_footnote%s!cCs3t|jƒd}|jj||jƒfƒdS(Ni(R#RJRRp(R
R((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_footnote,scCs_|j|jƒx?|jD]4\}}|j|jit|ƒd6|d6ƒqWg|_dS(NRR(Rt	FN_HEADERRJtFN_TARGET_PATTERNRª(R
RR((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRu0s
 cCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	open_file7RcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
close_file8RcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_kbd:RcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	close_kbd;RcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_key=RcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	close_key>RcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_r@RcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_rARcCs|jdƒdS(Ns`(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	open_sampCRcCs|jdƒdS(Ns'(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
close_sampDRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_scFRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_scGRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_strongIRcCs|jdƒdS(Ns	(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_strongJRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_bLRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_bMRcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_varORcCs|jdƒdS(Ns(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	close_varPRcCs|jdƒdS(Ns	(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_wRRcCs|jdƒdS(Ns
(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_wSRcCs|jƒdS(N(Ro(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytopen_urlURcCs)|jƒ}|jd|d|dƒdS(Ns	s(RpR(R
R((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt	close_urlVscCs|jƒdS(N(Ro(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
open_emailZRcCs)|jƒ}|jd|d|dƒdS(Nss(RpR(R
R((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_email[scCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
open_smallbRcCsdS(N((R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytclose_smallcRcCs#|jdƒ\}}|||!}||jƒ}|jdkrnd|jGdG|jG|jGd|G|GHnyt|d|ƒ}Wnttk
rûyt|d|ƒ}Wn.tk
rÜ|jsØ|j||ƒndSX|jj|ƒ||ƒdSX|js|dkr||ƒndS(NiRyscommand:R’tdo_tbgn_R(	RgR}R<RcRdR˜R™tunknown_cmdR(R
R[RkRlRmRnRrtfunc((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRhes(


	
cCsOdGd|G|GH|jj|ƒs3d|j|s

(RR~(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_centerûs c Cs›|jƒd|_g|jdƒD]}|jƒ^q#}x#t|ƒdkr`|jdƒq>W||_|d \}}}}|jdt|ƒ}|j j |ƒrµdG|GHn |jrÕd|jGdG|GHnd |j |<||_|j r|jr|j|jd _ n|js(||_n|} |jrK| d|j} n|j|j|j|j| |||ƒ|_|jj|j||||ƒdS(NiRñiRRs*** Filename already in use: Rys--- writingiiÿÿÿÿs -- (RxR?RóR}R#RRvRRR;R£R<RR/RORRtNodeRNRBtaddnode( R RrRôtpartsRRRRR«R((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_nodes0 ( c CsV|rR|jƒdkr!d}nt|ƒ}|j|d|d|d|dƒndS(Ns(dir)s../dir.htmls: s (RRR(R RRR!((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR".s cCs7|jr3||j_x|jr/|jdj|krf|jdjƒ|jdjƒ|jd=q|jdj|krù|jdjs¥|jj|jd_n|jjsÊ|jdj|j_n|jdjƒ|jdjƒ|jd=q|dkr+|jjr+|jdj|j_nPqWndS(Niÿÿÿÿi( RNR3ROR+RRRRR(R R3((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytpopstack9s$ cCs$|jd|dƒ|jdƒdS(NtH1ii(theadingRZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_chapterNscCs$|jd|dƒ|jdƒdS(NR[iÿÿÿÿi(R\RZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_unnumberedRscCs$|jd|dƒ|jdƒdS(NR[iÿÿÿÿi(R\RZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_appendixUscCs|jd|dƒdS(NR[iÿÿÿÿ(R\(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_topXscCs|jd|dƒdS(NR[iÿÿÿÿ(R\(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_chapheadingZscCs|jd|dƒdS(NR[iÿÿÿÿ(R\(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_majorheading\scCs$|jd|dƒ|jdƒdS(NR[ii(R\RZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_section_scCs$|jd|dƒ|jdƒdS(NR[iÿÿÿÿi(R\RZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_unnumberedseccscCs$|jd|dƒ|jdƒdS(NR[iÿÿÿÿi(R\RZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_appendixsecfscCs|jd|dƒdS(NR[iÿÿÿÿ(R\(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_headingjscCs$|jd|dƒ|jdƒdS(NtH2ii(R\RZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_subsectionmscCs$|jd|dƒ|jdƒdS(NRgiÿÿÿÿi(R\RZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_unnumberedsubsecpscCs$|jd|dƒ|jdƒdS(NRgiÿÿÿÿi(R\RZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_appendixsubsecsscCs|jd|dƒdS(NRgiÿÿÿÿ(R\(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_subheadingvscCs$|jd|dƒ|jdƒdS(NtH3ii(R\RZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_subsubsectionyscCs$|jd|dƒ|jdƒdS(NRliÿÿÿÿi(R\RZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_unnumberedsubsubsec|scCs$|jd|dƒ|jdƒdS(NRliÿÿÿÿi(R\RZ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_appendixsubsubsecscCs|jd|dƒdS(NRliÿÿÿÿ(R\(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_subsubheading‚scCs|dkr¹x)t|jƒ|kr7|jjdƒqW|j|d3|j|d|j| s---( R#RFRRªRERRR~R<R=(R R3RrtleveltxR ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR\…s cCs|jddƒdS(NsTable of Contentsiç(tlistcontents(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_contents–scCsdS(N((R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_shortcontentsšscCs!|jd|dƒdg}xç|jD]Ü\}}}||krGq&n||dkr|jd|ddƒ|j|ƒnI||dkrÈx6||dkrÄ|d=|jd|ddƒq’Wn|jd|dt|ƒd ƒ|j|ƒ|jd ƒq&W|jdt|ƒƒdS(Ns

s

s (RRERRR~R#(R Rtmaxlevelt prevlevelsRqRN((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRsŸs$ cCsdS(N((R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_page¹RcCsdS(N((R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_need»RcCsdS(N((R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_group½RcCsdS(N((R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt end_group¾RcCs*|jr|jdƒn |jdƒdS(Ns s

(RGR(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_spÂs cCs|jdƒdS(Ns

(R(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_hlineÈscCs|jdƒ|j|ƒdS(Ns

(Rt do_deffnx(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_deffnÍs cCs|jdƒdS(Ns (R(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt end_deffnÑscCs‘|jdƒt|dƒ}|d |d\}}}|jd|ƒx%|D]}|jdt|ƒƒqOW|jdƒ|jd|ƒdS(Ns

is@b{%s}RBs

tfn(Rt splitwordsR~tmakevartindex(R RrR7tcategoryRtresttword((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR~Ôs cCs|jd|ƒdS(Ns Function (R(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_defunÞRcCs|jd|ƒdS(Ns Function (R~(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_defunxàRcCs|jd|ƒdS(NsMacro (R(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_defmacâRcCs|jd|ƒdS(NsMacro (R~(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_defmacxäRcCs|jd|ƒdS(Ns{Special Form} (R(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytbgn_defspecæRcCs|jd|ƒdS(Ns{Special Form} (R~(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_defspecxèRcCs|jdƒ|j|ƒdS(Ns

is @code{%s}RBs

tvr(RR‚R~R„(R RrR7R…RR†R‡((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRŽðs cCs|jd|ƒdS(Ns Variable (R(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_defvarûRcCs|jd|ƒdS(Ns Variable (RŽ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_defvarxýRcCs|jd|ƒdS(Ns{User Option} (R(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_defoptÿRcCs|jd|ƒdS(Ns{User Option} (RŽ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_defoptxRcCs|jdƒ|j|ƒdS(Ns

is@code{%s} @b{%s}RBs

R(RR‚R~RƒR„(R RrR7R…tdatatypeRR†R‡((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR•s cCs|jd|ƒdS(Ns Function (R–(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytbgn_deftypefunRcCs|jd|ƒdS(Ns Function (R•(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_deftypefunxRcCs|jdƒ|j|ƒdS(Ns

is@code{%s} @b{%s}RBs

R(RR‚R~R„(R RrR7R…R—RR†R‡((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRš s cCs|jd|ƒdS(Ns Variable (R›(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytbgn_deftypevar+scCs|jd|ƒdS(Ns Variable (Rš(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_deftypevarx.scCs|jdƒ|j|ƒdS(Ns

is@b{%s}RBs

Rs%s @r{on %s}(RR‚R~R„(R RrR7R…t classnameRR†R‡((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRž9s cCs|jd|ƒdS(Ns{Instance Variable} (RŸ(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytbgn_defivarDscCs|jd|ƒdS(Ns{Instance Variable} (Rž(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_defivarxGscCs|jdƒ|j|ƒdS(Ns

is@b{%s}RBs

Rs%s @r{on %s}(RR‚R~RƒR„(R RrR7R…R RR†R‡((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR£Ps cCs|jd|ƒdS(NsMethod (R¤(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_defmethodZscCs|jd|ƒdS(NsMethod (R£(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_defmethodx]scCs|jdƒ|j|ƒdS(Ns

is@b{%s}RBs

ttp(RR‚R~R„(R RrR7R…RR†R‡((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR§hs cCs\|s,|jdƒd|jt|jƒ s s

s (RRIR#RdRL(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_enumeratets cCsEd|_|j|jt|jƒdƒ|jt|jƒd=dS(Ni(R4RLRRIR#Rd(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt end_enumerate|s !cCs||_|jdƒdS(Ns

(RKR(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytbgn_itemizes cCsd|_|jdƒdS(Ns (R4RKR(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytend_itemize„s cCs||_|jdƒdS(Ns

(RKR(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_tableˆs cCsd|_|jdƒdS(Ns (R4RKR(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt end_table‹s cCsd|_|j|ƒdS(NR(RMR®(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_ftables cCsd|_|jƒdS(N(R4RMR¯(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt end_ftable’s cCsd|_|j|ƒdS(NR(RMR®(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_vtable–s cCsd|_|jƒdS(N(R4RMR¯(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt end_vtable™s cCsv|jr|j|j|ƒn|jrŠ|jddkrv|jdrv|jdtjkrv|jd|d}qŠ|jd|}n|jdkr¿|jd|}t|jƒ|_n|jr|jdd kr|j d ƒ|j |ƒ|j dƒnm|jrK|jddkrK|j d ƒ|j |ƒ|j dƒn'|j dƒ|j |ƒ|j dƒdS(NiR’iRRRBs. iÿÿÿÿttables

s

t multitabless s

s (RMR„RKRœRRLR4t incrementRdRR~(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytdo_items* cCsd|_|jdƒdS(Ns (R4RKR(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytbgn_multitable¸s cCsd|_|jdƒdS(Ns

(R4RKR(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytend_multitable»s cCs d|_dS(N(R4RK(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pythandle_columnfractions¾scCs|jdƒdS(Ns (R(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt handle_tabÁscCs|jdƒdS(Ns

(R(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_quotationÇRcCs|jdƒdS(Ns

(R(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt end_quotationÈRcCs!|jd|_|jdƒdS(Nis

(RGR(R
Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytbgn_exampleÊscCs!|jdƒ|jd|_dS(Ns

i(RRG(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytend_exampleÍs cCs|j|dƒdS(Ns (R~(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt do_exdentàRcCs!|jd|_|jdƒdS(Nis

(RGR(R
Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt
bgn_flushleftãscCs!|jdƒ|jd|_dS(Ns

i(RRG(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt end_flushleftæs cCs!|jd|_|jdƒdS(Nis

(RGR(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytbgn_flushrightêscCs!|jdƒ|jd|_dS(Ns

i(RRG(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytend_flushrightís cCs+|jdƒ|jdƒ|jjƒdS(Ns s$ Menu

(RRBt beginmenu(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytbgn_menuñs cCs|jdƒ|jjƒdS(Ns

(RRBtendmenu(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytend_menuõs cCsdS(N((R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt bgn_cartoucheùRcCsdS(N((R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyt end_cartoucheúRcCs—dg|_i|_d|jd iRzs

s@code{Rs

%s s

(RÔRÖR<RÕtretcompileRRWRRtsortRR4R~R(R RtiscodeindexR„tindex1tjunkprogRDRNtsortkeyt oldsortkeyRkR tprevkeytprevnode((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRâ6sH cCsX|jrTdGH|jjƒ}|jƒx*|D]}|jdƒG|j|GHq.WndS(Ns--- Unrecognized commands ---i(R:RHRætljust(R tcmdsRn((s//usr/lib64/python2.7/Tools/scripts/texi2html.pytreport^s (AR0R1Rºt FN_ID_PATTERNRRRRRVRRQRRRSR]RZRoRpRRxReR{R~RžRšRŸR¤R¥R°R±R²R³R´RµR¶R¸R¹R»R¼R½R¿RÀRÁRÂRÃRÄRÅRÆRÇRÈRÉRÊRËRÌRÍRÎRÏRÐRÑRÒRÔRÕR×RØRÙRÚRÛRÜRÝRÞRßRàRáRâRãRäRåRæRçRèRéRëRìRíRîRïRðRõRêR÷RøRùRûRúR“R‘t open_asist close_asisRRRRRR R RRR RRRRRuRRRRRRRRRRR R!R"R#R$R%R&R'R(R)R*R+R,R-topen_titlefonttclose_titlefontR.R/RhR2R8R6R9tdo_cR:R;R<R=R>R?R@RARFRGRIRJRKRLRMRNtdo_finalouttdo_setchapternewpagetdo_setfilenameRORPRQRRRSRTRUtdo_titletdo_subtitlet do_authortdo_vskiptdo_vfilltdo_smallbooktdo_paragraphindenttdo_headingstdo_footnotestyletdo_evenheadingtdo_evenfootingt do_oddheadingt do_oddfootingtdo_everyheadingtdo_everyfootingRYR"RZR]R^R_R`RaRbRcRdRetdo_appendixsectionRfRhRiRjRkRmRnRoRpR\RtRutdo_summarycontentsRsRxRyRzR{R|R}RR€R~Rˆt end_defunR‰RŠt end_defmacR‹RŒtend_defspecRRt end_defvrRŽR‘t end_defvarR’R“t end_defoptR”R–t end_deftypefnR•R˜tend_deftypefunR™R›t end_deftypevrRšRœtend_deftypevarRRŸt end_defcvRžR¡tend_defivarR¢R¤t end_defopR£R¥t end_defmethodR¦R¨t end_deftpR§RªR«R¬RR®R¯R°R±R²R³R·tdo_itemxR¸R¹RºR»R¼R½R¾R¿tbgn_lisptend_lisptbgn_smallexampletend_smallexamplet bgn_smalllispt end_smalllisptbgn_displaytend_displayt bgn_formatt end_formatRÀRÁRÂRÃRÄRÆRÈRÉRÊRDR×RØRÙRÚRÛRÜRÝR„Rátdo_syncodeindexRãRâRð(((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR6¿s~ ! 8 # T & & (tTexinfoParserHTML3cBseZdZdZdedZdedZdZeZd„Z d„Z d „Zd „Zd„Z d„Zd „Zd„Zd„ZRS(s©s[%(id)s]s3ss;

s %(text)s

Footnotes

cCs|jdƒdS(Ns(R(R Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR¼uRcCs|jdƒdS(Ns (R(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR½vRcCs!|jd|_|jdƒdS(Nis

(RGR(R
Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR¾xscCs!|jdƒ|jd|_dS(Ns

i(RRG(R ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR¿}s cCs!|jd|_|jdƒdS(Nis

(RGR(R
Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRÁscCs!|jd|_|jdƒdS(Nis4
(RGR(R
Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRÃ…scCs!|jdƒ|jd|_dS(Ns
i(RRG(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRÄˆs
cCs|jdƒ|jdƒdS(Ns
s  Menu
(R(R
Rr((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRÆŒs
cCs|jdƒdS(Ns
(R(R
((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyRÈs(R0R1RºRñRRRR5RVR¼R½R¾R¿RÁRÃRÄRÆRÈ(((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR&gs								tHTMLHelpcBsÈeZdZejdƒZd„Zd„Zd„Zd„Z	d„Z
d„Zd„Zd	„Z
ejd
„Zejd„Zdejd
„Zdejd„Zd„Zejd„Zd„ZRS(s¡
    This class encapsulates support for HTML Help. Node names,
    file names, menu items, index items, and image file names are
    accumulated until a call to finalize(). At that time, three
    output files are created in the current directory:

        `helpbase`.hhp  is a HTML Help Workshop project file.
                        It contains various information, some of
                        which I do not understand; I just copied
                        the default project info from a fresh
                        installation.
        `helpbase`.hhc  is the Contents file for the project.
        `helpbase`.hhk  is the Index file for the project.

    When these files are used as input to HTML Help Workshop,
    the resulting file will be named:

        `helpbase`.chm

    If none of the defaults in `helpbase`.hhp are changed,
    the .CHM file will have Contents, Index, Search, and
    Favorites tabs.
    s@code{(.*?)}cCsy||_||_d|_d|_d|_g|_i|_i|_i|_	g|_
d|_i|_i|_
dS(NR(thelpbaseRR4tprojectfiletcontentfilet	indexfiletnodelistt	nodenamest	nodeindexR;t	indexlisttcurrenttmenudicttdumped(R
R(R((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR¯s												cCse|||||f}||j|s0sssGssss'   sss$s$(
R(R,Rt	dumpfilesRR©tsystexitt	dumpnodest	dumpindex(R
t
resultfileR)R*R+RRttopnextttopprevttopupttopfiletdefaulttopicRR¬((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR+Üsœ	



	












































cCs8|jjƒ}|jƒx|D]}||IJq WdS(N(R;RHRæ(R
toutfiletfilelistRþ((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR4;s

cCsyi|_|jr:|jd\}}}}}||_n|dIJx$|jD]}|j|d|ƒqNW|dIJdS(Niss(R2R,ttopnodetdumpnode(R
R?RRwRN((s//usr/lib64/python2.7/Tools/scripts/texi2html.pyR7As		
ic
CsÐ|rÌ|\}}}}}||_|jj|ƒr:dSd|j|<|d|I|dI|d|dI|d|dI|dIJy(|j|}	|j|	|d|ƒWqÌtk
rÈqÌXndS(	NiRBs

') self.expand(args) self.write('

', title, '

s

s

s

s