Python 0.9.1 as posted in alt.sources

1 files changed, 2539 insertions, 0 deletions

diff --git a/shar/python-0.9.1-15-21.shar b/shar/python-0.9.1-15-21.shar
new file mode 100644
index 0000000..3cc3c78
--- /dev/null
+++ b/shar/python-0.9.1-15-21.shar
@@ -0,0 +1,2539 @@
+: This is a shell archive.
+: Extract with 'sh this_file'.
+:
+: Extract part 01 first since it makes all directories
+echo 'Start of pack.out, part 15 out of 21:'
+if test -s 'demo/sgi/gl/kites.py'
+then echo '*** I will not over-write existing file demo/sgi/gl/kites.py'
+else
+echo 'x - demo/sgi/gl/kites.py'
+sed 's/^X//' > 'demo/sgi/gl/kites.py' << 'EOF'
+X#! /ufs/guido/bin/sgi/python
+X
+X# *** This only works correctly on a 24 bit-plane machine. ***
+X#
+X# A simple Python program that tests the some parts of the
+X# GL library. It shows the speed that can be obtained when
+X# doing simple graphics.
+X#
+X# The bottleneck in this program is NOT Python but the graphics
+X# engine; i.e Python can feed the graphics pipeline fast enough
+X# on the 4D/25G.
+X#
+X# This program show 3 kites flying around the screen. It uses
+X#
+X# * bgnpolygon, endpolygon
+X# * v3, n3
+X# * lmdef, lmbind
+X#
+X# Usage :
+X#
+X# ESC -> exit program
+X# MOUSE3 -> freeze toggle
+X# MOUSE2 -> one step (use this in freeze state)
+X
+Xfrom GL import *
+Xfrom gl import *
+Ximport DEVICE
+Xfrom math import *
+X
+X#
+X# viewobj : sets the rotation, translation and scaling
+X# set appropiate material, call drawobject()
+X#
+Xdef viewobj (r, s, t, mat) :
+X pushmatrix()
+X rot (r * 10.0, 'X')
+X rot (r * 10.0, 'Y')
+X rot (r * 10.0, 'Z')
+X scale (s[0], s[1], s[2])
+X translate (t[0], t[1], t[2])
+X lmbind(MATERIAL, mat)
+X drawobject()
+X popmatrix()
+X
+X#
+X# makeobj : the contructor of the object
+X#
+Xdef mkobj () :
+X v0 = (-5.0 ,0.0, 0.0)
+X v1 = (0.0 ,5.0, 0.0)
+X v2 = (5.0 ,0.0, 0.0)
+X v3 = (0.0 ,2.0, 0.0)
+X n0 = (sqrt(2.0)/2.0, sqrt(2.0)/2.0, 0.0)
+X vn = ((v0, n0), (v1, n0), (v2, n0), (v3, n0))
+X #
+X return vn
+X
+X#
+X# the object itself as an array of vertices and normals
+X#
+Xkite = mkobj ()
+X
+X#
+X# drawobject : draw a triangle. with bgnpolygon
+X#
+Xdef drawobject () :
+X #
+X bgnpolygon()
+X vnarray (kite)
+X endpolygon()
+X
+X#
+X# identity matrix
+X#
+Xidmat=[1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0]
+X
+X#
+X# the rgb-value of light-blue
+X#
+XLightBlue = (43,169,255)
+X
+X#
+X# the different materials.
+X#
+Xm1=[SPECULAR,0.0,0.0,0.6,DIFFUSE,0.0,0.0,0.8,SHININESS,20.0,LMNULL]
+Xm2=[SPECULAR,0.8,0.0,0.1,DIFFUSE,0.8,0.0,0.3,SHININESS,120.0,LMNULL]
+Xm3=[SPECULAR,0.0,1.0,0.0,DIFFUSE,0.0,0.6,0.0,SHININESS,120.0,LMNULL]
+X
+X#
+X# lightsources
+X#
+Xlight1 = [LCOLOR,1.0,1.0,1.0,POSITION,15.0,15.0,0.0,1.0,LMNULL]
+Xlight2 = [LCOLOR,1.0,1.0,1.0,POSITION,-15.0,15.0,0.0,1.0,LMNULL]
+X
+X#
+X# the lightmodel
+X#
+Xmodel = [AMBIENT,0.2,0.2,0.2,LMNULL]
+X
+X#
+X# initgl : opens the window, configures the pipeline to 2buf and zbuf,
+X# sets the viewing, defines and binds the materials
+X#
+Xdef initgl () :
+X #
+X # open window
+X #
+X foreground ()
+X keepaspect (1, 1)
+X prefposition (100, 500, 100, 500)
+X w = winopen ('PYTHON lights')
+X keepaspect (1, 1)
+X winconstraints()
+X #
+X # configure pipeline (zbuf, 2buf, GOURAUD and RGBmode)
+X #
+X zbuffer (1)
+X doublebuffer ()
+X shademodel (GOURAUD)
+X RGBmode ()
+X gconfig ()
+X #
+X # define and bind materials (set perspective BEFORE loadmat !)
+X #
+X mmode(MVIEWING)
+X perspective (900, 1.0, 1.0, 20.0)
+X loadmatrix(idmat)
+X lmdef(DEFMATERIAL, 1, m1)
+X lmdef(DEFMATERIAL, 2, m2)
+X lmdef(DEFMATERIAL, 3, m3)
+X lmdef(DEFLIGHT, 1, light1)
+X lmdef(DEFLIGHT, 2, light2)
+X lmdef(DEFLMODEL, 1, model)
+X lmbind(LIGHT0,1)
+X lmbind(LIGHT1,2)
+X lmbind(LMODEL,1)
+X #
+X # set viewing
+X #
+X lookat (0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 0)
+X #
+X # ask for the REDRAW and ESCKEY events
+X #
+X qdevice(DEVICE.MOUSE3)
+X qdevice(DEVICE.MOUSE2)
+X qdevice(DEVICE.REDRAW)
+X qdevice(DEVICE.ESCKEY)
+X
+X#
+X# GoForIT : use 2buf to redraw the object 2n times. index i is used as
+X# the (smoothly changing) rotation angle
+X#
+Xdef GoForIt(i) :
+X freeze = 1
+X while 1 :
+X if freeze <> 0 :
+X i = i + 1
+X #
+X # clear z-buffer and clear background to light-blue
+X #
+X zclear()
+X c3i (LightBlue)
+X clear()
+X #
+X # draw the 3 traiangles scaled above each other.
+X #
+X viewobj(float(i),[1.0,1.0,1.0],[1.0,1.0,1.0],1)
+X viewobj(float(i),[0.75,0.75,0.75],[0.0,2.0,2.0],2)
+X viewobj(float(i),[0.5,0.5,0.5],[0.0,4.0,4.0],3)
+X #
+X swapbuffers()
+X #
+X if qtest() <> 0 :
+X dev, val = qread()
+X if dev = DEVICE.ESCKEY :
+X break
+X elif dev = DEVICE.REDRAW :
+X reshapeviewport ()
+X elif dev = DEVICE.MOUSE3 and val <> 0 :
+X freeze = 1 - freeze
+X elif dev = DEVICE.MOUSE2 and val <> 0 :
+X i = i + 1
+X
+X
+X# the main program
+X#
+Xdef main () :
+X initgl ()
+X GoForIt (0)
+X
+X#
+X# exec main
+X#
+Xmain ()
+EOF
+chmod +x 'demo/sgi/gl/kites.py'
+fi
+if test -s 'demo/sgi/gl_panel/nurbs/nurbs.s'
+then echo '*** I will not over-write existing file demo/sgi/gl_panel/nurbs/nurbs.s'
+else
+echo 'x - demo/sgi/gl_panel/nurbs/nurbs.s'
+sed 's/^X//' > 'demo/sgi/gl_panel/nurbs/nurbs.s' << 'EOF'
+X;;; This file was automatically generated by the panel editor.
+X;;; If you read it into gnu emacs, it will automagically format itself.
+X
+X(panel (prop help creator:user-panel-help)
+X(prop user-panel #t)
+X(label "NURB controls")
+X(x 815)
+X(y 22)
+X(al (pnl_toggle_button (name "trim")
+X(prop help creator:user-act-help)
+X(label "trim on/off")
+X(x 4)
+X(y 4.5)
+X(w 0.45)
+X(h 0.4)
+X(downfunc move-then-resize)
+X)
+X(pnl_toggle_button (name "motion")
+X(prop help creator:user-act-help)
+X(label "motion on/off")
+X(y 1)
+X(downfunc move-then-resize)
+X)
+X(pnl_toggle_button (name "xyzaxis")
+X(prop help creator:user-act-help)
+X(label "xyz-axis")
+X(y 3)
+X(downfunc move-then-resize)
+X)
+X(pnl_toggle_button (name "trimpnts")
+X(prop help creator:user-act-help)
+X(label "trimming pnts")
+X(y 3.5)
+X(downfunc move-then-resize)
+X)
+X(pnl_toggle_button (name "cntlpnts")
+X(prop help creator:user-act-help)
+X(label "control pnts")
+X(y 4)
+X(downfunc move-then-resize)
+X)
+X(pnl_toggle_button (name "nurb")
+X(prop help creator:user-act-help)
+X(label "nurb")
+X(y 4.5)
+X(val 1)
+X(downfunc move-then-resize)
+X)
+X(pnl_button (name "quit")
+X(prop help creator:user-act-help)
+X(label "quit")
+X(x 4)
+X(y 1)
+X(labeltype 1)
+X(downfunc move-then-resize)
+X)
+X(pnl_label (prop help creator:user-act-help)
+X(label "TRIMMING")
+X(x 4)
+X(y 5)
+X(downfunc move-then-resize)
+X)
+X(pnl_label (prop help creator:user-act-help)
+X(label "MOTION")
+X(y 1.5)
+X(downfunc move-then-resize)
+X)
+X(pnl_label (prop help creator:user-act-help)
+X(label "VISIBILITY")
+X(y 5)
+X(downfunc move-then-resize)
+X)
+X)
+X)
+X;;; Local Variables:
+X;;; mode: scheme
+X;;; eval: (save-excursion (goto-char (point-min)) (kill-line 3))
+X;;; eval: (save-excursion (goto-char (point-min)) (replace-regexp "[ \n]*)" ")"))
+X;;; eval: (indent-region (point-min) (point-max) nil)
+X;;; eval: (progn (kill-line -3) (delete-backward-char 1) (save-buffer))
+X;;; End:
+EOF
+fi
+if test -s 'lib/Sliders.py'
+then echo '*** I will not over-write existing file lib/Sliders.py'
+else
+echo 'x - lib/Sliders.py'
+sed 's/^X//' > 'lib/Sliders.py' << 'EOF'
+X# Module 'Sliders'
+X
+X
+Ximport stdwin
+Xfrom stdwinevents import *
+Ximport rect
+Xfrom Buttons import *
+Xfrom HVSplit import HSplit
+X
+X
+X# Field indices in event detail
+X#
+X_HV = 0
+X_CLICKS = 1
+X_BUTTON = 2
+X_MASK = 3
+X
+X
+X# DragSlider is the simplest possible slider.
+X# It looks like a button but dragging the mouse left or right
+X# changes the controlled value.
+X# It does not support any of the triggers or hooks defined by Buttons,
+X# but defines its own setval_trigger and setval_hook.
+X#
+Xclass DragSliderReactivity() = BaseReactivity():
+X #
+X def mouse_down(self, detail):
+X h, v = hv = detail[_HV]
+X if self.enabled and self.mousetest(hv):
+X self.anchor = h
+X self.oldval = self.val
+X self.active = 1
+X #
+X def mouse_move(self, detail):
+X if self.active:
+X h, v = detail[_HV]
+X self.setval(self.oldval + (h - self.anchor))
+X #
+X def mouse_up(self, detail):
+X if self.active:
+X h, v = detail[_HV]
+X self.setval(self.oldval + (h - self.anchor))
+X self.active = 0
+X #
+X
+Xclass DragSliderAppearance() = ButtonAppearance():
+X #
+X # INVARIANTS maintained by the setval method:
+X #
+X # self.min <= self.val <= self.max
+X # self.text = self.pretext + `self.val` + self.postext
+X #
+X # (Notice that unlike Python ranges, the end point belongs
+X # to the range.)
+X #
+X def init_appearance(self):
+X ButtonAppearance.init_appearance(self)
+X self.min = 0
+X self.val = 0
+X self.max = 100
+X self.hook = 0
+X self.pretext = self.postext = ''
+X self.recalctext()
+X #
+X # The 'get*' and 'set*' methods belong to the generic slider interface
+X #
+X def getval(self): return self.val
+X #
+X def sethook(self, hook):
+X self.hook = hook
+X #
+X def setminvalmax(self, (min, val, max)):
+X self.min = min
+X self.max = max
+X self.setval(val)
+X #
+X def settexts(self, (pretext, postext)):
+X self.pretext = pretext
+X self.postext = postext
+X self.recalctext()
+X #
+X def setval(self, val):
+X val = min(self.max, max(self.min, val))
+X if val <> self.val:
+X self.val = val
+X self.recalctext()
+X self.trigger()
+X #
+X def trigger(self):
+X if self.hook:
+X self.hook(self)
+X #
+X def recalctext(self):
+X self.settext(self.pretext + `self.val` + self.postext)
+X #
+X
+Xclass DragSlider() = DragSliderReactivity(), DragSliderAppearance(), Define():
+X def definetext(self, (parent, text)):
+X raise RuntimeError, 'DragSlider.definetext() not supported'
+X
+X
+X# Auxiliary class for PushButton incorporated in ComplexSlider
+X#
+Xclass _StepButton() = PushButton():
+X def define(self, parent):
+X self = PushButton.define(self, parent)
+X self.step = 0
+X return self
+X def setstep(self, step):
+X self.step = step
+X def definetextstep(self, (parent, text, step)):
+X self = self.definetext(parent, text)
+X self.setstep(step)
+X return self
+X def init_reactivity(self):
+X PushButton.init_reactivity(self)
+X self.parent.need_timer(self)
+X def step_trigger(self):
+X self.parent.setval(self.parent.getval() + self.step)
+X def down_trigger(self):
+X self.step_trigger()
+X self.parent.settimer(5)
+X def timer(self):
+X if self.hilited:
+X self.step_trigger()
+X if self.active:
+X self.parent.settimer(1)
+X
+X
+X# A complex slider is an HSplit initialized to three buttons:
+X# one to step down, a dragslider, and one to step up.
+X#
+Xclass ComplexSlider() = HSplit():
+X #
+X # Override Slider define() method
+X #
+X def define(self, parent):
+X self = self.create(parent) # HSplit
+X #
+X self.downbutton = _StepButton().definetextstep(self, '-', -1)
+X self.dragbutton = DragSlider().define(self)
+X self.upbutton = _StepButton().definetextstep(self, '+', 1)
+X #
+X return self
+X #
+X # Override HSplit methods
+X #
+X def minsize(self, m):
+X w1, h1 = self.downbutton.minsize(m)
+X w2, h2 = self.dragbutton.minsize(m)
+X w3, h3 = self.upbutton.minsize(m)
+X height = max(h1, h2, h3)
+X w1 = max(w1, height)
+X w3 = max(w3, height)
+X return w1+w2+w3, height
+X #
+X def setbounds(self, bounds):
+X (left, top), (right, bottom) = self.bounds = bounds
+X size = bottom - top
+X self.downbutton.setbounds((left, top), (left+size, bottom))
+X self.dragbutton.setbounds((left+size, top), \
+X (right-size, bottom))
+X self.upbutton.setbounds((right-size, top), (right, bottom))
+X #
+X # Pass other Slider methods on to dragbutton
+X #
+X def getval(self): return self.dragbutton.getval()
+X def sethook(self, hook): self.dragbutton.sethook(hook)
+X def setminvalmax(self, args): self.dragbutton.setminvalmax(args)
+X def settexts(self, args): self.dragbutton.settexts(args)
+X def setval(self, val): self.dragbutton.setval(val)
+X def enable(self, flag):
+X self.downbutton.enable(flag)
+X self.dragbutton.enable(flag)
+X self.upbutton.enable(flag)
+EOF
+fi
+if test -s 'lib/clock.py'
+then echo '*** I will not over-write existing file lib/clock.py'
+else
+echo 'x - lib/clock.py'
+sed 's/^X//' > 'lib/clock.py' << 'EOF'
+X# 'klok' -- A simple alarm clock
+X
+X# The alarm can be set at 5 minute intervals on a 12 hour basis.
+X# It is controlled with the mouse:
+X# - Click and drag around the circle to set the alarm.
+X# - Click far outside the circle to clear the alarm.
+X# - Click near the center to set the alarm at the last time set.
+X# The alarm time is indicated by a small triangle just outside the circle,
+X# and also by a digital time at the bottom.
+X# The indicators disappear when the alarm is not set.
+X# When the alarm goes off, it beeps every minute for five minutes,
+X# and the clock turns into inverse video.
+X# Click or activate the window to turn the ringing off.
+X
+Ximport stdwin
+Xfrom stdwinevents import WE_MOUSE_DOWN, WE_MOUSE_MOVE, WE_MOUSE_UP, \
+X WE_TIMER, WE_DRAW, WE_SIZE, WE_CLOSE, WE_ACTIVATE
+Ximport time
+Xfrom math import sin, cos, atan2, pi, sqrt
+X
+XDEFWIDTH, DEFHEIGHT = 200, 200
+X
+Xmouse_events = (WE_MOUSE_DOWN, WE_MOUSE_MOVE, WE_MOUSE_UP)
+Xorigin = 0, 0
+Xfaraway = 2000, 2000
+Xeverywhere = origin, faraway
+X
+Xclass struct(): pass # A class to declare featureless objects
+X
+XG = struct() # Global variables (most set in setdimensions())
+XG.tzdiff = 5*3600 # THINK computes UCT from local time assuming EST!
+X
+XA = struct() # Globals used by the alarm
+XA.set = 1 # True when alarm is set
+XA.time = 11*60 + 40 # Time when alarm must go off
+XA.ring = 0 # True when alarm is ringing
+X
+Xdef main():
+X try:
+X realmain()
+X except KeyboardInterrupt:
+X print 'KeyboardInterrupt'
+X finally:
+X G.w = 0
+X
+Xdef realmain():
+X setdimensions(DEFWIDTH, DEFHEIGHT)
+X stdwin.setdefwinsize(G.farcorner)
+X G.w = stdwin.open('klok')
+X settimer()
+X while 1:
+X type, window, detail = stdwin.getevent()
+X if type = WE_DRAW:
+X drawproc(detail)
+X elif type = WE_TIMER:
+X settimer()
+X drawproc(everywhere)
+X elif type in mouse_events:
+X mouseclick(type, detail)
+X elif type = WE_ACTIVATE:
+X if A.ring:
+X # Turn the ringing off
+X A.ring = 0
+X G.w.begindrawing().invert(G.mainarea)
+X elif type = WE_SIZE:
+X G.w.change(everywhere)
+X width, height = G.w.getwinsize()
+X height = height - stdwin.lineheight()
+X setdimensions(width, height)
+X elif type = WE_CLOSE:
+X break
+X
+Xdef setdimensions(width, height):
+X if width < height: size = width
+X else: size = height
+X halfwidth = width/2
+X halfheight = height/2
+X G.center = halfwidth, halfheight
+X G.radius = size*45/100
+X G.width = width
+X G.height = height
+X G.corner = width, height
+X G.mainarea = origin, G.corner
+X G.lineheight = stdwin.lineheight()
+X G.farcorner = width, height + G.lineheight
+X G.statusarea = (0, height), G.farcorner
+X G.fullarea = origin, G.farcorner
+X
+Xdef settimer():
+X now = getlocaltime()
+X G.times = calctime(now)
+X delay = 61 - now % 60
+X G.w.settimer(10 * delay)
+X minutes = (now/60) % 720
+X if A.ring:
+X # Is it time to stop the alarm ringing?
+X since = (minutes - A.time + 720) % 720
+X if since >= 5:
+X # Stop it now
+X A.ring = 0
+X else:
+X # Ring again, once every minute
+X stdwin.fleep()
+X elif A.set and minutes = A.time:
+X # Start the alarm ringing
+X A.ring = 1
+X stdwin.fleep()
+X
+Xdef drawproc(area):
+X hours, minutes, seconds = G.times
+X d = G.w.begindrawing()
+X d.cliprect(area)
+X d.erase(everywhere)
+X d.circle(G.center, G.radius)
+X d.line(G.center, calcpoint(hours*30 + minutes/2, 0.6))
+X d.line(G.center, calcpoint(minutes*6, 1.0))
+X str = dd(hours) + ':' + dd(minutes)
+X p = (G.width - d.textwidth(str))/2, G.height * 3 / 4
+X d.text(p, str)
+X if A.set:
+X drawalarm(d)
+X drawalarmtime(d)
+X if A.ring:
+X d.invert(G.mainarea)
+X
+Xdef mouseclick(type, detail):
+X d = G.w.begindrawing()
+X if A.ring:
+X # First turn the ringing off
+X A.ring = 0
+X d.invert(G.mainarea)
+X h, v = detail[0]
+X ch, cv = G.center
+X x, y = h-ch, cv-v
+X dist = sqrt(x*x + y*y) / float(G.radius)
+X if dist > 1.2:
+X if A.set:
+X drawalarm(d)
+X erasealarmtime(d)
+X A.set = 0
+X elif dist < 0.8:
+X if not A.set:
+X A.set = 1
+X drawalarm(d)
+X drawalarmtime(d)
+X else:
+X # Convert to half-degrees (range 0..720)
+X alpha = atan2(y, x)
+X hdeg = alpha*360.0/pi
+X hdeg = 180.0 - hdeg
+X hdeg = (hdeg + 720.0) % 720.0
+X atime = 5*int(hdeg/5.0 + 0.5)
+X if atime <> A.time or not A.set:
+X if A.set:
+X drawalarm(d)
+X erasealarmtime(d)
+X A.set = 1
+X A.time = atime
+X drawalarm(d)
+X drawalarmtime(d)
+X
+Xdef drawalarm(d):
+X p1 = calcpoint(float(A.time)/2.0, 1.02)
+X p2 = calcpoint(float(A.time)/2.0 - 4.0, 1.1)
+X p3 = calcpoint(float(A.time)/2.0 + 4.0, 1.1)
+X d.xorline(p1, p2)
+X d.xorline(p2, p3)
+X d.xorline(p3, p1)
+X
+Xdef erasealarmtime(d):
+X d.erase(G.statusarea)
+X
+Xdef drawalarmtime(d):
+X # A.time is in the range 0..720 with origin at 12 o'clock
+X # Convert to hours (0..12) and minutes (12*(0..60))
+X hh = A.time/60
+X mm = A.time%60
+X str = 'Alarm@' + dd(hh) + ':' + dd(mm)
+X p1 = (G.width - d.textwidth(str))/2, G.height
+X d.text(p1, str)
+X
+Xdef calctime(now):
+X seconds = now % 60
+X minutes = (now/60) % 60
+X hours = (now/3600) % 12
+X return hours, minutes, seconds
+X
+Xdef calcpoint(degrees, size):
+X alpha = pi/2.0 - float(degrees) * pi/180.0
+X x, y = cos(alpha), sin(alpha)
+X h, v = G.center
+X r = float(G.radius)
+X return h + int(x*size*r), v - int(y*size*r)
+X
+Xdef dd(n):
+X s = `n`
+X return '0'*(2-len(s)) + s
+X
+Xdef getlocaltime():
+X return time.time() - G.tzdiff
+X
+X#main()
+EOF
+fi
+if test -s 'lib/dircmp.py'
+then echo '*** I will not over-write existing file lib/dircmp.py'
+else
+echo 'x - lib/dircmp.py'
+sed 's/^X//' > 'lib/dircmp.py' << 'EOF'
+X# Module 'dirmp'
+X#
+X# Defines a class to build directory diff tools on.
+X
+Ximport posix
+X
+Ximport path
+X
+Ximport dircache
+Ximport cmpcache
+Ximport statcache
+Xfrom stat import *
+X
+X# Directory comparison class.
+X#
+Xclass dircmp():
+X #
+X def new(dd, (a, b)): # Initialize
+X dd.a = a
+X dd.b = b
+X # Properties that caller may change before callingdd. run():
+X dd.hide = ['.', '..'] # Names never to be shown
+X dd.ignore = ['RCS', 'tags'] # Names ignored in comparison
+X #
+X return dd
+X #
+X def run(dd): # Compare everything except common subdirectories
+X dd.a_list = filter(dircache.listdir(dd.a), dd.hide)
+X dd.b_list = filter(dircache.listdir(dd.b), dd.hide)
+X dd.a_list.sort()
+X dd.b_list.sort()
+X dd.phase1()
+X dd.phase2()
+X dd.phase3()
+X #
+X def phase1(dd): # Compute common names
+X dd.a_only = []
+X dd.common = []
+X for x in dd.a_list:
+X if x in dd.b_list:
+X dd.common.append(x)
+X else:
+X dd.a_only.append(x)
+X #
+X dd.b_only = []
+X for x in dd.b_list:
+X if x not in dd.common:
+X dd.b_only.append(x)
+X #
+X def phase2(dd): # Distinguish files, directories, funnies
+X dd.common_dirs = []
+X dd.common_files = []
+X dd.common_funny = []
+X #
+X for x in dd.common:
+X a_path = path.cat(dd.a, x)
+X b_path = path.cat(dd.b, x)
+X #
+X ok = 1
+X try:
+X a_stat = statcache.stat(a_path)
+X except posix.error, why:
+X # print 'Can\'t stat', a_path, ':', why[1]
+X ok = 0
+X try:
+X b_stat = statcache.stat(b_path)
+X except posix.error, why:
+X # print 'Can\'t stat', b_path, ':', why[1]
+X ok = 0
+X #
+X if ok:
+X a_type = S_IFMT(a_stat[ST_MODE])
+X b_type = S_IFMT(b_stat[ST_MODE])
+X if a_type <> b_type:
+X dd.common_funny.append(x)
+X elif S_ISDIR(a_type):
+X dd.common_dirs.append(x)
+X elif S_ISREG(a_type):
+X dd.common_files.append(x)
+X else:
+X dd.common_funny.append(x)
+X else:
+X dd.common_funny.append(x)
+X #
+X def phase3(dd): # Find out differences between common files
+X xx = cmpfiles(dd.a, dd.b, dd.common_files)
+X dd.same_files, dd.diff_files, dd.funny_files = xx
+X #
+X def phase4(dd): # Find out differences between common subdirectories
+X # A new dircmp object is created for each common subdirectory,
+X # these are stored in a dictionary indexed by filename.
+X # The hide and ignore properties are inherited from the parent
+X dd.subdirs = {}
+X for x in dd.common_dirs:
+X a_x = path.cat(dd.a, x)
+X b_x = path.cat(dd.b, x)
+X dd.subdirs[x] = newdd = dircmp().new(a_x, b_x)
+X newdd.hide = dd.hide
+X newdd.ignore = dd.ignore
+X newdd.run()
+X #
+X def phase4_closure(dd): # Recursively call phase4() on subdirectories
+X dd.phase4()
+X for x in dd.subdirs.keys():
+X dd.subdirs[x].phase4_closure()
+X #
+X def report(dd): # Print a report on the differences between a and b
+X # Assume that phases 1 to 3 have been executed
+X # Output format is purposely lousy
+X print 'diff', dd.a, dd.b
+X if dd.a_only:
+X print 'Only in', dd.a, ':', dd.a_only
+X if dd.b_only:
+X print 'Only in', dd.b, ':', dd.b_only
+X if dd.same_files:
+X print 'Identical files :', dd.same_files
+X if dd.diff_files:
+X print 'Differing files :', dd.diff_files
+X if dd.funny_files:
+X print 'Trouble with common files :', dd.funny_files
+X if dd.common_dirs:
+X print 'Common subdirectories :', dd.common_dirs
+X if dd.common_funny:
+X print 'Common funny cases :', dd.common_funny
+X #
+X def report_closure(dd): # Print reports on dd and on subdirs
+X # If phase 4 hasn't been done, no subdir reports are printed
+X dd.report()
+X try:
+X x = dd.subdirs
+X except NameError:
+X return # No subdirectories computed
+X for x in dd.subdirs.keys():
+X print
+X dd.subdirs[x].report_closure()
+X #
+X def report_phase4_closure(dd): # Report and do phase 4 recursively
+X dd.report()
+X dd.phase4()
+X for x in dd.subdirs.keys():
+X print
+X dd.subdirs[x].report_phase4_closure()
+X
+X
+X# Compare common files in two directories.
+X# Return:
+X# - files that compare equal
+X# - files that compare different
+X# - funny cases (can't stat etc.)
+X#
+Xdef cmpfiles(a, b, common):
+X res = ([], [], [])
+X for x in common:
+X res[cmp(path.cat(a, x), path.cat(b, x))].append(x)
+X return res
+X
+X
+X# Compare two files.
+X# Return:
+X# 0 for equal
+X# 1 for different
+X# 2 for funny cases (can't stat, etc.)
+X#
+Xdef cmp(a, b):
+X try:
+X if cmpcache.cmp(a, b): return 0
+X return 1
+X except posix.error:
+X return 2
+X
+X
+X# Remove a list item.
+X# NB: This modifies the list argument.
+X#
+Xdef remove(list, item):
+X for i in range(len(list)):
+X if list[i] = item:
+X del list[i]
+X break
+X
+X
+X# Return a copy with items that occur in skip removed.
+X#
+Xdef filter(list, skip):
+X result = []
+X for item in list:
+X if item not in skip: result.append(item)
+X return result
+X
+X
+X# Demonstration and testing.
+X#
+Xdef demo():
+X import sys
+X import getopt
+X options, args = getopt.getopt(sys.argv[1:], 'r')
+X if len(args) <> 2: raise getopt.error, 'need exactly two args'
+X dd = dircmp().new(args[0], args[1])
+X dd.run()
+X if ('-r', '') in options:
+X dd.report_phase4_closure()
+X else:
+X dd.report()
+X
+X# demo()
+EOF
+fi
+if test -s 'lib/dis.py'
+then echo '*** I will not over-write existing file lib/dis.py'
+else
+echo 'x - lib/dis.py'
+sed 's/^X//' > 'lib/dis.py' << 'EOF'
+X# Disassembler
+X
+Ximport sys
+Ximport string
+X
+Xdef dis():
+X tb = sys.last_traceback
+X while tb.tb_next: tb = tb.tb_next
+X distb(tb)
+X
+Xdef distb(tb):
+X disassemble(tb.tb_frame.f_code, tb.tb_lasti)
+X
+Xdef disco(co):
+X disassemble(co, -1)
+X
+Xdef disassemble(co, lasti):
+X code = co.co_code
+X labels = findlabels(code)
+X n = len(code)
+X i = 0
+X while i < n:
+X c = code[i]
+X op = ord(c)
+X if op = SET_LINENO and i > 0: print # Extra blank line
+X if i = lasti: print '-->',
+X else: print ' ',
+X if i in labels: print '>>',
+X else: print ' ',
+X print string.rjust(`i`, 4),
+X print string.ljust(opname[op], 15),
+X i = i+1
+X if op >= HAVE_ARGUMENT:
+X oparg = ord(code[i]) + ord(code[i+1])*256
+X i = i+2
+X print string.rjust(`oparg`, 5),
+X if op in hasconst:
+X print '(' + `co.co_consts[oparg]` + ')',
+X elif op in hasname:
+X print '(' + co.co_names[oparg] + ')',
+X elif op in hasjrel:
+X print '(to ' + `i + oparg` + ')',
+X print
+X
+Xdef findlabels(code):
+X labels = []
+X n = len(code)
+X i = 0
+X while i < n:
+X c = code[i]
+X op = ord(c)
+X i = i+1
+X if op >= HAVE_ARGUMENT:
+X oparg = ord(code[i]) + ord(code[i+1])*256
+X i = i+2
+X label = -1
+X if op in hasjrel:
+X label = i+oparg
+X elif op in hasjabs:
+X label = oparg
+X if label >= 0:
+X if label not in labels:
+X labels.append(label)
+X return labels
+X
+Xhasconst = []
+Xhasname = []
+Xhasjrel = []
+Xhasjabs = []
+X
+Xopname = range(256)
+Xfor op in opname: opname[op] = '<' + `op` + '>'
+X
+Xdef def_op(name, op):
+X opname[op] = name
+X
+Xdef name_op(name, op):
+X opname[op] = name
+X hasname.append(op)
+X
+Xdef jrel_op(name, op):
+X opname[op] = name
+X hasjrel.append(op)
+X
+Xdef jabs_op(name, op):
+X opname[op] = name
+X hasjabs.append(op)
+X
+X# Instruction opcodes for compiled code
+X
+Xdef_op('STOP_CODE', 0)
+Xdef_op('POP_TOP', 1)
+Xdef_op('ROT_TWO', 2)
+Xdef_op('ROT_THREE', 3)
+Xdef_op('DUP_TOP', 4)
+X
+Xdef_op('UNARY_POSITIVE', 10)
+Xdef_op('UNARY_NEGATIVE', 11)
+Xdef_op('UNARY_NOT', 12)
+Xdef_op('UNARY_CONVERT', 13)
+Xdef_op('UNARY_CALL', 14)
+X
+Xdef_op('BINARY_MULTIPLY', 20)
+Xdef_op('BINARY_DIVIDE', 21)
+Xdef_op('BINARY_MODULO', 22)
+Xdef_op('BINARY_ADD', 23)
+Xdef_op('BINARY_SUBTRACT', 24)
+Xdef_op('BINARY_SUBSCR', 25)
+Xdef_op('BINARY_CALL', 26)
+X
+Xdef_op('SLICE+0', 30)
+Xdef_op('SLICE+1', 31)
+Xdef_op('SLICE+2', 32)
+Xdef_op('SLICE+3', 33)
+X
+Xdef_op('STORE_SLICE+0', 40)
+Xdef_op('STORE_SLICE+1', 41)
+Xdef_op('STORE_SLICE+2', 42)
+Xdef_op('STORE_SLICE+3', 43)
+X
+Xdef_op('DELETE_SLICE+0', 50)
+Xdef_op('DELETE_SLICE+1', 51)
+Xdef_op('DELETE_SLICE+2', 52)
+Xdef_op('DELETE_SLICE+3', 53)
+X
+Xdef_op('STORE_SUBSCR', 60)
+Xdef_op('DELETE_SUBSCR', 61)
+X
+Xdef_op('PRINT_EXPR', 70)
+Xdef_op('PRINT_ITEM', 71)
+Xdef_op('PRINT_NEWLINE', 72)
+X
+Xdef_op('BREAK_LOOP', 80)
+Xdef_op('RAISE_EXCEPTION', 81)
+Xdef_op('LOAD_LOCALS', 82)
+Xdef_op('RETURN_VALUE', 83)
+Xdef_op('REQUIRE_ARGS', 84)
+Xdef_op('REFUSE_ARGS', 85)
+Xdef_op('BUILD_FUNCTION', 86)
+Xdef_op('POP_BLOCK', 87)
+Xdef_op('END_FINALLY', 88)
+Xdef_op('BUILD_CLASS', 89)
+X
+XHAVE_ARGUMENT = 90 # Opcodes from here have an argument:
+X
+Xname_op('STORE_NAME', 90) # Index in name list
+Xname_op('DELETE_NAME', 91) # ""
+Xdef_op('UNPACK_TUPLE', 92) # Number of tuple items
+Xdef_op('UNPACK_LIST', 93) # Number of list items
+X# unused: 94
+Xname_op('STORE_ATTR', 95) # Index in name list
+Xname_op('DELETE_ATTR', 96) # ""
+X
+Xdef_op('LOAD_CONST', 100) # Index in const list
+Xhasconst.append(100)
+Xname_op('LOAD_NAME', 101) # Index in name list
+Xdef_op('BUILD_TUPLE', 102) # Number of tuple items
+Xdef_op('BUILD_LIST', 103) # Number of list items
+Xdef_op('BUILD_MAP', 104) # Always zero for now
+Xname_op('LOAD_ATTR', 105) # Index in name list
+Xdef_op('COMPARE_OP', 106) # Comparison operator
+Xname_op('IMPORT_NAME', 107) # Index in name list
+Xname_op('IMPORT_FROM', 108) # Index in name list
+X
+Xjrel_op('JUMP_FORWARD', 110) # Number of bytes to skip
+Xjrel_op('JUMP_IF_FALSE', 111) # ""
+Xjrel_op('JUMP_IF_TRUE', 112) # ""
+Xjabs_op('JUMP_ABSOLUTE', 113) # Target byte offset from beginning of code
+Xjrel_op('FOR_LOOP', 114) # Number of bytes to skip
+X
+Xjrel_op('SETUP_LOOP', 120) # Distance to target address
+Xjrel_op('SETUP_EXCEPT', 121) # ""
+Xjrel_op('SETUP_FINALLY', 122) # ""
+X
+Xdef_op('SET_LINENO', 127) # Current line number
+XSET_LINENO = 127
+EOF
+fi
+if test -s 'lib/lambda.py'
+then echo '*** I will not over-write existing file lib/lambda.py'
+else
+echo 'x - lib/lambda.py'
+sed 's/^X//' > 'lib/lambda.py' << 'EOF'
+X# A bit of Lambda Calculus illustrated in Python.
+X#
+X# This does not use Python's built-in 'eval' or 'exec' functions!
+X
+X
+X# Currying
+X#
+X# From a function with 2 args, f(x, y), and a value for the 1st arg,
+X# we can create a new function with one argument fx(y) = f(x, y).
+X# This is called "Currying" (after the idea's inventor, a Mr. Curry).
+X#
+X# To implement this we create a class member, of which fx is a method;
+X# f and x are stored as data attributes of the member.
+X
+Xclass _CurryClass():
+X def new(self, (f, x)):
+X self.f = f
+X self.x = x
+X return self
+X def fx(self, y):
+X return self.f(self.x, y)
+X
+Xdef CURRY(f, x):
+X # NB: f is not "simple": it has 2 arguments
+X return _CurryClass().new(f, x).fx
+X
+X
+X# Numbers in Lambda Calculus
+X#
+X# In the lambda calculus, natural numbers are represented by
+X# higher-order functions Ntimes(f, x) that yield f applied N
+X# times to x, e.g., Twice(f, x) = f(f(x)).
+X# As far as I understand, there is no difference in real lambda
+X# calculus between
+X# lambda f x : f(f(x))
+X# and
+X# lambda f : f o f # 'o' means function composition
+X# but in Python we have to write the first as Twice(f, x) and
+X# the second as twice(f).
+X
+Xdef Never(f, x): return x
+Xdef Once(f, x): return f(x)
+Xdef Twice(f, x): return f(f(x))
+Xdef Thrice(f, x): return f(f(f(x)))
+Xdef Fourfold(f, x): return f(f(f(f(x))))
+X# (etc.)
+X
+Xdef never(f): return CURRY(Never, f)
+Xdef once(f): return CURRY(Once, f)
+Xdef twice(f): return CURRY(Twice, f)
+Xdef thrice(f): return CURRY(Thrice, f)
+Xdef fourfold(f): return CURRY(Fourfold, f)
+X# (etc.)
+X
+X
+X# NB: actually 'ntimes' is less concrete than 'Ntimes', as
+X# 'ntimes' returns a function, while 'Ntimes' returns a value
+X# similar to what f(x) returns. 'Ntimes' can be derived
+X# from 'ntimes', as follows:
+X# def Ntimes(f, x): return ntimes(f)(x)
+X# but this doesn't help us since 'ntimes' can only be defined
+X# using Ntimes (or a trick like the one used by CURRY).
+X
+X
+X# Arithmetic in Lambda Calculus
+X#
+X# We can perform simple arithmetic on the un-curried versions, e.g.,
+X# Successor(Twice) = Thrice (2+1)
+X# Sum(Thrice, Twice) = Fivefold (3+2)
+X# Product(Thrice, Twice) = Sixfold (3*2)
+X# Power(Thrice, Twice) = Ninefold (3**2)
+X#
+X# First we define versions that need f and x arguments.
+X# They have funny argument forms so the final functions can
+X# use CURRY, which only works on functions of exactly 2 arguments.
+X
+Xdef SUCCESSOR(Ntimes, (f, x)): return f(Ntimes(f, x))
+Xdef SUCCESSOR(Ntimes, (f, x)): return Ntimes(f, f(x)) # Same effect
+Xdef SUM(Ntimes, (Mtimes, (f, x))): return Ntimes(f, Mtimes(f, x))
+Xdef PRODUCT(Ntimes, (Mtimes, (f, x))): return Ntimes(CURRY(Mtimes, f), x)
+Xdef POWER(Ntimes, (Mtimes, (f, x))):
+X return Mtimes(CURRY(CURRY, Ntimes), f)(x)
+X
+Xdef Successor(Ntimes): return CURRY(SUCCESSOR, Ntimes)
+Xdef Sum(Ntimes, Mtimes): return CURRY(CURRY(SUM, Ntimes), Mtimes)
+Xdef Product(Ntimes, Mtimes): return CURRY(CURRY(PRODUCT, Ntimes), Mtimes)
+Xdef Power(Ntimes, Mtimes): return CURRY(CURRY(POWER, Ntimes), Mtimes)
+X
+X
+X# Sorry, I don't have a clue on how to do subtraction or division...
+X
+X
+X# References
+X#
+X# All I know about lambda calculus is from Roger Penrose's
+X# The Emperor's New Mind, Chapter 2.
+X
+X
+X# P.S.: Here is a Lambda function in Python.
+X# It uses 'exec' and expects two strings to describe the arguments
+X# and the function expression. Example:
+X# lambda('x', 'x+1')
+X# defines the successor function.
+X
+Xdef lambda(args, expr):
+X if '\n' in args or '\n' in expr:
+X raise RuntimeError, 'lambda: no cheating!'
+X stmt = 'def func(' + args + '): return ' + expr + '\n'
+X print 'lambda:', stmt,
+X exec(stmt)
+X return func
+X
+X
+X# P.P.S.S.: Here is a way to construct Ntimes and ntimes directly.
+X# Example:
+X# GenericNtimes(4)
+X# is equivalent to Fourfold.
+X
+Xclass _GenericNtimesClass():
+X def new(self, n):
+X self.n = n
+X return self
+X def Ntimes(self, (f, x)):
+X n = self.n
+X while n > 0: x, n = f(x), n-1
+X return x
+X
+Xdef GenericNtimes(n):
+X return _GenericNtimesClass().new(n).Ntimes
+X
+X
+X# To construct any 'ntimes' function from the corresponding 'Ntimes',
+X# we use a trick as used by CURRY. For example,
+X# Ntimes2ntimes(Fourfold)
+X# yields a function equivalent to fourfold.
+X
+Xclass _Ntimes2ntimesClass():
+X def new(self, Ntimes):
+X self.Ntimes = Ntimes
+X return self
+X def ntimes(self, f):
+X return CURRY(self.Ntimes, f)
+X
+Xdef Ntimes2ntimes(Ntimes): return _Ntimes2ntimesClass().new(Ntimes).ntimes
+X
+X
+X# This allows us to construct generic 'ntimes' functions. Example:
+X# generic_ntimes(3)
+X# is the same as thrice.
+X
+Xdef generic_ntimes(n): return Ntimes2ntimes(GenericNtimes(n))
+EOF
+fi
+if test -s 'lib/tb.py'
+then echo '*** I will not over-write existing file lib/tb.py'
+else
+echo 'x - lib/tb.py'
+sed 's/^X//' > 'lib/tb.py' << 'EOF'
+X# Print tracebacks, with a dump of local variables.
+X# Also an interactive stack trace browser.
+X
+Ximport sys
+Xtry:
+X import mac
+X os = mac
+Xexcept NameError:
+X import posix
+X os = posix
+Xfrom stat import *
+Ximport string
+X
+Xdef br(): browser(sys.last_traceback)
+X
+Xdef tb(): printtb(sys.last_traceback)
+X
+Xdef browser(tb):
+X if not tb:
+X print 'No traceback.'
+X return
+X tblist = []
+X while tb:
+X tblist.append(tb)
+X tb = tb.tb_next
+X ptr = len(tblist)-1
+X tb = tblist[ptr]
+X while 1:
+X if tb <> tblist[ptr]:
+X tb = tblist[ptr]
+X print `ptr` + ':',
+X printtbheader(tb)
+X try:
+X line = raw_input('TB: ')
+X except KeyboardInterrupt:
+X print '\n[Interrupted]'
+X break
+X except EOFError:
+X print '\n[EOF]'
+X break
+X cmd = string.strip(line)
+X if cmd:
+X if cmd = 'quit':
+X break
+X elif cmd = 'list':
+X browserlist(tb)
+X elif cmd = 'up':
+X if ptr-1 >= 0: ptr = ptr-1
+X else: print 'Bottom of stack.'
+X elif cmd = 'down':
+X if ptr+1 < len(tblist): ptr = ptr+1
+X else: print 'Top of stack.'
+X elif cmd = 'locals':
+X printsymbols(tb.tb_frame.f_locals)
+X elif cmd = 'globals':
+X printsymbols(tb.tb_frame.f_globals)
+X elif cmd in ('?', 'help'):
+X browserhelp()
+X else:
+X browserexec(tb, cmd)
+X
+Xdef browserlist(tb):
+X filename = tb.tb_frame.f_code.co_filename
+X lineno = tb.tb_lineno
+X last = lineno
+X first = max(1, last-10)
+X for i in range(first, last+1):
+X if i = lineno: prefix = '***' + string.rjust(`i`, 4) + ':'
+X else: prefix = string.rjust(`i`, 7) + ':'
+X line = readfileline(filename, i)
+X if line[-1:] = '\n': line = line[:-1]
+X print prefix + line
+X
+Xdef browserexec(tb, cmd):
+X locals = tb.tb_frame.f_locals
+X globals = tb.tb_frame.f_globals
+X try:
+X exec(cmd+'\n', globals, locals)
+X except:
+X print '*** Exception:',
+X print sys.exc_type,
+X if sys.exc_value <> None:
+X print ':', sys.exc_value,
+X print
+X print 'Type help to get help.'
+X
+Xdef browserhelp():
+X print
+X print ' This is the traceback browser. Commands are:'
+X print ' up : move one level up in the call stack'
+X print ' down : move one level down in the call stack'
+X print ' locals : print all local variables at this level'
+X print ' globals : print all global variables at this level'
+X print ' list : list source code around the failure'
+X print ' help : print help (what you are reading now)'
+X print ' quit : back to command interpreter'
+X print ' Typing any other 1-line statement will execute it'
+X print ' using the current level\'s symbol tables'
+X print
+X
+Xdef printtb(tb):
+X while tb:
+X print1tb(tb)
+X tb = tb.tb_next
+X
+Xdef print1tb(tb):
+X printtbheader(tb)
+X if tb.tb_frame.f_locals is not tb.tb_frame.f_globals:
+X printsymbols(tb.tb_frame.f_locals)
+X
+Xdef printtbheader(tb):
+X filename = tb.tb_frame.f_code.co_filename
+X lineno = tb.tb_lineno
+X info = '"' + filename + '"(' + `lineno` + ')'
+X line = readfileline(filename, lineno)
+X if line:
+X info = info + ': ' + string.strip(line)
+X print info
+X
+Xdef printsymbols(d):
+X keys = d.keys()
+X keys.sort()
+X for name in keys:
+X print ' ' + string.ljust(name, 12) + ':',
+X printobject(d[name], 4)
+X print
+X
+Xdef printobject(v, maxlevel):
+X if v = None:
+X print 'None',
+X elif type(v) in (type(0), type(0.0)):
+X print v,
+X elif type(v) = type(''):
+X if len(v) > 20:
+X print `v[:17] + '...'`,
+X else:
+X print `v`,
+X elif type(v) = type(()):
+X print '(',
+X printlist(v, maxlevel)
+X print ')',
+X elif type(v) = type([]):
+X print '[',
+X printlist(v, maxlevel)
+X print ']',
+X elif type(v) = type({}):
+X print '{',
+X printdict(v, maxlevel)
+X print '}',
+X else:
+X print v,
+X
+Xdef printlist(v, maxlevel):
+X n = len(v)
+X if n = 0: return
+X if maxlevel <= 0:
+X print '...',
+X return
+X for i in range(min(6, n)):
+X printobject(v[i], maxlevel-1)
+X if i+1 < n: print ',',
+X if n > 6: print '...',
+X
+Xdef printdict(v, maxlevel):
+X keys = v.keys()
+X n = len(keys)
+X if n = 0: return
+X if maxlevel <= 0:
+X print '...',
+X return
+X keys.sort()
+X for i in range(min(6, n)):
+X key = keys[i]
+X print `key` + ':',
+X printobject(v[key], maxlevel-1)
+X if i+1 < n: print ',',
+X if n > 6: print '...',
+X
+X_filecache = {}
+X
+Xdef readfileline(filename, lineno):
+X try:
+X stat = os.stat(filename)
+X except os.error, msg:
+X print 'Cannot stat', filename, '--', msg
+X return ''
+X cache_ok = 0
+X if _filecache.has_key(filename):
+X cached_stat, lines = _filecache[filename]
+X if stat[ST_SIZE] = cached_stat[ST_SIZE] and \
+X stat[ST_MTIME] = cached_stat[ST_MTIME]:
+X cache_ok = 1
+X else:
+X print 'Stale cache entry for', filename
+X del _filecache[filename]
+X if not cache_ok:
+X lines = readfilelines(filename)
+X if not lines:
+X return ''
+X _filecache[filename] = stat, lines
+X if 0 <= lineno-1 < len(lines):
+X return lines[lineno-1]
+X else:
+X print 'Line number out of range, last line is', len(lines)
+X return ''
+X
+Xdef readfilelines(filename):
+X try:
+X fp = open(filename, 'r')
+X except:
+X print 'Cannot open', filename
+X return []
+X lines = []
+X while 1:
+X line = fp.readline()
+X if not line: break
+X lines.append(line)
+X if not lines:
+X print 'Empty file', filename
+X return lines
+EOF
+fi
+if test -s 'src/errors.c'
+then echo '*** I will not over-write existing file src/errors.c'
+else
+echo 'x - src/errors.c'
+sed 's/^X//' > 'src/errors.c' << 'EOF'
+X/***********************************************************
+XCopyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The
+XNetherlands.
+X
+X All Rights Reserved
+X
+XPermission to use, copy, modify, and distribute this software and its
+Xdocumentation for any purpose and without fee is hereby granted,
+Xprovided that the above copyright notice appear in all copies and that
+Xboth that copyright notice and this permission notice appear in
+Xsupporting documentation, and that the names of Stichting Mathematisch
+XCentrum or CWI not be used in advertising or publicity pertaining to
+Xdistribution of the software without specific, written prior permission.
+X
+XSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+XTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+XFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+XFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+XWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+XACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+XOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+X
+X******************************************************************/
+X
+X/* Error handling -- see also run.c */
+X
+X/* New error handling interface.
+X
+X The following problem exists (existed): methods of built-in modules
+X are called with 'self' and 'args' arguments, but without a context
+X argument, so they have no way to raise a specific exception.
+X The same is true for the object implementations: no context argument.
+X The old convention was to set 'errno' and to return NULL.
+X The caller (usually call_function() in eval.c) detects the NULL
+X return value and then calls puterrno(ctx) to turn the errno value
+X into a true exception. Problems with this approach are:
+X - it used standard errno values to indicate Python-specific errors,
+X but this means that when such an error code is reported by a system
+X call (e.g., in module posix), the user gets a confusing message
+X - errno is a global variable, which makes extensions to a multi-
+X threading environment difficult; e.g., in IRIX, multi-threaded
+X programs must use the function oserror() instead of looking in errno
+X - there is no portable way to add new error numbers for specic
+X situations -- the value space for errno is reserved to the OS, yet
+X the way to turn module-specific errors into a module-specific
+X exception requires module-specific values for errno
+X - there is no way to add a more situation-specific message to an
+X error.
+X
+X The new interface solves all these problems. To return an error, a
+X built-in function calls err_set(exception), err_setval(exception,
+X value) or err_setstr(exception, string), and returns NULL. These
+X functions save the value for later use by puterrno(). To adapt this
+X scheme to a multi-threaded environment, only the implementation of
+X err_setval() has to be changed.
+X*/
+X
+X#include "allobjects.h"
+X
+X#include <errno.h>
+X#ifndef errno
+Xextern int errno;
+X#endif
+X
+X#include "errcode.h"
+X
+Xextern char *strerror PROTO((int));
+X
+X/* Last exception stored by err_setval() */
+X
+Xstatic object *last_exception;
+Xstatic object *last_exc_val;
+X
+Xvoid
+Xerr_setval(exception, value)
+X object *exception;
+X object *value;
+X{
+X XDECREF(last_exception);
+X XINCREF(exception);
+X last_exception = exception;
+X
+X XDECREF(last_exc_val);
+X XINCREF(value);
+X last_exc_val = value;
+X}
+X
+Xvoid
+Xerr_set(exception)
+X object *exception;
+X{
+X err_setval(exception, (object *)NULL);
+X}
+X
+Xvoid
+Xerr_setstr(exception, string)
+X object *exception;
+X char *string;
+X{
+X object *value = newstringobject(string);
+X err_setval(exception, value);
+X XDECREF(value);
+X}
+X
+Xint
+Xerr_occurred()
+X{
+X return last_exception != NULL;
+X}
+X
+Xvoid
+Xerr_get(p_exc, p_val)
+X object **p_exc;
+X object **p_val;
+X{
+X *p_exc = last_exception;
+X last_exception = NULL;
+X *p_val = last_exc_val;
+X last_exc_val = NULL;
+X}
+X
+Xvoid
+Xerr_clear()
+X{
+X XDECREF(last_exception);
+X last_exception = NULL;
+X XDECREF(last_exc_val);
+X last_exc_val = NULL;
+X}
+X
+X/* Convenience functions to set a type error exception and return 0 */
+X
+Xint
+Xerr_badarg()
+X{
+X err_setstr(TypeError, "illegal argument type for built-in operation");
+X return 0;
+X}
+X
+Xobject *
+Xerr_nomem()
+X{
+X err_set(MemoryError);
+X return NULL;
+X}
+X
+Xobject *
+Xerr_errno(exc)
+X object *exc;
+X{
+X object *v = newtupleobject(2);
+X if (v != NULL) {
+X settupleitem(v, 0, newintobject((long)errno));
+X settupleitem(v, 1, newstringobject(strerror(errno)));
+X }
+X err_setval(exc, v);
+X XDECREF(v);
+X return NULL;
+X}
+X
+Xvoid
+Xerr_badcall()
+X{
+X err_setstr(SystemError, "bad argument to internal function");
+X}
+X
+X/* Set the error appropriate to the given input error code (see errcode.h) */
+X
+Xvoid
+Xerr_input(err)
+X int err;
+X{
+X switch (err) {
+X case E_DONE:
+X case E_OK:
+X break;
+X case E_SYNTAX:
+X err_setstr(RuntimeError, "syntax error");
+X break;
+X case E_TOKEN:
+X err_setstr(RuntimeError, "illegal token");
+X break;
+X case E_INTR:
+X err_set(KeyboardInterrupt);
+X break;
+X case E_NOMEM:
+X err_nomem();
+X break;
+X case E_EOF:
+X err_set(EOFError);
+X break;
+X default:
+X err_setstr(RuntimeError, "unknown input error");
+X break;
+X }
+X}
+EOF
+fi
+if test -s 'src/mathmodule.c'
+then echo '*** I will not over-write existing file src/mathmodule.c'
+else
+echo 'x - src/mathmodule.c'
+sed 's/^X//' > 'src/mathmodule.c' << 'EOF'
+X/***********************************************************
+XCopyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The
+XNetherlands.
+X
+X All Rights Reserved
+X
+XPermission to use, copy, modify, and distribute this software and its
+Xdocumentation for any purpose and without fee is hereby granted,
+Xprovided that the above copyright notice appear in all copies and that
+Xboth that copyright notice and this permission notice appear in
+Xsupporting documentation, and that the names of Stichting Mathematisch
+XCentrum or CWI not be used in advertising or publicity pertaining to
+Xdistribution of the software without specific, written prior permission.
+X
+XSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+XTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+XFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+XFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+XWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+XACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+XOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+X
+X******************************************************************/
+X
+X/* Math module -- standard C math library functions, pi and e */
+X
+X#include "allobjects.h"
+X
+X#include <errno.h>
+X#ifndef errno
+Xextern int errno;
+X#endif
+X
+X#include "modsupport.h"
+X
+X#include <math.h>
+X
+Xstatic int
+Xgetdoublearg(args, px)
+X register object *args;
+X double *px;
+X{
+X if (args == NULL)
+X return err_badarg();
+X if (is_floatobject(args)) {
+X *px = getfloatvalue(args);
+X return 1;
+X }
+X if (is_intobject(args)) {
+X *px = getintvalue(args);
+X return 1;
+X }
+X return err_badarg();
+X}
+X
+Xstatic int
+Xget2doublearg(args, px, py)
+X register object *args;
+X double *px, *py;
+X{
+X if (args == NULL || !is_tupleobject(args) || gettuplesize(args) != 2)
+X return err_badarg();
+X return getdoublearg(gettupleitem(args, 0), px) &&
+X getdoublearg(gettupleitem(args, 1), py);
+X}
+X
+Xstatic object *
+Xmath_1(args, func)
+X object *args;
+X double (*func) FPROTO((double));
+X{
+X double x;
+X if (!getdoublearg(args, &x))
+X return NULL;
+X errno = 0;
+X x = (*func)(x);
+X if (errno != 0)
+X return NULL;
+X else
+X return newfloatobject(x);
+X}
+X
+Xstatic object *
+Xmath_2(args, func)
+X object *args;
+X double (*func) FPROTO((double, double));
+X{
+X double x, y;
+X if (!get2doublearg(args, &x, &y))
+X return NULL;
+X errno = 0;
+X x = (*func)(x, y);
+X if (errno != 0)
+X return NULL;
+X else
+X return newfloatobject(x);
+X}
+X
+X#define FUNC1(stubname, func) \
+X static object * stubname(self, args) object *self, *args; { \
+X return math_1(args, func); \
+X }
+X
+X#define FUNC2(stubname, func) \
+X static object * stubname(self, args) object *self, *args; { \
+X return math_2(args, func); \
+X }
+X
+XFUNC1(math_acos, acos)
+XFUNC1(math_asin, asin)
+XFUNC1(math_atan, atan)
+XFUNC2(math_atan2, atan2)
+XFUNC1(math_ceil, ceil)
+XFUNC1(math_cos, cos)
+XFUNC1(math_cosh, cosh)
+XFUNC1(math_exp, exp)
+XFUNC1(math_fabs, fabs)
+XFUNC1(math_floor, floor)
+X#if 0
+X/* XXX This one is not in the Amoeba library yet, so what the heck... */
+XFUNC2(math_fmod, fmod)
+X#endif
+XFUNC1(math_log, log)
+XFUNC1(math_log10, log10)
+XFUNC2(math_pow, pow)
+XFUNC1(math_sin, sin)
+XFUNC1(math_sinh, sinh)
+XFUNC1(math_sqrt, sqrt)
+XFUNC1(math_tan, tan)
+XFUNC1(math_tanh, tanh)
+X
+X#if 0
+X/* What about these? */
+Xdouble frexp(double x, int *i);
+Xdouble ldexp(double x, int n);
+Xdouble modf(double x, double *i);
+X#endif
+X
+Xstatic struct methodlist math_methods[] = {
+X {"acos", math_acos},
+X {"asin", math_asin},
+X {"atan", math_atan},
+X {"atan2", math_atan2},
+X {"ceil", math_ceil},
+X {"cos", math_cos},
+X {"cosh", math_cosh},
+X {"exp", math_exp},
+X {"fabs", math_fabs},
+X {"floor", math_floor},
+X#if 0
+X {"fmod", math_fmod},
+X {"frexp", math_freqp},
+X {"ldexp", math_ldexp},
+X#endif
+X {"log", math_log},
+X {"log10", math_log10},
+X#if 0
+X {"modf", math_modf},
+X#endif
+X {"pow", math_pow},
+X {"sin", math_sin},
+X {"sinh", math_sinh},
+X {"sqrt", math_sqrt},
+X {"tan", math_tan},
+X {"tanh", math_tanh},
+X {NULL, NULL} /* sentinel */
+X};
+X
+Xvoid
+Xinitmath()
+X{
+X object *m, *d, *v;
+X
+X m = initmodule("math", math_methods);
+X d = getmoduledict(m);
+X dictinsert(d, "pi", v = newfloatobject(atan(1.0) * 4.0));
+X DECREF(v);
+X dictinsert(d, "e", v = newfloatobject(exp(1.0)));
+X DECREF(v);
+X}
+EOF
+fi
+if test -s 'src/sysmodule.c'
+then echo '*** I will not over-write existing file src/sysmodule.c'
+else
+echo 'x - src/sysmodule.c'
+sed 's/^X//' > 'src/sysmodule.c' << 'EOF'
+X/***********************************************************
+XCopyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The
+XNetherlands.
+X
+X All Rights Reserved
+X
+XPermission to use, copy, modify, and distribute this software and its
+Xdocumentation for any purpose and without fee is hereby granted,
+Xprovided that the above copyright notice appear in all copies and that
+Xboth that copyright notice and this permission notice appear in
+Xsupporting documentation, and that the names of Stichting Mathematisch
+XCentrum or CWI not be used in advertising or publicity pertaining to
+Xdistribution of the software without specific, written prior permission.
+X
+XSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+XTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+XFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+XFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+XWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+XACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+XOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+X
+X******************************************************************/
+X
+X/* System module */
+X
+X/*
+XVarious bits of information used by the interpreter are collected in
+Xmodule 'sys'.
+XFunction member:
+X- exit(sts): call (C, POSIX) exit(sts)
+XData members:
+X- stdin, stdout, stderr: standard file objects
+X- modules: the table of modules (dictionary)
+X- path: module search path (list of strings)
+X- argv: script arguments (list of strings)
+X- ps1, ps2: optional primary and secondary prompts (strings)
+X*/
+X
+X#include "allobjects.h"
+X
+X#include "sysmodule.h"
+X#include "import.h"
+X#include "modsupport.h"
+X
+X/* Define delimiter used in $PYTHONPATH */
+X
+X#ifdef THINK_C
+X#define DELIM ' '
+X#endif
+X
+X#ifndef DELIM
+X#define DELIM ':'
+X#endif
+X
+Xstatic object *sysdict;
+X
+Xobject *
+Xsysget(name)
+X char *name;
+X{
+X return dictlookup(sysdict, name);
+X}
+X
+XFILE *
+Xsysgetfile(name, def)
+X char *name;
+X FILE *def;
+X{
+X FILE *fp = NULL;
+X object *v = sysget(name);
+X if (v != NULL)
+X fp = getfilefile(v);
+X if (fp == NULL)
+X fp = def;
+X return fp;
+X}
+X
+Xint
+Xsysset(name, v)
+X char *name;
+X object *v;
+X{
+X if (v == NULL)
+X return dictremove(sysdict, name);
+X else
+X return dictinsert(sysdict, name, v);
+X}
+X
+Xstatic object *
+Xsys_exit(self, args)
+X object *self;
+X object *args;
+X{
+X int sts;
+X if (!getintarg(args, &sts))
+X return NULL;
+X goaway(sts);
+X exit(sts); /* Just in case */
+X /* NOTREACHED */
+X}
+X
+Xstatic struct methodlist sys_methods[] = {
+X {"exit", sys_exit},
+X {NULL, NULL} /* sentinel */
+X};
+X
+Xstatic object *sysin, *sysout, *syserr;
+X
+Xvoid
+Xinitsys()
+X{
+X object *m = initmodule("sys", sys_methods);
+X sysdict = getmoduledict(m);
+X INCREF(sysdict);
+X /* NB keep an extra ref to the std files to avoid closing them
+X when the user deletes them */
+X /* XXX File objects should have a "don't close" flag instead */
+X sysin = newopenfileobject(stdin, "<stdin>", "r");
+X sysout = newopenfileobject(stdout, "<stdout>", "w");
+X syserr = newopenfileobject(stderr, "<stderr>", "w");
+X if (err_occurred())
+X fatal("can't create sys.std* file objects");
+X dictinsert(sysdict, "stdin", sysin);
+X dictinsert(sysdict, "stdout", sysout);
+X dictinsert(sysdict, "stderr", syserr);
+X dictinsert(sysdict, "modules", get_modules());
+X if (err_occurred())
+X fatal("can't insert sys.* objects in sys dict");
+X}
+X
+Xstatic object *
+Xmakepathobject(path, delim)
+X char *path;
+X int delim;
+X{
+X int i, n;
+X char *p;
+X object *v, *w;
+X
+X n = 1;
+X p = path;
+X while ((p = strchr(p, delim)) != NULL) {
+X n++;
+X p++;
+X }
+X v = newlistobject(n);
+X if (v == NULL)
+X return NULL;
+X for (i = 0; ; i++) {
+X p = strchr(path, delim);
+X if (p == NULL)
+X p = strchr(path, '\0'); /* End of string */
+X w = newsizedstringobject(path, (int) (p - path));
+X if (w == NULL) {
+X DECREF(v);
+X return NULL;
+X }
+X setlistitem(v, i, w);
+X if (*p == '\0')
+X break;
+X path = p+1;
+X }
+X return v;
+X}
+X
+Xvoid
+Xsetpythonpath(path)
+X char *path;
+X{
+X object *v;
+X if ((v = makepathobject(path, DELIM)) == NULL)
+X fatal("can't create sys.path");
+X if (sysset("path", v) != 0)
+X fatal("can't assign sys.path");
+X DECREF(v);
+X}
+X
+Xstatic object *
+Xmakeargvobject(argc, argv)
+X int argc;
+X char **argv;
+X{
+X object *av;
+X if (argc < 0 || argv == NULL)
+X argc = 0;
+X av = newlistobject(argc);
+X if (av != NULL) {
+X int i;
+X for (i = 0; i < argc; i++) {
+X object *v = newstringobject(argv[i]);
+X if (v == NULL) {
+X DECREF(av);
+X av = NULL;
+X break;
+X }
+X setlistitem(av, i, v);
+X }
+X }
+X return av;
+X}
+X
+Xvoid
+Xsetpythonargv(argc, argv)
+X int argc;
+X char **argv;
+X{
+X object *av = makeargvobject(argc, argv);
+X if (av == NULL)
+X fatal("no mem for sys.argv");
+X if (sysset("argv", av) != 0)
+X fatal("can't assign sys.argv");
+X DECREF(av);
+X}
+EOF
+fi
+if test -s 'src/timemodule.c'
+then echo '*** I will not over-write existing file src/timemodule.c'
+else
+echo 'x - src/timemodule.c'
+sed 's/^X//' > 'src/timemodule.c' << 'EOF'
+X/***********************************************************
+XCopyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The
+XNetherlands.
+X
+X All Rights Reserved
+X
+XPermission to use, copy, modify, and distribute this software and its
+Xdocumentation for any purpose and without fee is hereby granted,
+Xprovided that the above copyright notice appear in all copies and that
+Xboth that copyright notice and this permission notice appear in
+Xsupporting documentation, and that the names of Stichting Mathematisch
+XCentrum or CWI not be used in advertising or publicity pertaining to
+Xdistribution of the software without specific, written prior permission.
+X
+XSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+XTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+XFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+XFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+XWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+XACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+XOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+X
+X******************************************************************/
+X
+X/* Time module */
+X
+X#include "allobjects.h"
+X
+X#include "modsupport.h"
+X
+X#include "sigtype.h"
+X
+X#include <signal.h>
+X#include <setjmp.h>
+X
+X#ifdef __STDC__
+X#include <time.h>
+X#else /* !__STDC__ */
+Xtypedef unsigned long time_t;
+Xextern time_t time();
+X#endif /* !__STDC__ */
+X
+X
+X/* Time methods */
+X
+Xstatic object *
+Xtime_time(self, args)
+X object *self;
+X object *args;
+X{
+X long secs;
+X if (!getnoarg(args))
+X return NULL;
+X secs = time((time_t *)NULL);
+X return newintobject(secs);
+X}
+X
+Xstatic jmp_buf sleep_intr;
+X
+Xstatic void
+Xsleep_catcher(sig)
+X int sig;
+X{
+X longjmp(sleep_intr, 1);
+X}
+X
+Xstatic object *
+Xtime_sleep(self, args)
+X object *self;
+X object *args;
+X{
+X int secs;
+X SIGTYPE (*sigsave)();
+X if (!getintarg(args, &secs))
+X return NULL;
+X if (setjmp(sleep_intr)) {
+X signal(SIGINT, sigsave);
+X err_set(KeyboardInterrupt);
+X return NULL;
+X }
+X sigsave = signal(SIGINT, SIG_IGN);
+X if (sigsave != (SIGTYPE (*)()) SIG_IGN)
+X signal(SIGINT, sleep_catcher);
+X sleep(secs);
+X signal(SIGINT, sigsave);
+X INCREF(None);
+X return None;
+X}
+X
+X#ifdef THINK_C
+X#define DO_MILLI
+X#endif /* THINK_C */
+X
+X#ifdef AMOEBA
+X#define DO_MILLI
+Xextern long sys_milli();
+X#define millitimer sys_milli
+X#endif /* AMOEBA */
+X
+X#ifdef BSD_TIME
+X#define DO_MILLI
+X#endif /* BSD_TIME */
+X
+X#ifdef DO_MILLI
+X
+Xstatic object *
+Xtime_millisleep(self, args)
+X object *self;
+X object *args;
+X{
+X long msecs;
+X SIGTYPE (*sigsave)();
+X if (!getlongarg(args, &msecs))
+X return NULL;
+X if (setjmp(sleep_intr)) {
+X signal(SIGINT, sigsave);
+X err_set(KeyboardInterrupt);
+X return NULL;
+X }
+X sigsave = signal(SIGINT, SIG_IGN);
+X if (sigsave != (SIGTYPE (*)()) SIG_IGN)
+X signal(SIGINT, sleep_catcher);
+X millisleep(msecs);
+X signal(SIGINT, sigsave);
+X INCREF(None);
+X return None;
+X}
+X
+Xstatic object *
+Xtime_millitimer(self, args)
+X object *self;
+X object *args;
+X{
+X long msecs;
+X extern long millitimer();
+X if (!getnoarg(args))
+X return NULL;
+X msecs = millitimer();
+X return newintobject(msecs);
+X}
+X
+X#endif /* DO_MILLI */
+X
+X
+Xstatic struct methodlist time_methods[] = {
+X#ifdef DO_MILLI
+X {"millisleep", time_millisleep},
+X {"millitimer", time_millitimer},
+X#endif /* DO_MILLI */
+X {"sleep", time_sleep},
+X {"time", time_time},
+X {NULL, NULL} /* sentinel */
+X};
+X
+X
+Xvoid
+Xinittime()
+X{
+X initmodule("time", time_methods);
+X}
+X
+X
+X#ifdef THINK_C
+X
+X#define MacTicks (* (long *)0x16A)
+X
+Xstatic
+Xsleep(msecs)
+X int msecs;
+X{
+X register long deadline;
+X
+X deadline = MacTicks + msecs * 60;
+X while (MacTicks < deadline) {
+X if (intrcheck())
+X sleep_catcher(SIGINT);
+X }
+X}
+X
+Xstatic
+Xmillisleep(msecs)
+X long msecs;
+X{
+X register long deadline;
+X
+X deadline = MacTicks + msecs * 3 / 50; /* msecs * 60 / 1000 */
+X while (MacTicks < deadline) {
+X if (intrcheck())
+X sleep_catcher(SIGINT);
+X }
+X}
+X
+Xstatic long
+Xmillitimer()
+X{
+X return MacTicks * 50 / 3; /* MacTicks * 1000 / 60 */
+X}
+X
+X#endif /* THINK_C */
+X
+X
+X#ifdef BSD_TIME
+X
+X#include <sys/types.h>
+X#include <sys/time.h>
+X
+Xstatic long
+Xmillitimer()
+X{
+X struct timeval t;
+X struct timezone tz;
+X if (gettimeofday(&t, &tz) != 0)
+X return -1;
+X return t.tv_sec*1000 + t.tv_usec/1000;
+X
+X}
+X
+Xstatic
+Xmillisleep(msecs)
+X long msecs;
+X{
+X struct timeval t;
+X t.tv_sec = msecs/1000;
+X t.tv_usec = (msecs%1000)*1000;
+X (void) select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &t);
+X}
+X
+X#endif /* BSD_TIME */
+X
+EOF
+fi
+if test -s 'src/traceback.c'
+then echo '*** I will not over-write existing file src/traceback.c'
+else
+echo 'x - src/traceback.c'
+sed 's/^X//' > 'src/traceback.c' << 'EOF'
+X/***********************************************************
+XCopyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The
+XNetherlands.
+X
+X All Rights Reserved
+X
+XPermission to use, copy, modify, and distribute this software and its
+Xdocumentation for any purpose and without fee is hereby granted,
+Xprovided that the above copyright notice appear in all copies and that
+Xboth that copyright notice and this permission notice appear in
+Xsupporting documentation, and that the names of Stichting Mathematisch
+XCentrum or CWI not be used in advertising or publicity pertaining to
+Xdistribution of the software without specific, written prior permission.
+X
+XSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+XTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+XFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+XFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+XWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+XACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+XOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+X
+X******************************************************************/
+X
+X/* Traceback implementation */
+X
+X#include "allobjects.h"
+X
+X#include "compile.h"
+X#include "frameobject.h"
+X#include "traceback.h"
+X#include "structmember.h"
+X
+Xtypedef struct _tracebackobject {
+X OB_HEAD
+X struct _tracebackobject *tb_next;
+X frameobject *tb_frame;
+X int tb_lasti;
+X int tb_lineno;
+X} tracebackobject;
+X
+X#define OFF(x) offsetof(tracebackobject, x)
+X
+Xstatic struct memberlist tb_memberlist[] = {
+X {"tb_next", T_OBJECT, OFF(tb_next)},
+X {"tb_frame", T_OBJECT, OFF(tb_frame)},
+X {"tb_lasti", T_INT, OFF(tb_lasti)},
+X {"tb_lineno", T_INT, OFF(tb_lineno)},
+X {NULL} /* Sentinel */
+X};
+X
+Xstatic object *
+Xtb_getattr(tb, name)
+X tracebackobject *tb;
+X char *name;
+X{
+X return getmember((char *)tb, tb_memberlist, name);
+X}
+X
+Xstatic void
+Xtb_dealloc(tb)
+X tracebackobject *tb;
+X{
+X XDECREF(tb->tb_next);
+X XDECREF(tb->tb_frame);
+X DEL(tb);
+X}
+X
+Xstatic typeobject Tracebacktype = {
+X OB_HEAD_INIT(&Typetype)
+X 0,
+X "traceback",
+X sizeof(tracebackobject),
+X 0,
+X tb_dealloc, /*tp_dealloc*/
+X 0, /*tp_print*/
+X tb_getattr, /*tp_getattr*/
+X 0, /*tp_setattr*/
+X 0, /*tp_compare*/
+X 0, /*tp_repr*/
+X 0, /*tp_as_number*/
+X 0, /*tp_as_sequence*/
+X 0, /*tp_as_mapping*/
+X};
+X
+X#define is_tracebackobject(v) ((v)->ob_type == &Tracebacktype)
+X
+Xstatic tracebackobject *
+Xnewtracebackobject(next, frame, lasti, lineno)
+X tracebackobject *next;
+X frameobject *frame;
+X int lasti, lineno;
+X{
+X tracebackobject *tb;
+X if ((next != NULL && !is_tracebackobject(next)) ||
+X frame == NULL || !is_frameobject(frame)) {
+X err_badcall();
+X return NULL;
+X }
+X tb = NEWOBJ(tracebackobject, &Tracebacktype);
+X if (tb != NULL) {
+X XINCREF(next);
+X tb->tb_next = next;
+X XINCREF(frame);
+X tb->tb_frame = frame;
+X tb->tb_lasti = lasti;
+X tb->tb_lineno = lineno;
+X }
+X return tb;
+X}
+X
+Xstatic tracebackobject *tb_current = NULL;
+X
+Xint
+Xtb_here(frame, lasti, lineno)
+X frameobject *frame;
+X int lasti;
+X int lineno;
+X{
+X tracebackobject *tb;
+X tb = newtracebackobject(tb_current, frame, lasti, lineno);
+X if (tb == NULL)
+X return -1;
+X XDECREF(tb_current);
+X tb_current = tb;
+X return 0;
+X}
+X
+Xobject *
+Xtb_fetch()
+X{
+X object *v;
+X v = (object *)tb_current;
+X tb_current = NULL;
+X return v;
+X}
+X
+Xint
+Xtb_store(v)
+X object *v;
+X{
+X if (v != NULL && !is_tracebackobject(v)) {
+X err_badcall();
+X return -1;
+X }
+X XDECREF(tb_current);
+X XINCREF(v);
+X tb_current = (tracebackobject *)v;
+X return 0;
+X}
+X
+Xstatic void
+Xtb_displayline(fp, filename, lineno)
+X FILE *fp;
+X char *filename;
+X int lineno;
+X{
+X FILE *xfp;
+X char buf[1000];
+X int i;
+X if (filename[0] == '<' && filename[strlen(filename)-1] == '>')
+X return;
+X xfp = fopen(filename, "r");
+X if (xfp == NULL) {
+X fprintf(fp, " (cannot open \"%s\")\n", filename);
+X return;
+X }
+X for (i = 0; i < lineno; i++) {
+X if (fgets(buf, sizeof buf, xfp) == NULL)
+X break;
+X }
+X if (i == lineno) {
+X char *p = buf;
+X while (*p == ' ' || *p == '\t')
+X p++;
+X fprintf(fp, " %s", p);
+X if (strchr(p, '\n') == NULL)
+X fprintf(fp, "\n");
+X }
+X fclose(xfp);
+X}
+X
+Xstatic void
+Xtb_printinternal(tb, fp)
+X tracebackobject *tb;
+X FILE *fp;
+X{
+X while (tb != NULL) {
+X if (intrcheck()) {
+X fprintf(fp, "[interrupted]\n");
+X break;
+X }
+X fprintf(fp, " File \"");
+X printobject(tb->tb_frame->f_code->co_filename, fp, PRINT_RAW);
+X fprintf(fp, "\", line %d\n", tb->tb_lineno);
+X tb_displayline(fp,
+X getstringvalue(tb->tb_frame->f_code->co_filename),
+X tb->tb_lineno);
+X tb = tb->tb_next;
+X }
+X}
+X
+Xint
+Xtb_print(v, fp)
+X object *v;
+X FILE *fp;
+X{
+X if (v == NULL)
+X return 0;
+X if (!is_tracebackobject(v)) {
+X err_badcall();
+X return -1;
+X }
+X sysset("last_traceback", v);
+X tb_printinternal((tracebackobject *)v, fp);
+X return 0;
+X}
+EOF
+fi
+echo 'Part 15 out of 21 of pack.out complete.'
+exit 0