Whitespace normalization, via reindent.py.
diff --git a/Lib/lib-old/Para.py b/Lib/lib-old/Para.py
index 2e6aa4c..2fd8dc6 100644
--- a/Lib/lib-old/Para.py
+++ b/Lib/lib-old/Para.py
@@ -1,4 +1,4 @@
-# Text formatting abstractions
+# Text formatting abstractions
# Note -- this module is obsolete, it's too slow anyway
@@ -14,330 +14,330 @@
# different screen locations. Once rendered, it can be queried
# for mouse hits, and parts of the text can be highlighted
class Para:
- #
- def __init__(self):
- self.words = [] # The words
- self.just = 'l' # Justification: 'l', 'r', 'lr' or 'c'
- self.indent_left = self.indent_right = self.indent_hang = 0
- # Final lay-out parameters, may change
- self.left = self.top = self.right = self.bottom = \
- self.width = self.height = self.lines = None
- #
- # Add a word, computing size information for it.
- # Words may also be added manually by appending to self.words
- # Each word should be a 7-tuple:
- # (font, text, width, space, stretch, ascent, descent)
- def addword(self, d, font, text, space, stretch):
- if font is not None:
- d.setfont(font)
- width = d.textwidth(text)
- ascent = d.baseline()
- descent = d.lineheight() - ascent
- spw = d.textwidth(' ')
- space = space * spw
- stretch = stretch * spw
- tuple = (font, text, width, space, stretch, ascent, descent)
- self.words.append(tuple)
- #
- # Hooks to begin and end anchors -- insert numbers in the word list!
- def bgn_anchor(self, id):
- self.words.append(id)
- #
- def end_anchor(self, id):
- self.words.append(0)
- #
- # Return the total length (width) of the text added so far, in pixels
- def getlength(self):
- total = 0
- for word in self.words:
- if type(word) is not Int:
- total = total + word[2] + word[3]
- return total
- #
- # Tab to a given position (relative to the current left indent):
- # remove all stretch, add fixed space up to the new indent.
- # If the current position is already at the tab stop,
- # don't add any new space (but still remove the stretch)
- def tabto(self, tab):
- total = 0
- as, de = 1, 0
- for i in range(len(self.words)):
- word = self.words[i]
- if type(word) is Int: continue
- (fo, te, wi, sp, st, as, de) = word
- self.words[i] = (fo, te, wi, sp, 0, as, de)
- total = total + wi + sp
- if total < tab:
- self.words.append((None, '', 0, tab-total, 0, as, de))
- #
- # Make a hanging tag: tab to hang, increment indent_left by hang,
- # and reset indent_hang to -hang
- def makehangingtag(self, hang):
- self.tabto(hang)
- self.indent_left = self.indent_left + hang
- self.indent_hang = -hang
- #
- # Decide where the line breaks will be given some screen width
- def layout(self, linewidth):
- self.width = linewidth
- height = 0
- self.lines = lines = []
- avail1 = self.width - self.indent_left - self.indent_right
- avail = avail1 - self.indent_hang
- words = self.words
- i = 0
- n = len(words)
- lastfont = None
- while i < n:
- firstfont = lastfont
- charcount = 0
- width = 0
- stretch = 0
- ascent = 0
- descent = 0
- lsp = 0
- j = i
- while i < n:
- word = words[i]
- if type(word) is Int:
- if word > 0 and width >= avail:
- break
- i = i+1
- continue
- fo, te, wi, sp, st, as, de = word
- if width + wi > avail and width > 0 and wi > 0:
- break
- if fo is not None:
- lastfont = fo
- if width == 0:
- firstfont = fo
- charcount = charcount + len(te) + (sp > 0)
- width = width + wi + sp
- lsp = sp
- stretch = stretch + st
- lst = st
- ascent = max(ascent, as)
- descent = max(descent, de)
- i = i+1
- while i > j and type(words[i-1]) is Int and \
- words[i-1] > 0: i = i-1
- width = width - lsp
- if i < n:
- stretch = stretch - lst
- else:
- stretch = 0
- tuple = i-j, firstfont, charcount, width, stretch, \
- ascent, descent
- lines.append(tuple)
- height = height + ascent + descent
- avail = avail1
- self.height = height
- #
- # Call a function for all words in a line
- def visit(self, wordfunc, anchorfunc):
- avail1 = self.width - self.indent_left - self.indent_right
- avail = avail1 - self.indent_hang
- v = self.top
- i = 0
- for tuple in self.lines:
- wordcount, firstfont, charcount, width, stretch, \
- ascent, descent = tuple
- h = self.left + self.indent_left
- if i == 0: h = h + self.indent_hang
- extra = 0
- if self.just == 'r': h = h + avail - width
- elif self.just == 'c': h = h + (avail - width) / 2
- elif self.just == 'lr' and stretch > 0:
- extra = avail - width
- v2 = v + ascent + descent
- for j in range(i, i+wordcount):
- word = self.words[j]
- if type(word) is Int:
- ok = anchorfunc(self, tuple, word, \
- h, v)
- if ok is not None: return ok
- continue
- fo, te, wi, sp, st, as, de = word
- if extra > 0 and stretch > 0:
- ex = extra * st / stretch
- extra = extra - ex
- stretch = stretch - st
- else:
- ex = 0
- h2 = h + wi + sp + ex
- ok = wordfunc(self, tuple, word, h, v, \
- h2, v2, (j==i), (j==i+wordcount-1))
- if ok is not None: return ok
- h = h2
- v = v2
- i = i + wordcount
- avail = avail1
- #
- # Render a paragraph in "drawing object" d, using the rectangle
- # given by (left, top, right) with an unspecified bottom.
- # Return the computed bottom of the text.
- def render(self, d, left, top, right):
- if self.width != right-left:
- self.layout(right-left)
- self.left = left
- self.top = top
- self.right = right
- self.bottom = self.top + self.height
- self.anchorid = 0
- try:
- self.d = d
- self.visit(self.__class__._renderword, \
- self.__class__._renderanchor)
- finally:
- self.d = None
- return self.bottom
- #
- def _renderword(self, tuple, word, h, v, h2, v2, isfirst, islast):
- if word[0] is not None: self.d.setfont(word[0])
- baseline = v + tuple[5]
- self.d.text((h, baseline - word[5]), word[1])
- if self.anchorid > 0:
- self.d.line((h, baseline+2), (h2, baseline+2))
- #
- def _renderanchor(self, tuple, word, h, v):
- self.anchorid = word
- #
- # Return which anchor(s) was hit by the mouse
- def hitcheck(self, mouseh, mousev):
- self.mouseh = mouseh
- self.mousev = mousev
- self.anchorid = 0
- self.hits = []
- self.visit(self.__class__._hitcheckword, \
- self.__class__._hitcheckanchor)
- return self.hits
- #
- def _hitcheckword(self, tuple, word, h, v, h2, v2, isfirst, islast):
- if self.anchorid > 0 and h <= self.mouseh <= h2 and \
- v <= self.mousev <= v2:
- self.hits.append(self.anchorid)
- #
- def _hitcheckanchor(self, tuple, word, h, v):
- self.anchorid = word
- #
- # Return whether the given anchor id is present
- def hasanchor(self, id):
- return id in self.words or -id in self.words
- #
- # Extract the raw text from the word list, substituting one space
- # for non-empty inter-word space, and terminating with '\n'
- def extract(self):
- text = ''
- for w in self.words:
- if type(w) is not Int:
- word = w[1]
- if w[3]: word = word + ' '
- text = text + word
- return text + '\n'
- #
- # Return which character position was hit by the mouse, as
- # an offset in the entire text as returned by extract().
- # Return None if the mouse was not in this paragraph
- def whereis(self, d, mouseh, mousev):
- if mousev < self.top or mousev > self.bottom:
- return None
- self.mouseh = mouseh
- self.mousev = mousev
- self.lastfont = None
- self.charcount = 0
- try:
- self.d = d
- return self.visit(self.__class__._whereisword, \
- self.__class__._whereisanchor)
- finally:
- self.d = None
- #
- def _whereisword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
- fo, te, wi, sp, st, as, de = word
- if fo is not None: self.lastfont = fo
- h = h1
- if isfirst: h1 = 0
- if islast: h2 = 999999
- if not (v1 <= self.mousev <= v2 and h1 <= self.mouseh <= h2):
- self.charcount = self.charcount + len(te) + (sp > 0)
- return
- if self.lastfont is not None:
- self.d.setfont(self.lastfont)
- cc = 0
- for c in te:
- cw = self.d.textwidth(c)
- if self.mouseh <= h + cw/2:
- return self.charcount + cc
- cc = cc+1
- h = h+cw
- self.charcount = self.charcount + cc
- if self.mouseh <= (h+h2) / 2:
- return self.charcount
- else:
- return self.charcount + 1
- #
- def _whereisanchor(self, tuple, word, h, v):
- pass
- #
- # Return screen position corresponding to position in paragraph.
- # Return tuple (h, vtop, vbaseline, vbottom).
- # This is more or less the inverse of whereis()
- def screenpos(self, d, pos):
- if pos < 0:
- ascent, descent = self.lines[0][5:7]
- return self.left, self.top, self.top + ascent, \
- self.top + ascent + descent
- self.pos = pos
- self.lastfont = None
- try:
- self.d = d
- ok = self.visit(self.__class__._screenposword, \
- self.__class__._screenposanchor)
- finally:
- self.d = None
- if ok is None:
- ascent, descent = self.lines[-1][5:7]
- ok = self.right, self.bottom - ascent - descent, \
- self.bottom - descent, self.bottom
- return ok
- #
- def _screenposword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
- fo, te, wi, sp, st, as, de = word
- if fo is not None: self.lastfont = fo
- cc = len(te) + (sp > 0)
- if self.pos > cc:
- self.pos = self.pos - cc
- return
- if self.pos < cc:
- self.d.setfont(self.lastfont)
- h = h1 + self.d.textwidth(te[:self.pos])
- else:
- h = h2
- ascent, descent = tuple[5:7]
- return h, v1, v1+ascent, v2
- #
- def _screenposanchor(self, tuple, word, h, v):
- pass
- #
- # Invert the stretch of text between pos1 and pos2.
- # If pos1 is None, the beginning is implied;
- # if pos2 is None, the end is implied.
- # Undoes its own effect when called again with the same arguments
- def invert(self, d, pos1, pos2):
- if pos1 is None:
- pos1 = self.left, self.top, self.top, self.top
- else:
- pos1 = self.screenpos(d, pos1)
- if pos2 is None:
- pos2 = self.right, self.bottom,self.bottom,self.bottom
- else:
- pos2 = self.screenpos(d, pos2)
- h1, top1, baseline1, bottom1 = pos1
- h2, top2, baseline2, bottom2 = pos2
- if bottom1 <= top2:
- d.invert((h1, top1), (self.right, bottom1))
- h1 = self.left
- if bottom1 < top2:
- d.invert((h1, bottom1), (self.right, top2))
- top1, bottom1 = top2, bottom2
- d.invert((h1, top1), (h2, bottom2))
+ #
+ def __init__(self):
+ self.words = [] # The words
+ self.just = 'l' # Justification: 'l', 'r', 'lr' or 'c'
+ self.indent_left = self.indent_right = self.indent_hang = 0
+ # Final lay-out parameters, may change
+ self.left = self.top = self.right = self.bottom = \
+ self.width = self.height = self.lines = None
+ #
+ # Add a word, computing size information for it.
+ # Words may also be added manually by appending to self.words
+ # Each word should be a 7-tuple:
+ # (font, text, width, space, stretch, ascent, descent)
+ def addword(self, d, font, text, space, stretch):
+ if font is not None:
+ d.setfont(font)
+ width = d.textwidth(text)
+ ascent = d.baseline()
+ descent = d.lineheight() - ascent
+ spw = d.textwidth(' ')
+ space = space * spw
+ stretch = stretch * spw
+ tuple = (font, text, width, space, stretch, ascent, descent)
+ self.words.append(tuple)
+ #
+ # Hooks to begin and end anchors -- insert numbers in the word list!
+ def bgn_anchor(self, id):
+ self.words.append(id)
+ #
+ def end_anchor(self, id):
+ self.words.append(0)
+ #
+ # Return the total length (width) of the text added so far, in pixels
+ def getlength(self):
+ total = 0
+ for word in self.words:
+ if type(word) is not Int:
+ total = total + word[2] + word[3]
+ return total
+ #
+ # Tab to a given position (relative to the current left indent):
+ # remove all stretch, add fixed space up to the new indent.
+ # If the current position is already at the tab stop,
+ # don't add any new space (but still remove the stretch)
+ def tabto(self, tab):
+ total = 0
+ as, de = 1, 0
+ for i in range(len(self.words)):
+ word = self.words[i]
+ if type(word) is Int: continue
+ (fo, te, wi, sp, st, as, de) = word
+ self.words[i] = (fo, te, wi, sp, 0, as, de)
+ total = total + wi + sp
+ if total < tab:
+ self.words.append((None, '', 0, tab-total, 0, as, de))
+ #
+ # Make a hanging tag: tab to hang, increment indent_left by hang,
+ # and reset indent_hang to -hang
+ def makehangingtag(self, hang):
+ self.tabto(hang)
+ self.indent_left = self.indent_left + hang
+ self.indent_hang = -hang
+ #
+ # Decide where the line breaks will be given some screen width
+ def layout(self, linewidth):
+ self.width = linewidth
+ height = 0
+ self.lines = lines = []
+ avail1 = self.width - self.indent_left - self.indent_right
+ avail = avail1 - self.indent_hang
+ words = self.words
+ i = 0
+ n = len(words)
+ lastfont = None
+ while i < n:
+ firstfont = lastfont
+ charcount = 0
+ width = 0
+ stretch = 0
+ ascent = 0
+ descent = 0
+ lsp = 0
+ j = i
+ while i < n:
+ word = words[i]
+ if type(word) is Int:
+ if word > 0 and width >= avail:
+ break
+ i = i+1
+ continue
+ fo, te, wi, sp, st, as, de = word
+ if width + wi > avail and width > 0 and wi > 0:
+ break
+ if fo is not None:
+ lastfont = fo
+ if width == 0:
+ firstfont = fo
+ charcount = charcount + len(te) + (sp > 0)
+ width = width + wi + sp
+ lsp = sp
+ stretch = stretch + st
+ lst = st
+ ascent = max(ascent, as)
+ descent = max(descent, de)
+ i = i+1
+ while i > j and type(words[i-1]) is Int and \
+ words[i-1] > 0: i = i-1
+ width = width - lsp
+ if i < n:
+ stretch = stretch - lst
+ else:
+ stretch = 0
+ tuple = i-j, firstfont, charcount, width, stretch, \
+ ascent, descent
+ lines.append(tuple)
+ height = height + ascent + descent
+ avail = avail1
+ self.height = height
+ #
+ # Call a function for all words in a line
+ def visit(self, wordfunc, anchorfunc):
+ avail1 = self.width - self.indent_left - self.indent_right
+ avail = avail1 - self.indent_hang
+ v = self.top
+ i = 0
+ for tuple in self.lines:
+ wordcount, firstfont, charcount, width, stretch, \
+ ascent, descent = tuple
+ h = self.left + self.indent_left
+ if i == 0: h = h + self.indent_hang
+ extra = 0
+ if self.just == 'r': h = h + avail - width
+ elif self.just == 'c': h = h + (avail - width) / 2
+ elif self.just == 'lr' and stretch > 0:
+ extra = avail - width
+ v2 = v + ascent + descent
+ for j in range(i, i+wordcount):
+ word = self.words[j]
+ if type(word) is Int:
+ ok = anchorfunc(self, tuple, word, \
+ h, v)
+ if ok is not None: return ok
+ continue
+ fo, te, wi, sp, st, as, de = word
+ if extra > 0 and stretch > 0:
+ ex = extra * st / stretch
+ extra = extra - ex
+ stretch = stretch - st
+ else:
+ ex = 0
+ h2 = h + wi + sp + ex
+ ok = wordfunc(self, tuple, word, h, v, \
+ h2, v2, (j==i), (j==i+wordcount-1))
+ if ok is not None: return ok
+ h = h2
+ v = v2
+ i = i + wordcount
+ avail = avail1
+ #
+ # Render a paragraph in "drawing object" d, using the rectangle
+ # given by (left, top, right) with an unspecified bottom.
+ # Return the computed bottom of the text.
+ def render(self, d, left, top, right):
+ if self.width != right-left:
+ self.layout(right-left)
+ self.left = left
+ self.top = top
+ self.right = right
+ self.bottom = self.top + self.height
+ self.anchorid = 0
+ try:
+ self.d = d
+ self.visit(self.__class__._renderword, \
+ self.__class__._renderanchor)
+ finally:
+ self.d = None
+ return self.bottom
+ #
+ def _renderword(self, tuple, word, h, v, h2, v2, isfirst, islast):
+ if word[0] is not None: self.d.setfont(word[0])
+ baseline = v + tuple[5]
+ self.d.text((h, baseline - word[5]), word[1])
+ if self.anchorid > 0:
+ self.d.line((h, baseline+2), (h2, baseline+2))
+ #
+ def _renderanchor(self, tuple, word, h, v):
+ self.anchorid = word
+ #
+ # Return which anchor(s) was hit by the mouse
+ def hitcheck(self, mouseh, mousev):
+ self.mouseh = mouseh
+ self.mousev = mousev
+ self.anchorid = 0
+ self.hits = []
+ self.visit(self.__class__._hitcheckword, \
+ self.__class__._hitcheckanchor)
+ return self.hits
+ #
+ def _hitcheckword(self, tuple, word, h, v, h2, v2, isfirst, islast):
+ if self.anchorid > 0 and h <= self.mouseh <= h2 and \
+ v <= self.mousev <= v2:
+ self.hits.append(self.anchorid)
+ #
+ def _hitcheckanchor(self, tuple, word, h, v):
+ self.anchorid = word
+ #
+ # Return whether the given anchor id is present
+ def hasanchor(self, id):
+ return id in self.words or -id in self.words
+ #
+ # Extract the raw text from the word list, substituting one space
+ # for non-empty inter-word space, and terminating with '\n'
+ def extract(self):
+ text = ''
+ for w in self.words:
+ if type(w) is not Int:
+ word = w[1]
+ if w[3]: word = word + ' '
+ text = text + word
+ return text + '\n'
+ #
+ # Return which character position was hit by the mouse, as
+ # an offset in the entire text as returned by extract().
+ # Return None if the mouse was not in this paragraph
+ def whereis(self, d, mouseh, mousev):
+ if mousev < self.top or mousev > self.bottom:
+ return None
+ self.mouseh = mouseh
+ self.mousev = mousev
+ self.lastfont = None
+ self.charcount = 0
+ try:
+ self.d = d
+ return self.visit(self.__class__._whereisword, \
+ self.__class__._whereisanchor)
+ finally:
+ self.d = None
+ #
+ def _whereisword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
+ fo, te, wi, sp, st, as, de = word
+ if fo is not None: self.lastfont = fo
+ h = h1
+ if isfirst: h1 = 0
+ if islast: h2 = 999999
+ if not (v1 <= self.mousev <= v2 and h1 <= self.mouseh <= h2):
+ self.charcount = self.charcount + len(te) + (sp > 0)
+ return
+ if self.lastfont is not None:
+ self.d.setfont(self.lastfont)
+ cc = 0
+ for c in te:
+ cw = self.d.textwidth(c)
+ if self.mouseh <= h + cw/2:
+ return self.charcount + cc
+ cc = cc+1
+ h = h+cw
+ self.charcount = self.charcount + cc
+ if self.mouseh <= (h+h2) / 2:
+ return self.charcount
+ else:
+ return self.charcount + 1
+ #
+ def _whereisanchor(self, tuple, word, h, v):
+ pass
+ #
+ # Return screen position corresponding to position in paragraph.
+ # Return tuple (h, vtop, vbaseline, vbottom).
+ # This is more or less the inverse of whereis()
+ def screenpos(self, d, pos):
+ if pos < 0:
+ ascent, descent = self.lines[0][5:7]
+ return self.left, self.top, self.top + ascent, \
+ self.top + ascent + descent
+ self.pos = pos
+ self.lastfont = None
+ try:
+ self.d = d
+ ok = self.visit(self.__class__._screenposword, \
+ self.__class__._screenposanchor)
+ finally:
+ self.d = None
+ if ok is None:
+ ascent, descent = self.lines[-1][5:7]
+ ok = self.right, self.bottom - ascent - descent, \
+ self.bottom - descent, self.bottom
+ return ok
+ #
+ def _screenposword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
+ fo, te, wi, sp, st, as, de = word
+ if fo is not None: self.lastfont = fo
+ cc = len(te) + (sp > 0)
+ if self.pos > cc:
+ self.pos = self.pos - cc
+ return
+ if self.pos < cc:
+ self.d.setfont(self.lastfont)
+ h = h1 + self.d.textwidth(te[:self.pos])
+ else:
+ h = h2
+ ascent, descent = tuple[5:7]
+ return h, v1, v1+ascent, v2
+ #
+ def _screenposanchor(self, tuple, word, h, v):
+ pass
+ #
+ # Invert the stretch of text between pos1 and pos2.
+ # If pos1 is None, the beginning is implied;
+ # if pos2 is None, the end is implied.
+ # Undoes its own effect when called again with the same arguments
+ def invert(self, d, pos1, pos2):
+ if pos1 is None:
+ pos1 = self.left, self.top, self.top, self.top
+ else:
+ pos1 = self.screenpos(d, pos1)
+ if pos2 is None:
+ pos2 = self.right, self.bottom,self.bottom,self.bottom
+ else:
+ pos2 = self.screenpos(d, pos2)
+ h1, top1, baseline1, bottom1 = pos1
+ h2, top2, baseline2, bottom2 = pos2
+ if bottom1 <= top2:
+ d.invert((h1, top1), (self.right, bottom1))
+ h1 = self.left
+ if bottom1 < top2:
+ d.invert((h1, bottom1), (self.right, top2))
+ top1, bottom1 = top2, bottom2
+ d.invert((h1, top1), (h2, bottom2))
diff --git a/Lib/lib-old/addpack.py b/Lib/lib-old/addpack.py
index 3d09236..2fb2601 100644
--- a/Lib/lib-old/addpack.py
+++ b/Lib/lib-old/addpack.py
@@ -33,35 +33,35 @@
#
# If no directory is found, ImportError is raised.
-_packs = {} # {pack: [pathname, ...], ...}
+_packs = {} # {pack: [pathname, ...], ...}
def addpack(pack, *locations):
- import os
- if os.path.isabs(pack):
- base = os.path.basename(pack)
- else:
- base = pack
- if _packs.has_key(base):
- return
- import sys
- path = []
- for loc in _flatten(locations) + sys.path:
- fn = os.path.join(loc, base)
- if fn not in path and os.path.isdir(fn):
- path.append(fn)
- if pack != base and pack not in path and os.path.isdir(pack):
- path.append(pack)
- if not path: raise ImportError, 'package ' + pack + ' not found'
- _packs[base] = path
- for fn in path:
- if fn not in sys.path:
- sys.path.append(fn)
+ import os
+ if os.path.isabs(pack):
+ base = os.path.basename(pack)
+ else:
+ base = pack
+ if _packs.has_key(base):
+ return
+ import sys
+ path = []
+ for loc in _flatten(locations) + sys.path:
+ fn = os.path.join(loc, base)
+ if fn not in path and os.path.isdir(fn):
+ path.append(fn)
+ if pack != base and pack not in path and os.path.isdir(pack):
+ path.append(pack)
+ if not path: raise ImportError, 'package ' + pack + ' not found'
+ _packs[base] = path
+ for fn in path:
+ if fn not in sys.path:
+ sys.path.append(fn)
def _flatten(locations):
- locs = []
- for loc in locations:
- if type(loc) == type(''):
- locs.append(loc)
- else:
- locs = locs + _flatten(loc)
- return locs
+ locs = []
+ for loc in locations:
+ if type(loc) == type(''):
+ locs.append(loc)
+ else:
+ locs = locs + _flatten(loc)
+ return locs
diff --git a/Lib/lib-old/codehack.py b/Lib/lib-old/codehack.py
index 248205b..0b5e3a1 100644
--- a/Lib/lib-old/codehack.py
+++ b/Lib/lib-old/codehack.py
@@ -36,46 +36,46 @@
_namecache = {} # The cache
def getcodename(co):
- try:
- return co.co_name
- except AttributeError:
- pass
- key = `co` # arbitrary but uniquely identifying string
- if _namecache.has_key(key): return _namecache[key]
- filename = co.co_filename
- code = co.co_code
- name = ''
- if ord(code[0]) == SET_LINENO:
- lineno = ord(code[1]) | ord(code[2]) << 8
- line = linecache.getline(filename, lineno)
- words = line.split()
- if len(words) >= 2 and words[0] in ('def', 'class'):
- name = words[1]
- for i in range(len(name)):
- if name[i] not in identchars:
- name = name[:i]
- break
- _namecache[key] = name
- return name
+ try:
+ return co.co_name
+ except AttributeError:
+ pass
+ key = `co` # arbitrary but uniquely identifying string
+ if _namecache.has_key(key): return _namecache[key]
+ filename = co.co_filename
+ code = co.co_code
+ name = ''
+ if ord(code[0]) == SET_LINENO:
+ lineno = ord(code[1]) | ord(code[2]) << 8
+ line = linecache.getline(filename, lineno)
+ words = line.split()
+ if len(words) >= 2 and words[0] in ('def', 'class'):
+ name = words[1]
+ for i in range(len(name)):
+ if name[i] not in identchars:
+ name = name[:i]
+ break
+ _namecache[key] = name
+ return name
# Use the above routine to find a function's name.
def getfuncname(func):
- try:
- return func.func_name
- except AttributeError:
- pass
- return getcodename(func.func_code)
+ try:
+ return func.func_name
+ except AttributeError:
+ pass
+ return getcodename(func.func_code)
# A part of the above code to extract just the line number from a code object.
def getlineno(co):
- try:
- return co.co_firstlineno
- except AttributeError:
- pass
- code = co.co_code
- if ord(code[0]) == SET_LINENO:
- return ord(code[1]) | ord(code[2]) << 8
- else:
- return -1
+ try:
+ return co.co_firstlineno
+ except AttributeError:
+ pass
+ code = co.co_code
+ if ord(code[0]) == SET_LINENO:
+ return ord(code[1]) | ord(code[2]) << 8
+ else:
+ return -1
diff --git a/Lib/lib-old/dump.py b/Lib/lib-old/dump.py
index ec895b7..60bdba8 100644
--- a/Lib/lib-old/dump.py
+++ b/Lib/lib-old/dump.py
@@ -23,41 +23,41 @@
# Dump a whole symbol table
#
def dumpsymtab(dict):
- for key in dict.keys():
- dumpvar(key, dict[key])
+ for key in dict.keys():
+ dumpvar(key, dict[key])
# Dump a single variable
#
def dumpvar(name, x):
- import sys
- t = type(x)
- if t == type({}):
- print name, '= {}'
- for key in x.keys():
- item = x[key]
- if not printable(item):
- print '#',
- print name, '[', `key`, '] =', `item`
- elif t in (type(''), type(0), type(0.0), type([]), type(())):
- if not printable(x):
- print '#',
- print name, '=', `x`
- elif t == type(sys):
- print 'import', name, '#', x
- else:
- print '#', name, '=', x
+ import sys
+ t = type(x)
+ if t == type({}):
+ print name, '= {}'
+ for key in x.keys():
+ item = x[key]
+ if not printable(item):
+ print '#',
+ print name, '[', `key`, '] =', `item`
+ elif t in (type(''), type(0), type(0.0), type([]), type(())):
+ if not printable(x):
+ print '#',
+ print name, '=', `x`
+ elif t == type(sys):
+ print 'import', name, '#', x
+ else:
+ print '#', name, '=', x
# check if a value is printable in a way that can be read back with input()
#
def printable(x):
- t = type(x)
- if t in (type(''), type(0), type(0.0)):
- return 1
- if t in (type([]), type(())):
- for item in x:
- if not printable(item):
- return 0
- return 1
- if x == {}:
- return 1
- return 0
+ t = type(x)
+ if t in (type(''), type(0), type(0.0)):
+ return 1
+ if t in (type([]), type(())):
+ for item in x:
+ if not printable(item):
+ return 0
+ return 1
+ if x == {}:
+ return 1
+ return 0
diff --git a/Lib/lib-old/find.py b/Lib/lib-old/find.py
index ccd9fdb..39ad771 100644
--- a/Lib/lib-old/find.py
+++ b/Lib/lib-old/find.py
@@ -6,21 +6,21 @@
_prune = ['(*)']
def find(pattern, dir = os.curdir):
- list = []
- names = os.listdir(dir)
- names.sort()
- for name in names:
- if name in (os.curdir, os.pardir):
- continue
- fullname = os.path.join(dir, name)
- if fnmatch.fnmatch(name, pattern):
- list.append(fullname)
- if os.path.isdir(fullname) and not os.path.islink(fullname):
- for p in _prune:
- if fnmatch.fnmatch(name, p):
- if _debug: print "skip", `fullname`
- break
- else:
- if _debug: print "descend into", `fullname`
- list = list + find(pattern, fullname)
- return list
+ list = []
+ names = os.listdir(dir)
+ names.sort()
+ for name in names:
+ if name in (os.curdir, os.pardir):
+ continue
+ fullname = os.path.join(dir, name)
+ if fnmatch.fnmatch(name, pattern):
+ list.append(fullname)
+ if os.path.isdir(fullname) and not os.path.islink(fullname):
+ for p in _prune:
+ if fnmatch.fnmatch(name, p):
+ if _debug: print "skip", `fullname`
+ break
+ else:
+ if _debug: print "descend into", `fullname`
+ list = list + find(pattern, fullname)
+ return list
diff --git a/Lib/lib-old/fmt.py b/Lib/lib-old/fmt.py
index dfea987..997d37a 100644
--- a/Lib/lib-old/fmt.py
+++ b/Lib/lib-old/fmt.py
@@ -12,96 +12,96 @@
# Formatter back-end to do nothing at all with the paragraphs
class NullBackEnd:
- #
- def __init__(self):
- pass
- #
- def addpara(self, p):
- pass
- #
- def bgn_anchor(self, id):
- pass
- #
- def end_anchor(self, id):
- pass
+ #
+ def __init__(self):
+ pass
+ #
+ def addpara(self, p):
+ pass
+ #
+ def bgn_anchor(self, id):
+ pass
+ #
+ def end_anchor(self, id):
+ pass
# Formatter back-end to collect the paragraphs in a list
class SavingBackEnd(NullBackEnd):
- #
- def __init__(self):
- self.paralist = []
- #
- def addpara(self, p):
- self.paralist.append(p)
- #
- def hitcheck(self, h, v):
- hits = []
- for p in self.paralist:
- if p.top <= v <= p.bottom:
- for id in p.hitcheck(h, v):
- if id not in hits:
- hits.append(id)
- return hits
- #
- def extract(self):
- text = ''
- for p in self.paralist:
- text = text + (p.extract())
- return text
- #
- def extractpart(self, long1, long2):
- if long1 > long2: long1, long2 = long2, long1
- para1, pos1 = long1
- para2, pos2 = long2
- text = ''
- while para1 < para2:
- ptext = self.paralist[para1].extract()
- text = text + ptext[pos1:]
- pos1 = 0
- para1 = para1 + 1
- ptext = self.paralist[para2].extract()
- return text + ptext[pos1:pos2]
- #
- def whereis(self, d, h, v):
- total = 0
- for i in range(len(self.paralist)):
- p = self.paralist[i]
- result = p.whereis(d, h, v)
- if result is not None:
- return i, result
- return None
- #
- def roundtowords(self, long1, long2):
- i, offset = long1
- text = self.paralist[i].extract()
- while offset > 0 and text[offset-1] != ' ': offset = offset-1
- long1 = i, offset
- #
- i, offset = long2
- text = self.paralist[i].extract()
- n = len(text)
- while offset < n-1 and text[offset] != ' ': offset = offset+1
- long2 = i, offset
- #
- return long1, long2
- #
- def roundtoparagraphs(self, long1, long2):
- long1 = long1[0], 0
- long2 = long2[0], len(self.paralist[long2[0]].extract())
- return long1, long2
+ #
+ def __init__(self):
+ self.paralist = []
+ #
+ def addpara(self, p):
+ self.paralist.append(p)
+ #
+ def hitcheck(self, h, v):
+ hits = []
+ for p in self.paralist:
+ if p.top <= v <= p.bottom:
+ for id in p.hitcheck(h, v):
+ if id not in hits:
+ hits.append(id)
+ return hits
+ #
+ def extract(self):
+ text = ''
+ for p in self.paralist:
+ text = text + (p.extract())
+ return text
+ #
+ def extractpart(self, long1, long2):
+ if long1 > long2: long1, long2 = long2, long1
+ para1, pos1 = long1
+ para2, pos2 = long2
+ text = ''
+ while para1 < para2:
+ ptext = self.paralist[para1].extract()
+ text = text + ptext[pos1:]
+ pos1 = 0
+ para1 = para1 + 1
+ ptext = self.paralist[para2].extract()
+ return text + ptext[pos1:pos2]
+ #
+ def whereis(self, d, h, v):
+ total = 0
+ for i in range(len(self.paralist)):
+ p = self.paralist[i]
+ result = p.whereis(d, h, v)
+ if result is not None:
+ return i, result
+ return None
+ #
+ def roundtowords(self, long1, long2):
+ i, offset = long1
+ text = self.paralist[i].extract()
+ while offset > 0 and text[offset-1] != ' ': offset = offset-1
+ long1 = i, offset
+ #
+ i, offset = long2
+ text = self.paralist[i].extract()
+ n = len(text)
+ while offset < n-1 and text[offset] != ' ': offset = offset+1
+ long2 = i, offset
+ #
+ return long1, long2
+ #
+ def roundtoparagraphs(self, long1, long2):
+ long1 = long1[0], 0
+ long2 = long2[0], len(self.paralist[long2[0]].extract())
+ return long1, long2
# Formatter back-end to send the text directly to the drawing object
class WritingBackEnd(NullBackEnd):
- #
- def __init__(self, d, width):
- self.d = d
- self.width = width
- self.lineno = 0
- #
- def addpara(self, p):
- self.lineno = p.render(self.d, 0, self.lineno, self.width)
+ #
+ def __init__(self, d, width):
+ self.d = d
+ self.width = width
+ self.lineno = 0
+ #
+ def addpara(self, p):
+ self.lineno = p.render(self.d, 0, self.lineno, self.width)
# A formatter receives a stream of formatting instructions and assembles
@@ -125,192 +125,192 @@
# needvspace(nlines)
# addword(word, nspaces)
class BaseFormatter:
- #
- def __init__(self, d, b):
- # Drawing object used for text measurements
- self.d = d
- #
- # BackEnd object receiving completed paragraphs
- self.b = b
- #
- # Parameters of the formatting model
- self.leftindent = 0
- self.just = 'l'
- self.font = None
- self.blanklines = 0
- #
- # Parameters derived from the current font
- self.space = d.textwidth(' ')
- self.line = d.lineheight()
- self.ascent = d.baseline()
- self.descent = self.line - self.ascent
- #
- # Parameter derived from the default font
- self.n_space = self.space
- #
- # Current paragraph being built
- self.para = None
- self.nospace = 1
- #
- # Font to set on the next word
- self.nextfont = None
- #
- def newpara(self):
- return Para.Para()
- #
- def setfont(self, font):
- if font is None: return
- self.font = self.nextfont = font
- d = self.d
- d.setfont(font)
- self.space = d.textwidth(' ')
- self.line = d.lineheight()
- self.ascent = d.baseline()
- self.descent = self.line - self.ascent
- #
- def setleftindent(self, nspaces):
- self.leftindent = int(self.n_space * nspaces)
- if self.para:
- hang = self.leftindent - self.para.indent_left
- if hang > 0 and self.para.getlength() <= hang:
- self.para.makehangingtag(hang)
- self.nospace = 1
- else:
- self.flush()
- #
- def setrightindent(self, nspaces):
- self.rightindent = int(self.n_space * nspaces)
- if self.para:
- self.para.indent_right = self.rightindent
- self.flush()
- #
- def setjust(self, just):
- self.just = just
- if self.para:
- self.para.just = self.just
- #
- def flush(self):
- if self.para:
- self.b.addpara(self.para)
- self.para = None
- if self.font is not None:
- self.d.setfont(self.font)
- self.nospace = 1
- #
- def vspace(self, nlines):
- self.flush()
- if nlines > 0:
- self.para = self.newpara()
- tuple = None, '', 0, 0, 0, int(nlines*self.line), 0
- self.para.words.append(tuple)
- self.flush()
- self.blanklines = self.blanklines + nlines
- #
- def needvspace(self, nlines):
- self.flush() # Just to be sure
- if nlines > self.blanklines:
- self.vspace(nlines - self.blanklines)
- #
- def addword(self, text, space):
- if self.nospace and not text:
- return
- self.nospace = 0
- self.blanklines = 0
- if not self.para:
- self.para = self.newpara()
- self.para.indent_left = self.leftindent
- self.para.just = self.just
- self.nextfont = self.font
- space = int(space * self.space)
- self.para.words.append((self.nextfont, text,
- self.d.textwidth(text), space, space,
- self.ascent, self.descent))
- self.nextfont = None
- #
- def bgn_anchor(self, id):
- if not self.para:
- self.nospace = 0
- self.addword('', 0)
- self.para.bgn_anchor(id)
- #
- def end_anchor(self, id):
- if not self.para:
- self.nospace = 0
- self.addword('', 0)
- self.para.end_anchor(id)
+ #
+ def __init__(self, d, b):
+ # Drawing object used for text measurements
+ self.d = d
+ #
+ # BackEnd object receiving completed paragraphs
+ self.b = b
+ #
+ # Parameters of the formatting model
+ self.leftindent = 0
+ self.just = 'l'
+ self.font = None
+ self.blanklines = 0
+ #
+ # Parameters derived from the current font
+ self.space = d.textwidth(' ')
+ self.line = d.lineheight()
+ self.ascent = d.baseline()
+ self.descent = self.line - self.ascent
+ #
+ # Parameter derived from the default font
+ self.n_space = self.space
+ #
+ # Current paragraph being built
+ self.para = None
+ self.nospace = 1
+ #
+ # Font to set on the next word
+ self.nextfont = None
+ #
+ def newpara(self):
+ return Para.Para()
+ #
+ def setfont(self, font):
+ if font is None: return
+ self.font = self.nextfont = font
+ d = self.d
+ d.setfont(font)
+ self.space = d.textwidth(' ')
+ self.line = d.lineheight()
+ self.ascent = d.baseline()
+ self.descent = self.line - self.ascent
+ #
+ def setleftindent(self, nspaces):
+ self.leftindent = int(self.n_space * nspaces)
+ if self.para:
+ hang = self.leftindent - self.para.indent_left
+ if hang > 0 and self.para.getlength() <= hang:
+ self.para.makehangingtag(hang)
+ self.nospace = 1
+ else:
+ self.flush()
+ #
+ def setrightindent(self, nspaces):
+ self.rightindent = int(self.n_space * nspaces)
+ if self.para:
+ self.para.indent_right = self.rightindent
+ self.flush()
+ #
+ def setjust(self, just):
+ self.just = just
+ if self.para:
+ self.para.just = self.just
+ #
+ def flush(self):
+ if self.para:
+ self.b.addpara(self.para)
+ self.para = None
+ if self.font is not None:
+ self.d.setfont(self.font)
+ self.nospace = 1
+ #
+ def vspace(self, nlines):
+ self.flush()
+ if nlines > 0:
+ self.para = self.newpara()
+ tuple = None, '', 0, 0, 0, int(nlines*self.line), 0
+ self.para.words.append(tuple)
+ self.flush()
+ self.blanklines = self.blanklines + nlines
+ #
+ def needvspace(self, nlines):
+ self.flush() # Just to be sure
+ if nlines > self.blanklines:
+ self.vspace(nlines - self.blanklines)
+ #
+ def addword(self, text, space):
+ if self.nospace and not text:
+ return
+ self.nospace = 0
+ self.blanklines = 0
+ if not self.para:
+ self.para = self.newpara()
+ self.para.indent_left = self.leftindent
+ self.para.just = self.just
+ self.nextfont = self.font
+ space = int(space * self.space)
+ self.para.words.append((self.nextfont, text,
+ self.d.textwidth(text), space, space,
+ self.ascent, self.descent))
+ self.nextfont = None
+ #
+ def bgn_anchor(self, id):
+ if not self.para:
+ self.nospace = 0
+ self.addword('', 0)
+ self.para.bgn_anchor(id)
+ #
+ def end_anchor(self, id):
+ if not self.para:
+ self.nospace = 0
+ self.addword('', 0)
+ self.para.end_anchor(id)
# Measuring object for measuring text as viewed on a tty
class NullMeasurer:
- #
- def __init__(self):
- pass
- #
- def setfont(self, font):
- pass
- #
- def textwidth(self, text):
- return len(text)
- #
- def lineheight(self):
- return 1
- #
- def baseline(self):
- return 0
+ #
+ def __init__(self):
+ pass
+ #
+ def setfont(self, font):
+ pass
+ #
+ def textwidth(self, text):
+ return len(text)
+ #
+ def lineheight(self):
+ return 1
+ #
+ def baseline(self):
+ return 0
# Drawing object for writing plain ASCII text to a file
class FileWriter:
- #
- def __init__(self, fp):
- self.fp = fp
- self.lineno, self.colno = 0, 0
- #
- def setfont(self, font):
- pass
- #
- def text(self, (h, v), str):
- if not str: return
- if '\n' in str:
- raise ValueError, 'can\'t write \\n'
- while self.lineno < v:
- self.fp.write('\n')
- self.colno, self.lineno = 0, self.lineno + 1
- while self.lineno > v:
- # XXX This should never happen...
- self.fp.write('\033[A') # ANSI up arrow
- self.lineno = self.lineno - 1
- if self.colno < h:
- self.fp.write(' ' * (h - self.colno))
- elif self.colno > h:
- self.fp.write('\b' * (self.colno - h))
- self.colno = h
- self.fp.write(str)
- self.colno = h + len(str)
+ #
+ def __init__(self, fp):
+ self.fp = fp
+ self.lineno, self.colno = 0, 0
+ #
+ def setfont(self, font):
+ pass
+ #
+ def text(self, (h, v), str):
+ if not str: return
+ if '\n' in str:
+ raise ValueError, 'can\'t write \\n'
+ while self.lineno < v:
+ self.fp.write('\n')
+ self.colno, self.lineno = 0, self.lineno + 1
+ while self.lineno > v:
+ # XXX This should never happen...
+ self.fp.write('\033[A') # ANSI up arrow
+ self.lineno = self.lineno - 1
+ if self.colno < h:
+ self.fp.write(' ' * (h - self.colno))
+ elif self.colno > h:
+ self.fp.write('\b' * (self.colno - h))
+ self.colno = h
+ self.fp.write(str)
+ self.colno = h + len(str)
# Formatting class to do nothing at all with the data
class NullFormatter(BaseFormatter):
- #
- def __init__(self):
- d = NullMeasurer()
- b = NullBackEnd()
- BaseFormatter.__init__(self, d, b)
+ #
+ def __init__(self):
+ d = NullMeasurer()
+ b = NullBackEnd()
+ BaseFormatter.__init__(self, d, b)
# Formatting class to write directly to a file
class WritingFormatter(BaseFormatter):
- #
- def __init__(self, fp, width):
- dm = NullMeasurer()
- dw = FileWriter(fp)
- b = WritingBackEnd(dw, width)
- BaseFormatter.__init__(self, dm, b)
- self.blanklines = 1
- #
- # Suppress multiple blank lines
- def needvspace(self, nlines):
- BaseFormatter.needvspace(self, min(1, nlines))
+ #
+ def __init__(self, fp, width):
+ dm = NullMeasurer()
+ dw = FileWriter(fp)
+ b = WritingBackEnd(dw, width)
+ BaseFormatter.__init__(self, dm, b)
+ self.blanklines = 1
+ #
+ # Suppress multiple blank lines
+ def needvspace(self, nlines):
+ BaseFormatter.needvspace(self, min(1, nlines))
# A "FunnyFormatter" writes ASCII text with a twist: *bold words*,
@@ -320,10 +320,10 @@
# Moreover, if the font is in upper case, the text is converted to
# UPPER CASE.
class FunnyFormatter(WritingFormatter):
- #
- def flush(self):
- if self.para: finalize(self.para)
- WritingFormatter.flush(self)
+ #
+ def flush(self):
+ if self.para: finalize(self.para)
+ WritingFormatter.flush(self)
# Surrounds *bold words* and _italic text_ in a paragraph with
@@ -334,33 +334,33 @@
closechar = \
{'b':'*', 'i':'_', 'u':'_', 'q':'\'', 'B':'*', 'I':'_', 'U':'_', 'Q':'\''}
def finalize(para):
- oldfont = curfont = 'r'
- para.words.append(('r', '', 0, 0, 0, 0)) # temporary, deleted at end
- for i in range(len(para.words)):
- fo, te, wi = para.words[i][:3]
- if fo is not None: curfont = fo
- if curfont != oldfont:
- if closechar.has_key(oldfont):
- c = closechar[oldfont]
- j = i-1
- while j > 0 and para.words[j][1] == '': j = j-1
- fo1, te1, wi1 = para.words[j][:3]
- te1 = te1 + c
- wi1 = wi1 + len(c)
- para.words[j] = (fo1, te1, wi1) + \
- para.words[j][3:]
- if openchar.has_key(curfont) and te:
- c = openchar[curfont]
- te = c + te
- wi = len(c) + wi
- para.words[i] = (fo, te, wi) + \
- para.words[i][3:]
- if te: oldfont = curfont
- else: oldfont = 'r'
- if curfont in string.uppercase:
- te = string.upper(te)
- para.words[i] = (fo, te, wi) + para.words[i][3:]
- del para.words[-1]
+ oldfont = curfont = 'r'
+ para.words.append(('r', '', 0, 0, 0, 0)) # temporary, deleted at end
+ for i in range(len(para.words)):
+ fo, te, wi = para.words[i][:3]
+ if fo is not None: curfont = fo
+ if curfont != oldfont:
+ if closechar.has_key(oldfont):
+ c = closechar[oldfont]
+ j = i-1
+ while j > 0 and para.words[j][1] == '': j = j-1
+ fo1, te1, wi1 = para.words[j][:3]
+ te1 = te1 + c
+ wi1 = wi1 + len(c)
+ para.words[j] = (fo1, te1, wi1) + \
+ para.words[j][3:]
+ if openchar.has_key(curfont) and te:
+ c = openchar[curfont]
+ te = c + te
+ wi = len(c) + wi
+ para.words[i] = (fo, te, wi) + \
+ para.words[i][3:]
+ if te: oldfont = curfont
+ else: oldfont = 'r'
+ if curfont in string.uppercase:
+ te = string.upper(te)
+ para.words[i] = (fo, te, wi) + para.words[i][3:]
+ del para.words[-1]
# Formatter back-end to draw the text in a window.
@@ -368,256 +368,256 @@
# to minimize the delay before the user sees anything.
# This manages the entire "document" of the window.
class StdwinBackEnd(SavingBackEnd):
- #
- def __init__(self, window, drawnow):
- self.window = window
- self.drawnow = drawnow
- self.width = window.getwinsize()[0]
- self.selection = None
- self.height = 0
- window.setorigin(0, 0)
- window.setdocsize(0, 0)
- self.d = window.begindrawing()
- SavingBackEnd.__init__(self)
- #
- def finish(self):
- self.d.close()
- self.d = None
- self.window.setdocsize(0, self.height)
- #
- def addpara(self, p):
- self.paralist.append(p)
- if self.drawnow:
- self.height = \
- p.render(self.d, 0, self.height, self.width)
- else:
- p.layout(self.width)
- p.left = 0
- p.top = self.height
- p.right = self.width
- p.bottom = self.height + p.height
- self.height = p.bottom
- #
- def resize(self):
- self.window.change((0, 0), (self.width, self.height))
- self.width = self.window.getwinsize()[0]
- self.height = 0
- for p in self.paralist:
- p.layout(self.width)
- p.left = 0
- p.top = self.height
- p.right = self.width
- p.bottom = self.height + p.height
- self.height = p.bottom
- self.window.change((0, 0), (self.width, self.height))
- self.window.setdocsize(0, self.height)
- #
- def redraw(self, area):
- d = self.window.begindrawing()
- (left, top), (right, bottom) = area
- d.erase(area)
- d.cliprect(area)
- for p in self.paralist:
- if top < p.bottom and p.top < bottom:
- v = p.render(d, p.left, p.top, p.right)
- if self.selection:
- self.invert(d, self.selection)
- d.close()
- #
- def setselection(self, new):
- if new:
- long1, long2 = new
- pos1 = long1[:3]
- pos2 = long2[:3]
- new = pos1, pos2
- if new != self.selection:
- d = self.window.begindrawing()
- if self.selection:
- self.invert(d, self.selection)
- if new:
- self.invert(d, new)
- d.close()
- self.selection = new
- #
- def getselection(self):
- return self.selection
- #
- def extractselection(self):
- if self.selection:
- a, b = self.selection
- return self.extractpart(a, b)
- else:
- return None
- #
- def invert(self, d, region):
- long1, long2 = region
- if long1 > long2: long1, long2 = long2, long1
- para1, pos1 = long1
- para2, pos2 = long2
- while para1 < para2:
- self.paralist[para1].invert(d, pos1, None)
- pos1 = None
- para1 = para1 + 1
- self.paralist[para2].invert(d, pos1, pos2)
- #
- def search(self, prog):
- import re, string
- if type(prog) is type(''):
- prog = re.compile(string.lower(prog))
- if self.selection:
- iold = self.selection[0][0]
- else:
- iold = -1
- hit = None
- for i in range(len(self.paralist)):
- if i == iold or i < iold and hit:
- continue
- p = self.paralist[i]
- text = string.lower(p.extract())
- match = prog.search(text)
- if match:
- a, b = match.group(0)
- long1 = i, a
- long2 = i, b
- hit = long1, long2
- if i > iold:
- break
- if hit:
- self.setselection(hit)
- i = hit[0][0]
- p = self.paralist[i]
- self.window.show((p.left, p.top), (p.right, p.bottom))
- return 1
- else:
- return 0
- #
- def showanchor(self, id):
- for i in range(len(self.paralist)):
- p = self.paralist[i]
- if p.hasanchor(id):
- long1 = i, 0
- long2 = i, len(p.extract())
- hit = long1, long2
- self.setselection(hit)
- self.window.show(
- (p.left, p.top), (p.right, p.bottom))
- break
+ #
+ def __init__(self, window, drawnow):
+ self.window = window
+ self.drawnow = drawnow
+ self.width = window.getwinsize()[0]
+ self.selection = None
+ self.height = 0
+ window.setorigin(0, 0)
+ window.setdocsize(0, 0)
+ self.d = window.begindrawing()
+ SavingBackEnd.__init__(self)
+ #
+ def finish(self):
+ self.d.close()
+ self.d = None
+ self.window.setdocsize(0, self.height)
+ #
+ def addpara(self, p):
+ self.paralist.append(p)
+ if self.drawnow:
+ self.height = \
+ p.render(self.d, 0, self.height, self.width)
+ else:
+ p.layout(self.width)
+ p.left = 0
+ p.top = self.height
+ p.right = self.width
+ p.bottom = self.height + p.height
+ self.height = p.bottom
+ #
+ def resize(self):
+ self.window.change((0, 0), (self.width, self.height))
+ self.width = self.window.getwinsize()[0]
+ self.height = 0
+ for p in self.paralist:
+ p.layout(self.width)
+ p.left = 0
+ p.top = self.height
+ p.right = self.width
+ p.bottom = self.height + p.height
+ self.height = p.bottom
+ self.window.change((0, 0), (self.width, self.height))
+ self.window.setdocsize(0, self.height)
+ #
+ def redraw(self, area):
+ d = self.window.begindrawing()
+ (left, top), (right, bottom) = area
+ d.erase(area)
+ d.cliprect(area)
+ for p in self.paralist:
+ if top < p.bottom and p.top < bottom:
+ v = p.render(d, p.left, p.top, p.right)
+ if self.selection:
+ self.invert(d, self.selection)
+ d.close()
+ #
+ def setselection(self, new):
+ if new:
+ long1, long2 = new
+ pos1 = long1[:3]
+ pos2 = long2[:3]
+ new = pos1, pos2
+ if new != self.selection:
+ d = self.window.begindrawing()
+ if self.selection:
+ self.invert(d, self.selection)
+ if new:
+ self.invert(d, new)
+ d.close()
+ self.selection = new
+ #
+ def getselection(self):
+ return self.selection
+ #
+ def extractselection(self):
+ if self.selection:
+ a, b = self.selection
+ return self.extractpart(a, b)
+ else:
+ return None
+ #
+ def invert(self, d, region):
+ long1, long2 = region
+ if long1 > long2: long1, long2 = long2, long1
+ para1, pos1 = long1
+ para2, pos2 = long2
+ while para1 < para2:
+ self.paralist[para1].invert(d, pos1, None)
+ pos1 = None
+ para1 = para1 + 1
+ self.paralist[para2].invert(d, pos1, pos2)
+ #
+ def search(self, prog):
+ import re, string
+ if type(prog) is type(''):
+ prog = re.compile(string.lower(prog))
+ if self.selection:
+ iold = self.selection[0][0]
+ else:
+ iold = -1
+ hit = None
+ for i in range(len(self.paralist)):
+ if i == iold or i < iold and hit:
+ continue
+ p = self.paralist[i]
+ text = string.lower(p.extract())
+ match = prog.search(text)
+ if match:
+ a, b = match.group(0)
+ long1 = i, a
+ long2 = i, b
+ hit = long1, long2
+ if i > iold:
+ break
+ if hit:
+ self.setselection(hit)
+ i = hit[0][0]
+ p = self.paralist[i]
+ self.window.show((p.left, p.top), (p.right, p.bottom))
+ return 1
+ else:
+ return 0
+ #
+ def showanchor(self, id):
+ for i in range(len(self.paralist)):
+ p = self.paralist[i]
+ if p.hasanchor(id):
+ long1 = i, 0
+ long2 = i, len(p.extract())
+ hit = long1, long2
+ self.setselection(hit)
+ self.window.show(
+ (p.left, p.top), (p.right, p.bottom))
+ break
# GL extensions
class GLFontCache:
- #
- def __init__(self):
- self.reset()
- self.setfont('')
- #
- def reset(self):
- self.fontkey = None
- self.fonthandle = None
- self.fontinfo = None
- self.fontcache = {}
- #
- def close(self):
- self.reset()
- #
- def setfont(self, fontkey):
- if fontkey == '':
- fontkey = 'Times-Roman 12'
- elif ' ' not in fontkey:
- fontkey = fontkey + ' 12'
- if fontkey == self.fontkey:
- return
- if self.fontcache.has_key(fontkey):
- handle = self.fontcache[fontkey]
- else:
- import string
- i = string.index(fontkey, ' ')
- name, sizestr = fontkey[:i], fontkey[i:]
- size = eval(sizestr)
- key1 = name + ' 1'
- key = name + ' ' + `size`
- # NB key may differ from fontkey!
- if self.fontcache.has_key(key):
- handle = self.fontcache[key]
- else:
- if self.fontcache.has_key(key1):
- handle = self.fontcache[key1]
- else:
- import fm
- handle = fm.findfont(name)
- self.fontcache[key1] = handle
- handle = handle.scalefont(size)
- self.fontcache[fontkey] = \
- self.fontcache[key] = handle
- self.fontkey = fontkey
- if self.fonthandle != handle:
- self.fonthandle = handle
- self.fontinfo = handle.getfontinfo()
- handle.setfont()
+ #
+ def __init__(self):
+ self.reset()
+ self.setfont('')
+ #
+ def reset(self):
+ self.fontkey = None
+ self.fonthandle = None
+ self.fontinfo = None
+ self.fontcache = {}
+ #
+ def close(self):
+ self.reset()
+ #
+ def setfont(self, fontkey):
+ if fontkey == '':
+ fontkey = 'Times-Roman 12'
+ elif ' ' not in fontkey:
+ fontkey = fontkey + ' 12'
+ if fontkey == self.fontkey:
+ return
+ if self.fontcache.has_key(fontkey):
+ handle = self.fontcache[fontkey]
+ else:
+ import string
+ i = string.index(fontkey, ' ')
+ name, sizestr = fontkey[:i], fontkey[i:]
+ size = eval(sizestr)
+ key1 = name + ' 1'
+ key = name + ' ' + `size`
+ # NB key may differ from fontkey!
+ if self.fontcache.has_key(key):
+ handle = self.fontcache[key]
+ else:
+ if self.fontcache.has_key(key1):
+ handle = self.fontcache[key1]
+ else:
+ import fm
+ handle = fm.findfont(name)
+ self.fontcache[key1] = handle
+ handle = handle.scalefont(size)
+ self.fontcache[fontkey] = \
+ self.fontcache[key] = handle
+ self.fontkey = fontkey
+ if self.fonthandle != handle:
+ self.fonthandle = handle
+ self.fontinfo = handle.getfontinfo()
+ handle.setfont()
class GLMeasurer(GLFontCache):
- #
- def textwidth(self, text):
- return self.fonthandle.getstrwidth(text)
- #
- def baseline(self):
- return self.fontinfo[6] - self.fontinfo[3]
- #
- def lineheight(self):
- return self.fontinfo[6]
+ #
+ def textwidth(self, text):
+ return self.fonthandle.getstrwidth(text)
+ #
+ def baseline(self):
+ return self.fontinfo[6] - self.fontinfo[3]
+ #
+ def lineheight(self):
+ return self.fontinfo[6]
class GLWriter(GLFontCache):
- #
- # NOTES:
- # (1) Use gl.ortho2 to use X pixel coordinates!
- #
- def text(self, (h, v), text):
- import gl, fm
- gl.cmov2i(h, v + self.fontinfo[6] - self.fontinfo[3])
- fm.prstr(text)
- #
- def setfont(self, fontkey):
- oldhandle = self.fonthandle
- GLFontCache.setfont(fontkey)
- if self.fonthandle != oldhandle:
- handle.setfont()
+ #
+ # NOTES:
+ # (1) Use gl.ortho2 to use X pixel coordinates!
+ #
+ def text(self, (h, v), text):
+ import gl, fm
+ gl.cmov2i(h, v + self.fontinfo[6] - self.fontinfo[3])
+ fm.prstr(text)
+ #
+ def setfont(self, fontkey):
+ oldhandle = self.fonthandle
+ GLFontCache.setfont(fontkey)
+ if self.fonthandle != oldhandle:
+ handle.setfont()
class GLMeasurerWriter(GLMeasurer, GLWriter):
- pass
+ pass
class GLBackEnd(SavingBackEnd):
- #
- def __init__(self, wid):
- import gl
- gl.winset(wid)
- self.wid = wid
- self.width = gl.getsize()[1]
- self.height = 0
- self.d = GLMeasurerWriter()
- SavingBackEnd.__init__(self)
- #
- def finish(self):
- pass
- #
- def addpara(self, p):
- self.paralist.append(p)
- self.height = p.render(self.d, 0, self.height, self.width)
- #
- def redraw(self):
- import gl
- gl.winset(self.wid)
- width = gl.getsize()[1]
- if width != self.width:
- setdocsize = 1
- self.width = width
- for p in self.paralist:
- p.top = p.bottom = None
- d = self.d
- v = 0
- for p in self.paralist:
- v = p.render(d, 0, v, width)
+ #
+ def __init__(self, wid):
+ import gl
+ gl.winset(wid)
+ self.wid = wid
+ self.width = gl.getsize()[1]
+ self.height = 0
+ self.d = GLMeasurerWriter()
+ SavingBackEnd.__init__(self)
+ #
+ def finish(self):
+ pass
+ #
+ def addpara(self, p):
+ self.paralist.append(p)
+ self.height = p.render(self.d, 0, self.height, self.width)
+ #
+ def redraw(self):
+ import gl
+ gl.winset(self.wid)
+ width = gl.getsize()[1]
+ if width != self.width:
+ setdocsize = 1
+ self.width = width
+ for p in self.paralist:
+ p.top = p.bottom = None
+ d = self.d
+ v = 0
+ for p in self.paralist:
+ v = p.render(d, 0, v, width)
diff --git a/Lib/lib-old/grep.py b/Lib/lib-old/grep.py
index bdefbe6..2926746 100644
--- a/Lib/lib-old/grep.py
+++ b/Lib/lib-old/grep.py
@@ -8,72 +8,72 @@
opt_show_lineno = 1
def grep(pat, *files):
- return ggrep(RE_SYNTAX_GREP, pat, files)
+ return ggrep(RE_SYNTAX_GREP, pat, files)
def egrep(pat, *files):
- return ggrep(RE_SYNTAX_EGREP, pat, files)
+ return ggrep(RE_SYNTAX_EGREP, pat, files)
def emgrep(pat, *files):
- return ggrep(RE_SYNTAX_EMACS, pat, files)
+ return ggrep(RE_SYNTAX_EMACS, pat, files)
def ggrep(syntax, pat, files):
- if len(files) == 1 and type(files[0]) == type([]):
- files = files[0]
- global opt_show_filename
- opt_show_filename = (len(files) != 1)
- syntax = regex.set_syntax(syntax)
- try:
- prog = regex.compile(pat)
- finally:
- syntax = regex.set_syntax(syntax)
- for filename in files:
- fp = open(filename, 'r')
- lineno = 0
- while 1:
- line = fp.readline()
- if not line: break
- lineno = lineno + 1
- if prog.search(line) >= 0:
- showline(filename, lineno, line, prog)
- fp.close()
+ if len(files) == 1 and type(files[0]) == type([]):
+ files = files[0]
+ global opt_show_filename
+ opt_show_filename = (len(files) != 1)
+ syntax = regex.set_syntax(syntax)
+ try:
+ prog = regex.compile(pat)
+ finally:
+ syntax = regex.set_syntax(syntax)
+ for filename in files:
+ fp = open(filename, 'r')
+ lineno = 0
+ while 1:
+ line = fp.readline()
+ if not line: break
+ lineno = lineno + 1
+ if prog.search(line) >= 0:
+ showline(filename, lineno, line, prog)
+ fp.close()
def pgrep(pat, *files):
- if len(files) == 1 and type(files[0]) == type([]):
- files = files[0]
- global opt_show_filename
- opt_show_filename = (len(files) != 1)
- import re
- prog = re.compile(pat)
- for filename in files:
- fp = open(filename, 'r')
- lineno = 0
- while 1:
- line = fp.readline()
- if not line: break
- lineno = lineno + 1
- if prog.search(line):
- showline(filename, lineno, line, prog)
- fp.close()
+ if len(files) == 1 and type(files[0]) == type([]):
+ files = files[0]
+ global opt_show_filename
+ opt_show_filename = (len(files) != 1)
+ import re
+ prog = re.compile(pat)
+ for filename in files:
+ fp = open(filename, 'r')
+ lineno = 0
+ while 1:
+ line = fp.readline()
+ if not line: break
+ lineno = lineno + 1
+ if prog.search(line):
+ showline(filename, lineno, line, prog)
+ fp.close()
def showline(filename, lineno, line, prog):
- if line[-1:] == '\n': line = line[:-1]
- if opt_show_lineno:
- prefix = `lineno`.rjust(3) + ': '
- else:
- prefix = ''
- if opt_show_filename:
- prefix = filename + ': ' + prefix
- print prefix + line
- if opt_show_where:
- start, end = prog.regs()[0]
- line = line[:start]
- if '\t' not in line:
- prefix = ' ' * (len(prefix) + start)
- else:
- prefix = ' ' * len(prefix)
- for c in line:
- if c != '\t': c = ' '
- prefix = prefix + c
- if start == end: prefix = prefix + '\\'
- else: prefix = prefix + '^'*(end-start)
- print prefix
+ if line[-1:] == '\n': line = line[:-1]
+ if opt_show_lineno:
+ prefix = `lineno`.rjust(3) + ': '
+ else:
+ prefix = ''
+ if opt_show_filename:
+ prefix = filename + ': ' + prefix
+ print prefix + line
+ if opt_show_where:
+ start, end = prog.regs()[0]
+ line = line[:start]
+ if '\t' not in line:
+ prefix = ' ' * (len(prefix) + start)
+ else:
+ prefix = ' ' * len(prefix)
+ for c in line:
+ if c != '\t': c = ' '
+ prefix = prefix + c
+ if start == end: prefix = prefix + '\\'
+ else: prefix = prefix + '^'*(end-start)
+ print prefix
diff --git a/Lib/lib-old/lockfile.py b/Lib/lib-old/lockfile.py
index 3aaeac0..cde9b48 100644
--- a/Lib/lib-old/lockfile.py
+++ b/Lib/lib-old/lockfile.py
@@ -1,15 +1,15 @@
import struct, fcntl
def writelock(f):
- _lock(f, fcntl.F_WRLCK)
+ _lock(f, fcntl.F_WRLCK)
def readlock(f):
- _lock(f, fcntl.F_RDLCK)
+ _lock(f, fcntl.F_RDLCK)
def unlock(f):
- _lock(f, fcntl.F_UNLCK)
+ _lock(f, fcntl.F_UNLCK)
def _lock(f, op):
- dummy = fcntl.fcntl(f.fileno(), fcntl.F_SETLKW,
- struct.pack('2h8l', op,
- 0, 0, 0, 0, 0, 0, 0, 0, 0))
+ dummy = fcntl.fcntl(f.fileno(), fcntl.F_SETLKW,
+ struct.pack('2h8l', op,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0))
diff --git a/Lib/lib-old/newdir.py b/Lib/lib-old/newdir.py
index 937c49e..356becc 100644
--- a/Lib/lib-old/newdir.py
+++ b/Lib/lib-old/newdir.py
@@ -5,69 +5,69 @@
# the current local name space by default
def listattrs(x):
- try:
- dictkeys = x.__dict__.keys()
- except (AttributeError, TypeError):
- dictkeys = []
- #
- try:
- methods = x.__methods__
- except (AttributeError, TypeError):
- methods = []
- #
- try:
- members = x.__members__
- except (AttributeError, TypeError):
- members = []
- #
- try:
- the_class = x.__class__
- except (AttributeError, TypeError):
- the_class = None
- #
- try:
- bases = x.__bases__
- except (AttributeError, TypeError):
- bases = ()
- #
- total = dictkeys + methods + members
- if the_class:
- # It's a class instace; add the class's attributes
- # that are functions (methods)...
- class_attrs = listattrs(the_class)
- class_methods = []
- for name in class_attrs:
- if is_function(getattr(the_class, name)):
- class_methods.append(name)
- total = total + class_methods
- elif bases:
- # It's a derived class; add the base class attributes
- for base in bases:
- base_attrs = listattrs(base)
- total = total + base_attrs
- total.sort()
- return total
- i = 0
- while i+1 < len(total):
- if total[i] == total[i+1]:
- del total[i+1]
- else:
- i = i+1
- return total
+ try:
+ dictkeys = x.__dict__.keys()
+ except (AttributeError, TypeError):
+ dictkeys = []
+ #
+ try:
+ methods = x.__methods__
+ except (AttributeError, TypeError):
+ methods = []
+ #
+ try:
+ members = x.__members__
+ except (AttributeError, TypeError):
+ members = []
+ #
+ try:
+ the_class = x.__class__
+ except (AttributeError, TypeError):
+ the_class = None
+ #
+ try:
+ bases = x.__bases__
+ except (AttributeError, TypeError):
+ bases = ()
+ #
+ total = dictkeys + methods + members
+ if the_class:
+ # It's a class instace; add the class's attributes
+ # that are functions (methods)...
+ class_attrs = listattrs(the_class)
+ class_methods = []
+ for name in class_attrs:
+ if is_function(getattr(the_class, name)):
+ class_methods.append(name)
+ total = total + class_methods
+ elif bases:
+ # It's a derived class; add the base class attributes
+ for base in bases:
+ base_attrs = listattrs(base)
+ total = total + base_attrs
+ total.sort()
+ return total
+ i = 0
+ while i+1 < len(total):
+ if total[i] == total[i+1]:
+ del total[i+1]
+ else:
+ i = i+1
+ return total
# Helper to recognize functions
def is_function(x):
- return type(x) == type(is_function)
+ return type(x) == type(is_function)
# Approximation of builtin dir(); but note that this lists the user's
# variables by default, not the current local name space.
def dir(x = None):
- if x is not None:
- return listattrs(x)
- else:
- import __main__
- return listattrs(__main__)
+ if x is not None:
+ return listattrs(x)
+ else:
+ import __main__
+ return listattrs(__main__)
diff --git a/Lib/lib-old/packmail.py b/Lib/lib-old/packmail.py
index 9c2b566..e569108 100644
--- a/Lib/lib-old/packmail.py
+++ b/Lib/lib-old/packmail.py
@@ -8,104 +8,104 @@
# Print help
def help():
- print 'All fns have a file open for writing as first parameter'
- print 'pack(f, fullname, name): pack fullname as name'
- print 'packsome(f, directory, namelist): selected files from directory'
- print 'packall(f, directory): pack all files from directory'
- print 'packnotolder(f, directory, name): pack all files from directory'
- print ' that are not older than a file there'
- print 'packtree(f, directory): pack entire directory tree'
+ print 'All fns have a file open for writing as first parameter'
+ print 'pack(f, fullname, name): pack fullname as name'
+ print 'packsome(f, directory, namelist): selected files from directory'
+ print 'packall(f, directory): pack all files from directory'
+ print 'packnotolder(f, directory, name): pack all files from directory'
+ print ' that are not older than a file there'
+ print 'packtree(f, directory): pack entire directory tree'
# Pack one file
def pack(outfp, file, name):
- fp = open(file, 'r')
- outfp.write('echo ' + name + '\n')
- outfp.write('sed "s/^X//" >"' + name + '" <<"!"\n')
- while 1:
- line = fp.readline()
- if not line: break
- if line[-1:] != '\n':
- line = line + '\n'
- outfp.write('X' + line)
- outfp.write('!\n')
- fp.close()
+ fp = open(file, 'r')
+ outfp.write('echo ' + name + '\n')
+ outfp.write('sed "s/^X//" >"' + name + '" <<"!"\n')
+ while 1:
+ line = fp.readline()
+ if not line: break
+ if line[-1:] != '\n':
+ line = line + '\n'
+ outfp.write('X' + line)
+ outfp.write('!\n')
+ fp.close()
# Pack some files from a directory
def packsome(outfp, dirname, names):
- for name in names:
- print name
- file = os.path.join(dirname, name)
- pack(outfp, file, name)
+ for name in names:
+ print name
+ file = os.path.join(dirname, name)
+ pack(outfp, file, name)
# Pack all files from a directory
def packall(outfp, dirname):
- names = os.listdir(dirname)
- try:
- names.remove('.')
- except:
- pass
- try:
- names.remove('..')
- except:
- pass
- names.sort()
- packsome(outfp, dirname, names)
+ names = os.listdir(dirname)
+ try:
+ names.remove('.')
+ except:
+ pass
+ try:
+ names.remove('..')
+ except:
+ pass
+ names.sort()
+ packsome(outfp, dirname, names)
# Pack all files from a directory that are not older than a give one
def packnotolder(outfp, dirname, oldest):
- names = os.listdir(dirname)
- try:
- names.remove('.')
- except:
- pass
- try:
- names.remove('..')
- except:
- pass
- oldest = os.path.join(dirname, oldest)
- st = os.stat(oldest)
- mtime = st[ST_MTIME]
- todo = []
- for name in names:
- print name, '...',
- st = os.stat(os.path.join(dirname, name))
- if st[ST_MTIME] >= mtime:
- print 'Yes.'
- todo.append(name)
- else:
- print 'No.'
- todo.sort()
- packsome(outfp, dirname, todo)
+ names = os.listdir(dirname)
+ try:
+ names.remove('.')
+ except:
+ pass
+ try:
+ names.remove('..')
+ except:
+ pass
+ oldest = os.path.join(dirname, oldest)
+ st = os.stat(oldest)
+ mtime = st[ST_MTIME]
+ todo = []
+ for name in names:
+ print name, '...',
+ st = os.stat(os.path.join(dirname, name))
+ if st[ST_MTIME] >= mtime:
+ print 'Yes.'
+ todo.append(name)
+ else:
+ print 'No.'
+ todo.sort()
+ packsome(outfp, dirname, todo)
# Pack a whole tree (no exceptions)
def packtree(outfp, dirname):
- print 'packtree', dirname
- outfp.write('mkdir ' + unixfix(dirname) + '\n')
- names = os.listdir(dirname)
- try:
- names.remove('.')
- except:
- pass
- try:
- names.remove('..')
- except:
- pass
- subdirs = []
- for name in names:
- fullname = os.path.join(dirname, name)
- if os.path.isdir(fullname):
- subdirs.append(fullname)
- else:
- print 'pack', fullname
- pack(outfp, fullname, unixfix(fullname))
- for subdirname in subdirs:
- packtree(outfp, subdirname)
+ print 'packtree', dirname
+ outfp.write('mkdir ' + unixfix(dirname) + '\n')
+ names = os.listdir(dirname)
+ try:
+ names.remove('.')
+ except:
+ pass
+ try:
+ names.remove('..')
+ except:
+ pass
+ subdirs = []
+ for name in names:
+ fullname = os.path.join(dirname, name)
+ if os.path.isdir(fullname):
+ subdirs.append(fullname)
+ else:
+ print 'pack', fullname
+ pack(outfp, fullname, unixfix(fullname))
+ for subdirname in subdirs:
+ packtree(outfp, subdirname)
def unixfix(name):
- comps = name.split(os.sep)
- res = ''
- for comp in comps:
- if comp:
- if res: res = res + '/'
- res = res + comp
- return res
+ comps = name.split(os.sep)
+ res = ''
+ for comp in comps:
+ if comp:
+ if res: res = res + '/'
+ res = res + comp
+ return res
diff --git a/Lib/lib-old/poly.py b/Lib/lib-old/poly.py
index f89bd14..fe6a1dc 100644
--- a/Lib/lib-old/poly.py
+++ b/Lib/lib-old/poly.py
@@ -6,47 +6,47 @@
# taken out by normalize().
def normalize(p): # Strip unnecessary zero coefficients
- n = len(p)
- while n:
- if p[n-1]: return p[:n]
- n = n-1
- return []
+ n = len(p)
+ while n:
+ if p[n-1]: return p[:n]
+ n = n-1
+ return []
def plus(a, b):
- if len(a) < len(b): a, b = b, a # make sure a is the longest
- res = a[:] # make a copy
- for i in range(len(b)):
- res[i] = res[i] + b[i]
- return normalize(res)
+ if len(a) < len(b): a, b = b, a # make sure a is the longest
+ res = a[:] # make a copy
+ for i in range(len(b)):
+ res[i] = res[i] + b[i]
+ return normalize(res)
def minus(a, b):
- neg_b = map(lambda x: -x, b[:])
- return plus(a, neg_b)
+ neg_b = map(lambda x: -x, b[:])
+ return plus(a, neg_b)
def one(power, coeff): # Representation of coeff * x**power
- res = []
- for i in range(power): res.append(0)
- return res + [coeff]
+ res = []
+ for i in range(power): res.append(0)
+ return res + [coeff]
def times(a, b):
- res = []
- for i in range(len(a)):
- for j in range(len(b)):
- res = plus(res, one(i+j, a[i]*b[j]))
- return res
+ res = []
+ for i in range(len(a)):
+ for j in range(len(b)):
+ res = plus(res, one(i+j, a[i]*b[j]))
+ return res
def power(a, n): # Raise polynomial a to the positive integral power n
- if n == 0: return [1]
- if n == 1: return a
- if n/2*2 == n:
- b = power(a, n/2)
- return times(b, b)
- return times(power(a, n-1), a)
+ if n == 0: return [1]
+ if n == 1: return a
+ if n/2*2 == n:
+ b = power(a, n/2)
+ return times(b, b)
+ return times(power(a, n-1), a)
def der(a): # First derivative
- res = a[1:]
- for i in range(len(res)):
- res[i] = res[i] * (i+1)
- return res
+ res = a[1:]
+ for i in range(len(res)):
+ res[i] = res[i] * (i+1)
+ return res
# Computing a primitive function would require rational arithmetic...
diff --git a/Lib/lib-old/rand.py b/Lib/lib-old/rand.py
index c299d0a..a557b69 100644
--- a/Lib/lib-old/rand.py
+++ b/Lib/lib-old/rand.py
@@ -4,10 +4,10 @@
import whrandom
def srand(seed):
- whrandom.seed(seed%256, seed/256%256, seed/65536%256)
+ whrandom.seed(seed%256, seed/256%256, seed/65536%256)
def rand():
- return int(whrandom.random() * 32768.0) % 32768
+ return int(whrandom.random() * 32768.0) % 32768
def choice(seq):
- return seq[rand() % len(seq)]
+ return seq[rand() % len(seq)]
diff --git a/Lib/lib-old/tb.py b/Lib/lib-old/tb.py
index 57851aa..9063559 100644
--- a/Lib/lib-old/tb.py
+++ b/Lib/lib-old/tb.py
@@ -12,166 +12,166 @@
def tb(): printtb(sys.last_traceback)
def browser(tb):
- if not tb:
- print 'No traceback.'
- return
- tblist = []
- while tb:
- tblist.append(tb)
- tb = tb.tb_next
- ptr = len(tblist)-1
- tb = tblist[ptr]
- while 1:
- if tb != tblist[ptr]:
- tb = tblist[ptr]
- print `ptr` + ':',
- printtbheader(tb)
- try:
- line = raw_input('TB: ')
- except KeyboardInterrupt:
- print '\n[Interrupted]'
- break
- except EOFError:
- print '\n[EOF]'
- break
- cmd = line.strip()
- if cmd:
- if cmd == 'quit':
- break
- elif cmd == 'list':
- browserlist(tb)
- elif cmd == 'up':
- if ptr-1 >= 0: ptr = ptr-1
- else: print 'Bottom of stack.'
- elif cmd == 'down':
- if ptr+1 < len(tblist): ptr = ptr+1
- else: print 'Top of stack.'
- elif cmd == 'locals':
- printsymbols(tb.tb_frame.f_locals)
- elif cmd == 'globals':
- printsymbols(tb.tb_frame.f_globals)
- elif cmd in ('?', 'help'):
- browserhelp()
- else:
- browserexec(tb, cmd)
+ if not tb:
+ print 'No traceback.'
+ return
+ tblist = []
+ while tb:
+ tblist.append(tb)
+ tb = tb.tb_next
+ ptr = len(tblist)-1
+ tb = tblist[ptr]
+ while 1:
+ if tb != tblist[ptr]:
+ tb = tblist[ptr]
+ print `ptr` + ':',
+ printtbheader(tb)
+ try:
+ line = raw_input('TB: ')
+ except KeyboardInterrupt:
+ print '\n[Interrupted]'
+ break
+ except EOFError:
+ print '\n[EOF]'
+ break
+ cmd = line.strip()
+ if cmd:
+ if cmd == 'quit':
+ break
+ elif cmd == 'list':
+ browserlist(tb)
+ elif cmd == 'up':
+ if ptr-1 >= 0: ptr = ptr-1
+ else: print 'Bottom of stack.'
+ elif cmd == 'down':
+ if ptr+1 < len(tblist): ptr = ptr+1
+ else: print 'Top of stack.'
+ elif cmd == 'locals':
+ printsymbols(tb.tb_frame.f_locals)
+ elif cmd == 'globals':
+ printsymbols(tb.tb_frame.f_globals)
+ elif cmd in ('?', 'help'):
+ browserhelp()
+ else:
+ browserexec(tb, cmd)
def browserlist(tb):
- filename = tb.tb_frame.f_code.co_filename
- lineno = tb.tb_lineno
- last = lineno
- first = max(1, last-10)
- for i in range(first, last+1):
- if i == lineno: prefix = '***' + `i`.rjust(4) + ':'
- else: prefix = `i`.rjust(7) + ':'
- line = linecache.getline(filename, i)
- if line[-1:] == '\n': line = line[:-1]
- print prefix + line
+ filename = tb.tb_frame.f_code.co_filename
+ lineno = tb.tb_lineno
+ last = lineno
+ first = max(1, last-10)
+ for i in range(first, last+1):
+ if i == lineno: prefix = '***' + `i`.rjust(4) + ':'
+ else: prefix = `i`.rjust(7) + ':'
+ line = linecache.getline(filename, i)
+ if line[-1:] == '\n': line = line[:-1]
+ print prefix + line
def browserexec(tb, cmd):
- locals = tb.tb_frame.f_locals
- globals = tb.tb_frame.f_globals
- try:
- exec cmd+'\n' in globals, locals
- except:
- t, v = sys.exc_info()[:2]
- print '*** Exception:',
- if type(t) is type(''):
- print t,
- else:
- print t.__name__,
- if v is not None:
- print ':', v,
- print
- print 'Type help to get help.'
+ locals = tb.tb_frame.f_locals
+ globals = tb.tb_frame.f_globals
+ try:
+ exec cmd+'\n' in globals, locals
+ except:
+ t, v = sys.exc_info()[:2]
+ print '*** Exception:',
+ if type(t) is type(''):
+ print t,
+ else:
+ print t.__name__,
+ if v is not None:
+ print ':', v,
+ print
+ print 'Type help to get help.'
def browserhelp():
- print
- print ' This is the traceback browser. Commands are:'
- print ' up : move one level up in the call stack'
- print ' down : move one level down in the call stack'
- print ' locals : print all local variables at this level'
- print ' globals : print all global variables at this level'
- print ' list : list source code around the failure'
- print ' help : print help (what you are reading now)'
- print ' quit : back to command interpreter'
- print ' Typing any other 1-line statement will execute it'
- print ' using the current level\'s symbol tables'
- print
+ print
+ print ' This is the traceback browser. Commands are:'
+ print ' up : move one level up in the call stack'
+ print ' down : move one level down in the call stack'
+ print ' locals : print all local variables at this level'
+ print ' globals : print all global variables at this level'
+ print ' list : list source code around the failure'
+ print ' help : print help (what you are reading now)'
+ print ' quit : back to command interpreter'
+ print ' Typing any other 1-line statement will execute it'
+ print ' using the current level\'s symbol tables'
+ print
def printtb(tb):
- while tb:
- print1tb(tb)
- tb = tb.tb_next
+ while tb:
+ print1tb(tb)
+ tb = tb.tb_next
def print1tb(tb):
- printtbheader(tb)
- if tb.tb_frame.f_locals is not tb.tb_frame.f_globals:
- printsymbols(tb.tb_frame.f_locals)
+ printtbheader(tb)
+ if tb.tb_frame.f_locals is not tb.tb_frame.f_globals:
+ printsymbols(tb.tb_frame.f_locals)
def printtbheader(tb):
- filename = tb.tb_frame.f_code.co_filename
- lineno = tb.tb_lineno
- info = '"' + filename + '"(' + `lineno` + ')'
- line = linecache.getline(filename, lineno)
- if line:
- info = info + ': ' + line.strip()
- print info
+ filename = tb.tb_frame.f_code.co_filename
+ lineno = tb.tb_lineno
+ info = '"' + filename + '"(' + `lineno` + ')'
+ line = linecache.getline(filename, lineno)
+ if line:
+ info = info + ': ' + line.strip()
+ print info
def printsymbols(d):
- keys = d.keys()
- keys.sort()
- for name in keys:
- print ' ' + name.ljust(12) + ':',
- printobject(d[name], 4)
- print
+ keys = d.keys()
+ keys.sort()
+ for name in keys:
+ print ' ' + name.ljust(12) + ':',
+ printobject(d[name], 4)
+ print
def printobject(v, maxlevel):
- if v is None:
- print 'None',
- elif type(v) in (type(0), type(0.0)):
- print v,
- elif type(v) is type(''):
- if len(v) > 20:
- print `v[:17] + '...'`,
- else:
- print `v`,
- elif type(v) is type(()):
- print '(',
- printlist(v, maxlevel)
- print ')',
- elif type(v) is type([]):
- print '[',
- printlist(v, maxlevel)
- print ']',
- elif type(v) is type({}):
- print '{',
- printdict(v, maxlevel)
- print '}',
- else:
- print v,
+ if v is None:
+ print 'None',
+ elif type(v) in (type(0), type(0.0)):
+ print v,
+ elif type(v) is type(''):
+ if len(v) > 20:
+ print `v[:17] + '...'`,
+ else:
+ print `v`,
+ elif type(v) is type(()):
+ print '(',
+ printlist(v, maxlevel)
+ print ')',
+ elif type(v) is type([]):
+ print '[',
+ printlist(v, maxlevel)
+ print ']',
+ elif type(v) is type({}):
+ print '{',
+ printdict(v, maxlevel)
+ print '}',
+ else:
+ print v,
def printlist(v, maxlevel):
- n = len(v)
- if n == 0: return
- if maxlevel <= 0:
- print '...',
- return
- for i in range(min(6, n)):
- printobject(v[i], maxlevel-1)
- if i+1 < n: print ',',
- if n > 6: print '...',
+ n = len(v)
+ if n == 0: return
+ if maxlevel <= 0:
+ print '...',
+ return
+ for i in range(min(6, n)):
+ printobject(v[i], maxlevel-1)
+ if i+1 < n: print ',',
+ if n > 6: print '...',
def printdict(v, maxlevel):
- keys = v.keys()
- n = len(keys)
- if n == 0: return
- if maxlevel <= 0:
- print '...',
- return
- keys.sort()
- for i in range(min(6, n)):
- key = keys[i]
- print `key` + ':',
- printobject(v[key], maxlevel-1)
- if i+1 < n: print ',',
- if n > 6: print '...',
+ keys = v.keys()
+ n = len(keys)
+ if n == 0: return
+ if maxlevel <= 0:
+ print '...',
+ return
+ keys.sort()
+ for i in range(min(6, n)):
+ key = keys[i]
+ print `key` + ':',
+ printobject(v[key], maxlevel-1)
+ if i+1 < n: print ',',
+ if n > 6: print '...',
diff --git a/Lib/lib-old/util.py b/Lib/lib-old/util.py
index 6cb1433..104af1e 100644
--- a/Lib/lib-old/util.py
+++ b/Lib/lib-old/util.py
@@ -10,16 +10,16 @@
# If it occurs more than once, remove the first occurrence.
#
def remove(item, list):
- if item in list: list.remove(item)
+ if item in list: list.remove(item)
# Return a string containing a file's contents.
#
def readfile(fn):
- return readopenfile(open(fn, 'r'))
+ return readopenfile(open(fn, 'r'))
# Read an open file until EOF.
#
def readopenfile(fp):
- return fp.read()
+ return fp.read()
diff --git a/Lib/lib-old/zmod.py b/Lib/lib-old/zmod.py
index 7259bf8..55f49df 100644
--- a/Lib/lib-old/zmod.py
+++ b/Lib/lib-old/zmod.py
@@ -1,7 +1,7 @@
# module 'zmod'
# Compute properties of mathematical "fields" formed by taking
-# Z/n (the whole numbers modulo some whole number n) and an
+# Z/n (the whole numbers modulo some whole number n) and an
# irreducible polynomial (i.e., a polynomial with only complex zeros),
# e.g., Z/5 and X**2 + 2.
#
@@ -30,65 +30,65 @@
# Return x modulo y. Returns >= 0 even if x < 0.
def mod(x, y):
- return divmod(x, y)[1]
+ return divmod(x, y)[1]
# Normalize a polynomial modulo n and modulo p.
def norm(a, n, p):
- a = poly.modulo(a, p)
- a = a[:]
- for i in range(len(a)): a[i] = mod(a[i], n)
- a = poly.normalize(a)
- return a
+ a = poly.modulo(a, p)
+ a = a[:]
+ for i in range(len(a)): a[i] = mod(a[i], n)
+ a = poly.normalize(a)
+ return a
# Make a list of all n^d elements of the proposed field.
def make_all(mat):
- all = []
- for row in mat:
- for a in row:
- all.append(a)
- return all
+ all = []
+ for row in mat:
+ for a in row:
+ all.append(a)
+ return all
def make_elements(n, d):
- if d == 0: return [poly.one(0, 0)]
- sub = make_elements(n, d-1)
- all = []
- for a in sub:
- for i in range(n):
- all.append(poly.plus(a, poly.one(d-1, i)))
- return all
+ if d == 0: return [poly.one(0, 0)]
+ sub = make_elements(n, d-1)
+ all = []
+ for a in sub:
+ for i in range(n):
+ all.append(poly.plus(a, poly.one(d-1, i)))
+ return all
def make_inv(all, n, p):
- x = poly.one(1, 1)
- inv = []
- for a in all:
- inv.append(norm(poly.times(a, x), n, p))
- return inv
+ x = poly.one(1, 1)
+ inv = []
+ for a in all:
+ inv.append(norm(poly.times(a, x), n, p))
+ return inv
def checkfield(n, p):
- all = make_elements(n, len(p)-1)
- inv = make_inv(all, n, p)
- all1 = all[:]
- inv1 = inv[:]
- all1.sort()
- inv1.sort()
- if all1 == inv1: print 'BINGO!'
- else:
- print 'Sorry:', n, p
- print all
- print inv
+ all = make_elements(n, len(p)-1)
+ inv = make_inv(all, n, p)
+ all1 = all[:]
+ inv1 = inv[:]
+ all1.sort()
+ inv1.sort()
+ if all1 == inv1: print 'BINGO!'
+ else:
+ print 'Sorry:', n, p
+ print all
+ print inv
def rj(s, width):
- if type(s) is not type(''): s = `s`
- n = len(s)
- if n >= width: return s
- return ' '*(width - n) + s
+ if type(s) is not type(''): s = `s`
+ n = len(s)
+ if n >= width: return s
+ return ' '*(width - n) + s
def lj(s, width):
- if type(s) is not type(''): s = `s`
- n = len(s)
- if n >= width: return s
- return s + ' '*(width - n)
+ if type(s) is not type(''): s = `s`
+ n = len(s)
+ if n >= width: return s
+ return s + ' '*(width - n)