diff options
Diffstat (limited to 'shar/python-0.9.1-12-21.shar')
| -rw-r--r-- | shar/python-0.9.1-12-21.shar | 2833 |
1 files changed, 2833 insertions, 0 deletions
diff --git a/shar/python-0.9.1-12-21.shar b/shar/python-0.9.1-12-21.shar new file mode 100644 index 0000000..adb9780 --- /dev/null +++ b/shar/python-0.9.1-12-21.shar @@ -0,0 +1,2833 @@ +: 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 12 out of 21:' +if test -s 'demo/sgi/gl_panel/flying/flying.py' +then echo '*** I will not over-write existing file demo/sgi/gl_panel/flying/flying.py' +else +echo 'x - demo/sgi/gl_panel/flying/flying.py' +sed 's/^X//' > 'demo/sgi/gl_panel/flying/flying.py' << 'EOF' +X#! /ufs/guido/bin/sgi/python +X +Xfrom gl import * +Xfrom objdict import * +Xfrom GL import * +Ximport DEVICE, time +Ximport objectdef, light, panel, material +X +Xdef fixmatact (p) : +X p.diffR.fixact () +X p.diffG.fixact () +X p.diffB.fixact () +X p.specR.fixact () +X p.specG.fixact () +X p.specB.fixact () +X p.shine.fixact () +X +Xdef fixlichtact (p) : +X p.R.fixact () +X p.G.fixact () +X p.B.fixact () +X p.X.fixact () +X p.Y.fixact () +X p.Z.fixact () +X p.local.fixact () +X +Xdef cbsetlight (a) : +X p = a.back +X setlight (p, a.label) +X +Xdef cbsetmaterial (a) : +X p = a.back +X setmaterial (p, a.label) +X +Xmater = [0] +Xlicht = [0] +X +Xdef setmaterial (p, mname) : +X # +X mater [0:1] = [material.materdict [mname]] +X # +X p.diffR.val = mater [0][1] +X p.diffG.val = mater [0][2] +X p.diffB.val = mater [0][3] +X # +X p.specR.val = mater [0][5] +X p.specG.val = mater [0][6] +X p.specB.val = mater [0][7] +X # +X p.shine.val = mater [0][9] / 128.0 +X fixmatact (p) +X +Xdef setlight (p, mname) : +X # +X licht [0:1] = [material.lichtdict [mname]] +X # +X p.R.val = licht [0][1] +X p.G.val = licht [0][2] +X p.B.val = licht [0][3] +X # +X p.X.val = (licht [0][5] + 10.0) / 20.0 +X p.Y.val = (licht [0][6] + 10.0) / 20.0 +X p.Z.val = (licht [0][7] + 10.0) / 20.0 +X # +X p.local.val = licht [0][8] +X # +X fixlichtact (p) +X +Xdef cbmaterial (a) : +X # +X if mater[0] = 0 : return +X # +X p = a.back +X mater [0][5:8] = [p.diffR.val, p.diffG.val, p.diffB.val] +X mater [0][1:4] = [p.specR.val, p.specG.val, p.specB.val] +X mater [0][9:10] = [128.0 * p.shine.val] +X light.bindlight (0) +X +Xdef cblight (a) : +X # +X if licht[0] = 0 : return +X # +X p = a.back +X licht [0][1:4] = [p.R.val, p.G.val, p.B.val] +X licht [0][5:8] = [20.0 * p.X.val - 10.0, 20.0 * p.Y.val - 10.0, 20.0 * p.Z.val - 10.0] +X if p.local.val = 0.0 : +X licht [0][8:9] = [0.0] +X else: +X licht [0][8:9] = [1.0] +X # +X light.bindlight (0) +X +X# +X# initgl : initialize window, pipeline, light, viewing +X# +Xdef initgl () : +X # +X # init window +X # +X foreground () +X keepaspect (1, 1) +X prefposition (100, 500, 100, 500) +X w = winopen ('flying objects') +X keepaspect (1, 1) +X winconstraints () +X # +X # configure pipline +X # +X doublebuffer () +X shademodel (GOURAUD) +X zbuffer (1) +X RGBmode () +X gconfig () +X # +X # init lighting +X # +X light.bindlight (1) +X # +X # set viewing +X # +X lookat (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0) +X # +X +X# +X# drawit : draws the object with the given attributes. +X# +X# rfac : the rotation factor. +X# mat : the material identification +X# attr : a list of attributes : +X# +X# [[rotate vector ], [tranlate vector], [scale vector]] +X# i.e : +X# [[rX, rY, rZ], [tX, tY, tZ], [sX, sY, sZ]] +X# +Xdef drawit(object, rfac, attr, mat) : +X pushmatrix() +X rot (attr[0][0] * float (rfac), 'X') +X rot (attr[0][1] * float (rfac), 'Y') +X rot (attr[0][2] * float (rfac), 'Z') +X translate(attr[1][0], attr[1][1], attr[1][2]) +X scale(attr[2][0], attr[2][1], attr[2][2]) +X lmbind(MATERIAL, mat) +X objectdef.drawobject(object) +X popmatrix() +X +Xdef callbacksphere (a) : +X putDict (objects, 'sphere', int (a.val)) +X +Xdef callbackcylinder (a) : +X putDict (objects, 'cylinder', int (a.val)) +X +Xdef callbackcube (a) : +X putDict (objects, 'cube', int (a.val)) +X +Xdef callbackicecream (a) : +X putDict (objects, 'icecream', int (a.val)) +X +Xdef callbackdisk (a) : +X putDict (objects, 'disk', int (a.val)) +X +Xdef callbackdiamond (a) : +X putDict (objects, 'diamond', int (a.val)) +X +Xdef callbackglass (a) : +X putDict (objects, 'glass', int (a.val)) +X +Xdef callbackpyramid (a) : +X putDict (objects, 'pyramid', int (a.val)) +X +Xdef callbacktable (a) : +X putDict (objects, 'table', int (a.val)) +X +Xdef callbackflat (a) : +X shademodel(FLAT) +X +Xdef callbackgouraud (a) : +X shademodel(GOURAUD) +X +Xdef callbackwire (a) : +X objectdef.putFunc ([bgnclosedline, endclosedline]) +X +Xdef callbackfilled (a) : +X objectdef.putFunc ([bgnpolygon, endpolygon]) +X +Xdef callbackquit (a) : +X import sys +X sys.exit (-1) +X +Xdef allObjects(p, val) : +X p.sphere.val = val +X p.sphere.fixact () +X p.cube.val = val +X p.cube.fixact () +X p.cylinder.val = val +X p.cylinder.fixact () +X p.pyramid.val = val +X p.pyramid.fixact () +X p.disk.val = val +X p.disk.fixact () +X p.diamond.val = val +X p.diamond.fixact () +X p.icecream.val = val +X p.icecream.fixact () +X p.table.val = val +X p.table.fixact () +X p.fixpanel() +X +X +Xdef callbackshowall (a) : +X #print objects +X for key in objects.keys () : +X #print key +X putDict (objects, key, 1) +X allObjects (a.back, 1.0) +X +Xdef callbackshownone (a) : +X for key in objects.keys () : +X putDict (objects, key, 0) +X allObjects (a.back, 0.0) +X +X# +X# main : makeobjects, initialze graphics, and loop continuously. +X# +Xdef main () : +X # +X # iter keeps track of the iterations. It is used as the +X # (x, y, z) rotation increments to which the objects rotate. +X iter = 0 +X # +X # make the objects. the objects are put in the odict dictionary +X # +X od = objectdef.makeobjects () +X # +X # initialize gl +X # +X initgl () +X # +X # initialize time and iterations per second +X # +X time0 = time.time () # epoch-time of previous second +X fps = 0 # frames per second +X # +X # initialize panels +X # +X panel.needredraw() +X panels = panel.defpanellist('flying.s') #XXX +X p = panels[0] +X p.sphere.upfunc = callbacksphere +X p.cylinder.upfunc = callbackcylinder +X p.cube.upfunc = callbackcube +X p.icecream.upfunc = callbackicecream +X p.disk.upfunc = callbackdisk +X p.diamond.upfunc = callbackdiamond +X # NOT YET IMPLEMENTED p.glass.upfunc = callbackglass +X p.pyramid.upfunc = callbackpyramid +X p.table.upfunc = callbacktable +X p.wire.upfunc = callbackwire +X p.filled.upfunc = callbackfilled +X p.flat.upfunc = callbackflat +X p.gouraud.upfunc = callbackgouraud +X p.quit.upfunc = callbackquit +X p.showall.upfunc = callbackshowall +X p.shownone.upfunc = callbackshownone +X p.showall.back = p +X p.shownone.back = p +X # +X qanels = panel.defpanellist('freeze.s') #XXX +X q = qanels[0] +X # +X ranels = panel.defpanellist('materials.s') #XXX +X r = ranels[0] +X r.m9.upfunc = cbsetmaterial +X r.m8.upfunc = cbsetmaterial +X r.m7.upfunc = cbsetmaterial +X r.m6.upfunc = cbsetmaterial +X r.m5.upfunc = cbsetmaterial +X r.m4.upfunc = cbsetmaterial +X r.m3.upfunc = cbsetmaterial +X r.m2.upfunc = cbsetmaterial +X r.m1.upfunc = cbsetmaterial +X r.specR.activefunc = cbmaterial +X r.specG.activefunc = cbmaterial +X r.specB.activefunc = cbmaterial +X r.diffR.activefunc = cbmaterial +X r.diffG.activefunc = cbmaterial +X r.diffB.activefunc = cbmaterial +X r.shine.activefunc = cbmaterial +X r.m9.back = r +X r.m8.back = r +X r.m7.back = r +X r.m6.back = r +X r.m5.back = r +X r.m4.back = r +X r.m3.back = r +X r.m2.back = r +X r.m1.back = r +X r.diffR.back = r +X r.diffG.back = r +X r.diffB.back = r +X r.specR.back = r +X r.specG.back = r +X r.specB.back = r +X r.shine.back = r +X # +X sanels = panel.defpanellist('light.s') #XXX +X s = sanels[0] +X s.X.back = s +X s.Y.back = s +X s.Z.back = s +X s.R.back = s +X s.G.back = s +X s.B.back = s +X s.light1.back = s +X s.light2.back = s +X s.local.back = s +X s.light1.upfunc = cbsetlight +X s.light2.upfunc = cbsetlight +X s.R.activefunc = cblight +X s.G.activefunc = cblight +X s.B.activefunc = cblight +X s.X.activefunc = cblight +X s.Y.activefunc = cblight +X s.Z.activefunc = cblight +X # +X while 1 : +X # +X act = panel.dopanel() +X # +X wid = panel.userredraw () +X if wid : +X winset (wid) +X reshapeviewport() +X # +X # increment iter +X # +X if int (q.freeze.val) = 0 : +X iter = iter + 1 +X fps = fps + 1 +X if time.time() - time0 >= 1 : +X f = float(fps)/float(time.time()-time0) +X q.mystrip.val = f +X q.mystrip.fixact () +X q.fixpanel() +X time0 = time.time() +X fps = 0 +X # +X # clear the zbuffer and make the background light blue +X # +X zclear() +X c3i (LightBlue) +X clear() +X # +X # for each object in the objects dictionary +X # +X for key in objects.keys() : +X # +X # if the object should be displayed +X # +X if getDict (objects, key, 0) = ONE : +X loo = getDict (objects, key, 1) +X for o in loo : +X # +X # get attributes and materail +X # +X attr = o [1] +X mat = o [2] +X # +X # display the object +X # +X drawit(od[o[0]],iter,attr,mat) +X # +X swapbuffers() +X # +X +Xmain() +EOF +chmod +x 'demo/sgi/gl_panel/flying/flying.py' +fi +if test -s 'lib/adv.py' +then echo '*** I will not over-write existing file lib/adv.py' +else +echo 'x - lib/adv.py' +sed 's/^X//' > 'lib/adv.py' << 'EOF' +X#! /ufs/guido/bin/sgi/python +X +X# Module 'adv' -- text-oriented adventure game. +X +X +X# Name a constant that may once appear in the language... +X +Xdef return_nil(): return +Xnil = return_nil() +X +X +X# Copy of string.split() (to avoid loading all of string.py) +X +Xwhitespace = ' \t\n' +Xdef split(s): +X res = [] +X i, n = 0, len(s) +X while i < n: +X while i < n and s[i] in whitespace: i = i+1 +X if i = n: break +X j = i +X while j < n and s[j] not in whitespace: j = j+1 +X res.append(s[i:j]) +X i = j +X return res +X +X +X# Constants to name directions +X +XN = 'north' +XS = 'south' +XW = 'west' +XE = 'east' +XU = 'up' +XD = 'down' +XNW = 'nw' +XNE = 'ne' +XSW = 'sw' +XSE = 'se' +X +X +X# Constants to name other commands +X +XINVENT = 'invent' +XLOOK = 'look' +XBACK = 'back' +XHELP = 'help' +XGET = 'get' +XPUT = 'put' +X +X +X# Aliases recognized by the parser +X +Xalias = {} +Xalias['n'] = N +Xalias['s'] = S +Xalias['e'] = E +Xalias['w'] = W +Xalias['u'] = U +Xalias['d'] = D +Xalias['i'] = INVENT +Xalias['l'] = LOOK +Xalias['b'] = BACK +Xalias['take'] = GET +Xalias['drop'] = PUT +X +X +X# Normalize a command, in place: truncate words to 6 chars, and expand aliases. +X +Xdef normalize(cmd): +X for i in range(len(cmd)): +X word = cmd[i][:6] +X if alias.has_key(word): +X word = alias[word] +X cmd[i] = word +X +X +X# The Object class describes objects that the player can carry around. +X +Xclass Object(): +X def init(this, name): +X this.name = name +X return this +X def describe(this): +X print 'A', this.name + '.' +X def get(this, (player, room)): +X del room.objects[this.name] +X player.objects[this.name] = this +X def put(this, (player, room)): +X del player.objects[this.name] +X room.objects[this.name] = this +X +X +X# The Player class embodies first person control. +X +Xclass Player(): +X # Set initial state, except current room. +X def init(self, initial_room): +X self.blind = 0 +X self.here = initial_room +X self.prev = nil +X self.objects = {} +X return self +X # Read and execute commands forever. +X def play(self): +X self.here.casualdescribe() +X while 1: +X self.move() +X # Read and execute one command. +X def move(self): +X next = self.here.parser() +X if next and next <> self.here: +X self.prev = self.here +X self.here = next +X if not self.blind: +X self.here.casualdescribe() +X # Print inventory. +X def inventory(self): +X if not self.objects: +X print 'You aren\'t carrying anything.' +X return +X print 'You are carrying:' +X for key in self.objects.keys(): +X self.objects[key].describe() +X # Go back to previous room. +X def back(self): +X if self.prev: return self.prev +X print 'You can\'t go back now.' +X # Get an object from the room. +X def get(self, name): +X if self.here.objects.has_key(name): +X self.here.objects[name].get(self, self.here) +X else: +X print 'I see no', name, 'here.' +X # Put an object in the room. +X def put(self, name): +X if self.objects.has_key(name): +X self.objects[name].put(self, self.here) +X else: +X print 'You have no', name, 'with you.' +X +X +X# The Room class describes a generic room. +X# Rooms with special properties are defined by derived classes +X# that override certain operations. +X +Xclass Room(): +X # Initialize a featureless room. +X def init(here, name): +X here.seen = 0 +X here.name = name +X here.exits = {} +X here.objects = {} +X here.description = [] +X return here +X # Add an object to the room. Used during initialization. +X def add(here, obj): +X here.objects[obj.name] = obj +X # Print a casual description. +X def casualdescribe(here): +X if here.seen: +X print here.name + '.' +X here.listobjects() +X return +X here.seen = 1 +X here.describe() +X # Print a full description, including all exits and objects seen. +X def describe(here): +X if not here.description: +X print here.name + '.' +X here.listexits() +X else: +X for line in here.description: print line +X here.listobjects() +X # List exits. +X def listexits(here): +X there = here.exits.keys() +X if there: +X if len(there) = 1: +X print 'There is an exit leading', +X else: +X print 'There are exits leading', +X for name in there[:-2]: +X print name + ',', +X print there[len(there)-2], 'and', +X print there[len(there)-1] + '.' +X # List objects +X def listobjects(here): +X if here.objects: +X print 'I see:' +X for key in here.objects.keys(): +X here.objects[key].describe() +X # Default parser. Returns next room (possibly the same) or nil. +X def parser(here): +X cmd = here.getcmd(here.prompt()) +X return here.decide(cmd) +X # Return default prompt string. +X def prompt(here): return '> ' +X # Default input routine. Returns a non-empty list of words. +X def getcmd(here, prompt): +X # Loop until non-empty command gotten +X # EOFError and KeyboardInterrupt may be caught elsewhere +X while 1: +X line = raw_input(prompt) +X cmd = split(line) +X if cmd: +X normalize(cmd) +X return cmd +X # Default decision routine. Override for room-specific commands. +X def decide(here, cmd): +X key, args = cmd[0], cmd[1:] +X if not args: +X if key = N: return here.north() +X if key = S: return here.south() +X if key = E: return here.east() +X if key = W: return here.west() +X if key = U: return here.up() +X if key = D: return here.down() +X if key = NW: return here.nw() +X if key = NE: return here.ne() +X if key = SW: return here.sw() +X if key = SE: return here.se() +X if key = LOOK: return here.look() +X if key = INVENT: return here.inventory() +X if key = BACK: return here.back() +X if here.objects.has_key(key): +X print 'What do you want to do with the', key+'?' +X else: +X print 'Huh?' +X return +X if key = GET: +X for arg in args: +X player.get(arg) +X return +X if key = PUT: +X for arg in args: +X player.put(arg) +X # Standard commands. +X def look(here): +X here.describe() +X def inventory(here): +X player.inventory() +X def back(here): +X return player.back() +X # Standard exits. +X def north(here): return here.take_exit(N) +X def south(here): return here.take_exit(S) +X def west(here): return here.take_exit(W) +X def east(here): return here.take_exit(E) +X def up(here): return here.take_exit(U) +X def down(here): return here.take_exit(D) +X def nw(here): return here.take_exit(NW) +X def ne(here): return here.take_exit(NE) +X def sw(here): return here.take_exit(SW) +X def se(here): return here.take_exit(SE) +X # Subroutine for standard exits. +X def take_exit(here, key): +X if here.exits.has_key(key): +X return here.exits[key] +X print 'You cannot go in that direction.' +X return here +X +X +X# Create the objects we know about. +X# Object names begin with 'o_'. +X +Xo_lamp = Object().init('lamp') +Xo_python = Object().init('python') +X +X +X# Subroutine to connect two rooms. +X +Xdef connect(rm1, rm2, dir1, dir2): +X if dir1: +X rm1.exits[dir1] = rm2 +X if dir2: +X rm2.exits[dir2] = rm1 +X +X +X# Create the rooms and connect them together. +X# Room names begin with 'r_'. +X +Xr_front = Room().init('Front of building') +Xr_initial = r_front +Xr_front.description = [ \ +X 'You are standing in front of a large, desolate building.', \ +X 'Huge neon letters spell "CWI". The "I" is blinking.', \ +X 'There are entrances north and west from where you are standing.', \ +X ] +X +Xr_entrance = Room().init('Entrance') +Xr_entrance.description = [ \ +X 'You are standing in a small entrance room.', \ +X 'On the east side is a window to a reception room.', \ +X 'South is a door leading outside the building.', \ +X 'North is a large hall.' \ +X ] +X +Xr_hall_s = Room().init('South of hall') +Xr_hall_s.description = [ \ +X 'You are standing at the south side of a very large hall.', \ +X 'There are doors leading west, southwest, south and southeast,', \ +X 'and a corridor leads east.', \ +X 'The hall continues to the north.' \ +X ] +X +Xr_hall_n = Room().init('North of hall') +Xr_hall_n.description = [ \ +X 'You are stanting at the north side of a very large hall.', \ +X 'There are corridors leading west, northwest, northeast,', \ +X 'an elevator door north, and a door leading outside east.', \ +X 'There are stairs leading up, and the hall continues to the south.' \ +X ] +X +Xr_reception = Room().init('Reception') +X +Xr_mail = Room().init('Mail room') +X +Xconnect(r_front, r_entrance, N, S) +Xconnect(r_entrance, r_hall_s, N, SW) +Xconnect(r_hall_s, r_hall_n, N, S) +Xconnect(r_hall_s, r_reception, S, N) +Xconnect(r_hall_s, r_mail, SE, N) +Xconnect(r_reception, r_mail, E, W) +X +Xr_aud_front = Room().init('Front of Auditorium') +Xr_aud_back = Room().init('Back of Auditorium') +Xr_aud_tech = Room().init('Technician\'s room in Auditorium') +Xr_aud_proj = Room().init('Projection room in Auditorium') +X +Xconnect(r_aud_front, r_hall_s, E, W) +Xconnect(r_aud_front, r_aud_back, S, N) +Xconnect(r_aud_back, r_aud_proj, SE, N) +Xconnect(r_aud_front, r_aud_tech, W, E) +X +Xr_floor1 = Room().init('First floor') +Xr_floor2 = Room().init('Second floor') +Xr_floor3 = Room().init('Third floor') +X +Xconnect(r_hall_n, r_floor1, U, D) +Xconnect(r_floor1, r_floor2, U, D) +Xconnect(r_floor2, r_floor3, U, D) +X +X +X# Drop objects here and there +X +Xr_aud_proj.add(o_python) +Xr_reception.add(o_lamp) +X +X# Create an uninitialized player object. +X# It is initialized by main(), but must be created here (as global) +X# since some Room methods reference it. (Though maybe they shouldn't?) +X +Xplayer = Player() +X +X +X# Play the game from the beginning. +X +Xdef main(): +X x = player.init(r_initial) +X try: +X player.play() +X except (EOFError, KeyboardInterrupt): +X pass +X +Xmain() +EOF +fi +if test -s 'lib/cmpcache.py' +then echo '*** I will not over-write existing file lib/cmpcache.py' +else +echo 'x - lib/cmpcache.py' +sed 's/^X//' > 'lib/cmpcache.py' << 'EOF' +X# Module 'cmpcache' +X# +X# Efficiently compare files, boolean outcome only (equal / not equal). +X# +X# Tricks (used in this order): +X# - Use the statcache module to avoid statting files more than once +X# - Files with identical type, size & mtime are assumed to be clones +X# - Files with different type or size cannot be identical +X# - We keep a cache of outcomes of earlier comparisons +X# - We don't fork a process to run 'cmp' but read the files ourselves +X +Ximport posix +Xfrom stat import * +Ximport statcache +X +X +X# The cache. +X# +Xcache = {} +X +X +X# Compare two files, use the cache if possible. +X# May raise posix.error if a stat or open of either fails. +X# +Xdef cmp(f1, f2): +X # Return 1 for identical files, 0 for different. +X # Raise exceptions if either file could not be statted, read, etc. +X s1, s2 = sig(statcache.stat(f1)), sig(statcache.stat(f2)) +X if not S_ISREG(s1[0]) or not S_ISREG(s2[0]): +X # Either is a not a plain file -- always report as different +X return 0 +X if s1 = s2: +X # type, size & mtime match -- report same +X return 1 +X if s1[:2] <> s2[:2]: # Types or sizes differ, don't bother +X # types or sizes differ -- report different +X return 0 +X # same type and size -- look in the cache +X key = f1 + ' ' + f2 +X if cache.has_key(key): +X cs1, cs2, outcome = cache[key] +X # cache hit +X if s1 = cs1 and s2 = cs2: +X # cached signatures match +X return outcome +X # stale cached signature(s) +X # really compare +X outcome = do_cmp(f1, f2) +X cache[key] = s1, s2, outcome +X return outcome +X +X# Return signature (i.e., type, size, mtime) from raw stat data. +X# +Xdef sig(st): +X return S_IFMT(st[ST_MODE]), st[ST_SIZE], st[ST_MTIME] +X +X# Compare two files, really. +X# +Xdef do_cmp(f1, f2): +X #print ' cmp', f1, f2 # XXX remove when debugged +X bufsize = 8096 # Could be tuned +X fp1 = open(f1, 'r') +X fp2 = open(f2, 'r') +X while 1: +X b1 = fp1.read(bufsize) +X b2 = fp2.read(bufsize) +X if b1 <> b2: return 0 +X if not b1: return 1 +EOF +fi +if test -s 'lib/macshell.py' +then echo '*** I will not over-write existing file lib/macshell.py' +else +echo 'x - lib/macshell.py' +sed 's/^X//' > 'lib/macshell.py' << 'EOF' +X# Macintosh 'shell' +X# vi:set tabsize=4: +X +X# XXX string quoting in arguments +X# XXX directory stack +X# XXX $macros? +X# XXX ^C during any command +X# XXX 'sh' builtin command? +X# XXX why does open require absolute path? (need to fix chdir.c) +X +X +Ximport mac +X +Ximport macpath +Ximport string +Ximport glob +Xfrom macpath import isfile, isdir, exists +Ximport TclUtil # For splitting/quoting mechanisms +X +Xclass Struct(): pass +XG = Struct() +X +Xdef reset(): +X G.debug = 0 +X G.ps1 = '$ ' +X G.homedir = mac.getcwd() +X G.commands = mkcmdtab() +X G.aliases = {} +X +Xdef mkcmdtab(): +X tab = {} +X tab['alias'] = do_alias +X tab['cd'] = do_cd +X tab['debug'] = do_debug +X tab['grep'] = do_grep +X tab['help'] = do_help +X tab['ls'] = do_ls +X tab['mkdir'] = do_mkdir +X tab['mv'] = do_mv +X tab['page'] = do_page +X tab['pwd'] = do_pwd +X tab['reset'] = do_reset +X tab['rm'] = do_rm +X tab['rmdir'] = do_rmdir +X tab['sync'] = do_sync +X tab['unalias'] = do_unalias +X return tab +X +Xdef main(): +X while 1: +X try: +X line = raw_input(G.ps1) +X except EOFError: +X print '[EOF]' +X break +X except KeyboardInterrupt: +X print '[Intr]' +X line = '' +X if G.debug: +X print 'line:', `line` +X words = TclUtil.SplitList(line) +X if G.debug: +X print 'words:', words +X if words and words[0][0] <> '#': +X run(words) +X +Xdef run(words): +X expandaliases(words) +X cmd = words[0] +X args = words[1:] +X if G.commands.has_key(cmd): +X if args: +X try: +X args = expandgloblist(args) +X except glob_error, msg: +X print cmd, ': glob error :', msg +X return +X G.commands[cmd](args) +X return +X if hasglobchar(cmd): +X if args: +X print cmd, ': cannot glob pattern with arguments' +X return +X try: +X words = expandglobword(cmd) +X except glob_error, msg: +X print cmd, ': glob error :', msg +X return +X if len(words) > 1: +X columnize(words) +X return +X cmd = words[0] +X print cmd +X if isfile(cmd): +X if args: +X print cmd, ': file command expects no arguments' +X return +X do_page([cmd]) +X elif isdir(cmd): +X if args: +X print cmd, ': directory command expects no arguments' +X return +X do_cd([cmd]) +X else: +X print cmd, ': no such command, file or directory' +X +Xglob_error = 'glob error' +X +Xdef expandgloblist(words): +X res = [] +X for word in words: +X if hasglobchar(word): +X res = res + expandglobword(word) +X else: +X res.append(word) +X return res +X +Xdef expandglobword(word): +X names = glob.globlist(mac.listdir(':'), word) +X if not names: raise glob_error, 'no match for pattern ' + word +X return names +X +Xdef hasglobchar(word): +X return '*' in word or '?' in word +X +Xdef expandaliases(words): +X seen = [] +X cmd = words[0] +X while cmd not in seen and G.aliases.has_key(cmd): +X seen.append(cmd) +X words[:1] = G.aliases[cmd] +X cmd = words[0] +X +Xdef do_alias(args): +X if not args: +X listaliases() +X elif len(args) = 1: +X listalias(args[0]) +X else: +X defalias(args[0], args[1:]) +X +Xdef listaliases(): +X names = G.aliases.keys() +X names.sort() +X for name in names: listalias(name) +X +Xdef listalias(name): +X if not G.aliases.has_key(name): +X print name, ': no such alias' +X return +X print 'alias', name, +X printlist(G.aliases[name]) +X print +X +Xdef defalias(name, expansion): +X G.aliases[name] = expansion +X +Xdef do_cd(args): +X if len(args) > 1: +X print 'usage: cd [dirname]' +X elif args: +X chdirto(args[0]) +X else: +X chdirto(G.homedir) +X +Xdef chdirto(dirname): +X try: +X mac.chdir(dirname) +X except mac.error, msg: +X print dirname, ':', msg +X return +X +Xdef do_debug(args): +X G.debug = (not G.debug) +X +Xdef do_grep(args): +X if len(args) < 2: +X print 'usage: grep regexp file ...' +X return +X import regexp +X try: +X prog = regexp.compile(args[0]) +X except regexp.error, msg: +X print 'regexp.compile error for', args[0], ':', msg +X return +X for file in args[1:]: +X grepfile(prog, file) +X +Xdef grepfile(prog, file): +X try: +X fp = open(file, 'r') +X except RuntimeError, msg: +X print file, ': cannot open :', msg +X return +X lineno = 0 +X while 1: +X line = fp.readline() +X if not line: break +X lineno = lineno+1 +X if prog.exec(line): +X print file+'('+`lineno`+'):', line, +X +Xdef do_help(args): +X if args: +X print 'usage: help' +X return +X names = G.commands.keys() +X names.sort() +X columnize(names) +X +Xdef do_ls(args): +X if not args: +X lsdir(':') +X else: +X for dirname in args: +X lsdir(dirname) +X +Xdef lsdir(dirname): +X if not isdir(dirname): +X print dirname, ': no such directory' +X return +X names = mac.listdir(dirname) +X lsfiles(names, dirname) +X +Xdef lsfiles(names, dirname): +X names = names[:] # Make a copy so we can modify it +X for i in range(len(names)): +X name = names[i] +X if G.debug: print i, name +X if isdir(macpath.cat(dirname, name)): +X names[i] = ':' + name + ':' +X columnize(names) +X +Xdef columnize(list): +X COLUMNS = 80-1 +X n = len(list) +X colwidth = maxwidth(list) +X ncols = (COLUMNS + 1) / (colwidth + 1) +X if ncols < 1: ncols = 1 +X nrows = (n + ncols - 1) / ncols +X for irow in range(nrows): +X line = '' +X for icol in range(ncols): +X i = irow + nrows*icol +X if 0 <= i < n: +X word = list[i] +X if i+nrows < n: +X word = string.ljust(word, colwidth) +X if icol > 0: +X word = ' ' + word +X line = line + word +X print line +X +Xdef maxwidth(list): +X width = 0 +X for word in list: +X if len(word) > width: +X width = len(word) +X return width +X +Xdef do_mv(args): +X if len(args) <> 2: +X print 'usage: mv src dst' +X return +X src, dst = args[0], args[1] +X if not exists(src): +X print src, ': source does not exist' +X return +X if exists(dst): +X print src, ': destination already exists' +X return +X try: +X mac.rename(src, dst) +X except mac.error, msg: +X print src, dst, ': rename failed:', msg +X +Xdef do_mkdir(args): +X if not args: +X print 'usage: mkdir name ...' +X return +X for name in args: +X makedir(name) +X +Xdef makedir(name): +X if exists(name): +X print name, ': already exists' +X return +X try: +X mac.mkdir(name, 0777) +X except mac.error, msg: +X print name, ': mkdir failed:', msg +X +Xdef do_page(args): +X if not args: +X print 'usage: page file ...' +X return +X for name in args: +X pagefile(name) +X +Xdef pagefile(name): +X if not isfile(name): +X print name, ': no such file' +X return +X LINES = 24 - 1 +X # For THINK C 3.0, make the path absolute: +X # if not macpath.isabs(name): +X # name = macpath.cat(mac.getcwd(), name) +X try: +X fp = open(name, 'r') +X except: +X print name, ': cannot open' +X return +X line = fp.readline() +X while line: +X for i in range(LINES): +X print line, +X line = fp.readline() +X if not line: break +X if line: +X try: +X more = raw_input('[more]') +X except (EOFError, KeyboardInterrupt): +X print +X break +X if string.strip(more)[:1] in ('q', 'Q'): +X break +X +Xdef do_pwd(args): +X if args: +X print 'usage: pwd' +X else: +X print mac.getcwd() +X +Xdef do_reset(args): +X if args: +X print 'usage: reset' +X else: +X reset() +X +Xdef do_rm(args): +X if not args: +X print 'usage: rm file ...' +X return +X for name in args: +X remove(name) +X +Xdef remove(name): +X if not isfile(name): +X print name, ': no such file' +X return +X try: +X mac.unlink(name) +X except mac.error, msg: +X print name, ': unlink failed:', msg +X +Xdef do_rmdir(args): +X if not args: +X print 'usage: rmdir dir ...' +X return +X for name in args: +X rmdir(name) +X +Xdef rmdir(name): +X if not isdir(name): +X print name, ': no such directory' +X return +X try: +X mac.rmdir(name) +X except mac.error, msg: +X print name, ': rmdir failed:', msg +X +Xdef do_sync(args): +X if args: +X print 'usage: sync' +X return +X try: +X mac.sync() +X except mac.error, msg: +X print 'sync failed:', msg +X +Xdef do_unalias(args): +X if not args: +X print 'usage: unalias name ...' +X return +X for name in args: +X unalias(name) +X +Xdef unalias(name): +X if not G.aliases.has_key(name): +X print name, ': no such alias' +X return +X del G.aliases[name] +X +Xdef printlist(list): +X for word in list: +X print word, +X +Xreset() +Xmain() +EOF +fi +if test -s 'src/cgensupport.c' +then echo '*** I will not over-write existing file src/cgensupport.c' +else +echo 'x - src/cgensupport.c' +sed 's/^X//' > 'src/cgensupport.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/* Functions used by cgen output */ +X +X#include <stdio.h> +X +X#include "PROTO.h" +X#include "object.h" +X#include "intobject.h" +X#include "floatobject.h" +X#include "stringobject.h" +X#include "tupleobject.h" +X#include "listobject.h" +X#include "methodobject.h" +X#include "moduleobject.h" +X#include "modsupport.h" +X#include "import.h" +X#include "cgensupport.h" +X#include "errors.h" +X +X +X/* Functions to construct return values */ +X +Xobject * +Xmknewcharobject(c) +X int c; +X{ +X char ch[1]; +X ch[0] = c; +X return newsizedstringobject(ch, 1); +X} +X +X/* Functions to extract arguments. +X These needs to know the total number of arguments supplied, +X since the argument list is a tuple only of there is more than +X one argument. */ +X +Xint +Xgetiobjectarg(args, nargs, i, p_arg) +X register object *args; +X int nargs, i; +X object **p_arg; +X{ +X if (nargs != 1) { +X if (args == NULL || !is_tupleobject(args) || +X nargs != gettuplesize(args) || +X i < 0 || i >= nargs) { +X return err_badarg(); +X } +X else { +X args = gettupleitem(args, i); +X } +X } +X if (args == NULL) { +X return err_badarg(); +X } +X *p_arg = args; +X return 1; +X} +X +Xint +Xgetilongarg(args, nargs, i, p_arg) +X register object *args; +X int nargs, i; +X long *p_arg; +X{ +X if (nargs != 1) { +X if (args == NULL || !is_tupleobject(args) || +X nargs != gettuplesize(args) || +X i < 0 || i >= nargs) { +X return err_badarg(); +X } +X args = gettupleitem(args, i); +X } +X if (args == NULL || !is_intobject(args)) { +X return err_badarg(); +X } +X *p_arg = getintvalue(args); +X return 1; +X} +X +Xint +Xgetishortarg(args, nargs, i, p_arg) +X register object *args; +X int nargs, i; +X short *p_arg; +X{ +X long x; +X if (!getilongarg(args, nargs, i, &x)) +X return 0; +X *p_arg = x; +X return 1; +X} +X +Xstatic int +Xextractdouble(v, p_arg) +X register object *v; +X double *p_arg; +X{ +X if (v == NULL) { +X /* Fall through to error return at end of function */ +X } +X else if (is_floatobject(v)) { +X *p_arg = GETFLOATVALUE((floatobject *)v); +X return 1; +X } +X else if (is_intobject(v)) { +X *p_arg = GETINTVALUE((intobject *)v); +X return 1; +X } +X return err_badarg(); +X} +X +Xstatic int +Xextractfloat(v, p_arg) +X register object *v; +X float *p_arg; +X{ +X if (v == NULL) { +X /* Fall through to error return at end of function */ +X } +X else if (is_floatobject(v)) { +X *p_arg = GETFLOATVALUE((floatobject *)v); +X return 1; +X } +X else if (is_intobject(v)) { +X *p_arg = GETINTVALUE((intobject *)v); +X return 1; +X } +X return err_badarg(); +X} +X +Xint +Xgetifloatarg(args, nargs, i, p_arg) +X register object *args; +X int nargs, i; +X float *p_arg; +X{ +X object *v; +X float x; +X if (!getiobjectarg(args, nargs, i, &v)) +X return 0; +X if (!extractfloat(v, &x)) +X return 0; +X *p_arg = x; +X return 1; +X} +X +Xint +Xgetistringarg(args, nargs, i, p_arg) +X object *args; +X int nargs, i; +X string *p_arg; +X{ +X object *v; +X if (!getiobjectarg(args, nargs, i, &v)) +X return NULL; +X if (!is_stringobject(v)) { +X return err_badarg(); +X } +X *p_arg = getstringvalue(v); +X return 1; +X} +X +Xint +Xgetichararg(args, nargs, i, p_arg) +X object *args; +X int nargs, i; +X char *p_arg; +X{ +X string x; +X if (!getistringarg(args, nargs, i, &x)) +X return 0; +X if (x[0] == '\0' || x[1] != '\0') { +X /* Not exactly one char */ +X return err_badarg(); +X } +X *p_arg = x[0]; +X return 1; +X} +X +Xint +Xgetilongarraysize(args, nargs, i, p_arg) +X object *args; +X int nargs, i; +X long *p_arg; +X{ +X object *v; +X if (!getiobjectarg(args, nargs, i, &v)) +X return 0; +X if (is_tupleobject(v)) { +X *p_arg = gettuplesize(v); +X return 1; +X } +X if (is_listobject(v)) { +X *p_arg = getlistsize(v); +X return 1; +X } +X return err_badarg(); +X} +X +Xint +Xgetishortarraysize(args, nargs, i, p_arg) +X object *args; +X int nargs, i; +X short *p_arg; +X{ +X long x; +X if (!getilongarraysize(args, nargs, i, &x)) +X return 0; +X *p_arg = x; +X return 1; +X} +X +X/* XXX The following four are too similar. Should share more code. */ +X +Xint +Xgetilongarray(args, nargs, i, n, p_arg) +X object *args; +X int nargs, i; +X int n; +X long *p_arg; /* [n] */ +X{ +X object *v, *w; +X if (!getiobjectarg(args, nargs, i, &v)) +X return 0; +X if (is_tupleobject(v)) { +X if (gettuplesize(v) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X w = gettupleitem(v, i); +X if (!is_intobject(w)) { +X return err_badarg(); +X } +X p_arg[i] = getintvalue(w); +X } +X return 1; +X } +X else if (is_listobject(v)) { +X if (getlistsize(v) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X w = getlistitem(v, i); +X if (!is_intobject(w)) { +X return err_badarg(); +X } +X p_arg[i] = getintvalue(w); +X } +X return 1; +X } +X else { +X return err_badarg(); +X } +X} +X +Xint +Xgetishortarray(args, nargs, i, n, p_arg) +X object *args; +X int nargs, i; +X int n; +X short *p_arg; /* [n] */ +X{ +X object *v, *w; +X if (!getiobjectarg(args, nargs, i, &v)) +X return 0; +X if (is_tupleobject(v)) { +X if (gettuplesize(v) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X w = gettupleitem(v, i); +X if (!is_intobject(w)) { +X return err_badarg(); +X } +X p_arg[i] = getintvalue(w); +X } +X return 1; +X } +X else if (is_listobject(v)) { +X if (getlistsize(v) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X w = getlistitem(v, i); +X if (!is_intobject(w)) { +X return err_badarg(); +X } +X p_arg[i] = getintvalue(w); +X } +X return 1; +X } +X else { +X return err_badarg(); +X } +X} +X +Xint +Xgetidoublearray(args, nargs, i, n, p_arg) +X object *args; +X int nargs, i; +X int n; +X double *p_arg; /* [n] */ +X{ +X object *v, *w; +X if (!getiobjectarg(args, nargs, i, &v)) +X return 0; +X if (is_tupleobject(v)) { +X if (gettuplesize(v) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X w = gettupleitem(v, i); +X if (!extractdouble(w, &p_arg[i])) +X return 0; +X } +X return 1; +X } +X else if (is_listobject(v)) { +X if (getlistsize(v) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X w = getlistitem(v, i); +X if (!extractdouble(w, &p_arg[i])) +X return 0; +X } +X return 1; +X } +X else { +X return err_badarg(); +X } +X} +X +Xint +Xgetifloatarray(args, nargs, i, n, p_arg) +X object *args; +X int nargs, i; +X int n; +X float *p_arg; /* [n] */ +X{ +X object *v, *w; +X if (!getiobjectarg(args, nargs, i, &v)) +X return 0; +X if (is_tupleobject(v)) { +X if (gettuplesize(v) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X w = gettupleitem(v, i); +X if (!extractfloat(w, &p_arg[i])) +X return 0; +X } +X return 1; +X } +X else if (is_listobject(v)) { +X if (getlistsize(v) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X w = getlistitem(v, i); +X if (!extractfloat(w, &p_arg[i])) +X return 0; +X } +X return 1; +X } +X else { +X return err_badarg(); +X } +X} +EOF +fi +if test -s 'src/modsupport.c' +then echo '*** I will not over-write existing file src/modsupport.c' +else +echo 'x - src/modsupport.c' +sed 's/^X//' > 'src/modsupport.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/* Module support implementation */ +X +X#include "allobjects.h" +X#include "modsupport.h" +X#include "import.h" +X +X +Xobject * +Xinitmodule(name, methods) +X char *name; +X struct methodlist *methods; +X{ +X object *m, *d, *v; +X struct methodlist *ml; +X char namebuf[256]; +X if ((m = add_module(name)) == NULL) { +X fprintf(stderr, "initializing module: %s\n", name); +X fatal("can't create a module"); +X } +X d = getmoduledict(m); +X for (ml = methods; ml->ml_name != NULL; ml++) { +X sprintf(namebuf, "%s.%s", name, ml->ml_name); +X v = newmethodobject(strdup(namebuf), ml->ml_meth, +X (object *)NULL); +X /* XXX The strdup'ed memory is never freed */ +X if (v == NULL || dictinsert(d, ml->ml_name, v) != 0) { +X fprintf(stderr, "initializing module: %s\n", name); +X fatal("can't initialize module"); +X } +X DECREF(v); +X } +X return m; +X} +X +X +X/* Argument list handling tools. +X All return 1 for success, or call err_set*() and return 0 for failure */ +X +Xint +Xgetnoarg(v) +X object *v; +X{ +X if (v != NULL) { +X return err_badarg(); +X } +X return 1; +X} +X +Xint +Xgetintarg(v, a) +X object *v; +X int *a; +X{ +X if (v == NULL || !is_intobject(v)) { +X return err_badarg(); +X } +X *a = getintvalue(v); +X return 1; +X} +X +Xint +Xgetintintarg(v, a, b) +X object *v; +X int *a; +X int *b; +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 2) { +X return err_badarg(); +X } +X return getintarg(gettupleitem(v, 0), a) && +X getintarg(gettupleitem(v, 1), b); +X} +X +Xint +Xgetlongarg(v, a) +X object *v; +X long *a; +X{ +X if (v == NULL || !is_intobject(v)) { +X return err_badarg(); +X } +X *a = getintvalue(v); +X return 1; +X} +X +Xint +Xgetlonglongargs(v, a, b) +X object *v; +X long *a, *b; +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 2) { +X return err_badarg(); +X } +X return getlongarg(gettupleitem(v, 0), a) && +X getlongarg(gettupleitem(v, 1), b); +X} +X +Xint +Xgetlonglongobjectargs(v, a, b, c) +X object *v; +X long *a, *b; +X object **c; +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 3) { +X return err_badarg(); +X } +X if (getlongarg(gettupleitem(v, 0), a) && +X getlongarg(gettupleitem(v, 1), b)) { +X *c = gettupleitem(v, 2); +X return 1; +X } +X else { +X return err_badarg(); +X } +X} +X +Xint +Xgetstrarg(v, a) +X object *v; +X object **a; +X{ +X if (v == NULL || !is_stringobject(v)) { +X return err_badarg(); +X } +X *a = v; +X return 1; +X} +X +Xint +Xgetstrstrarg(v, a, b) +X object *v; +X object **a; +X object **b; +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 2) { +X return err_badarg(); +X } +X return getstrarg(gettupleitem(v, 0), a) && +X getstrarg(gettupleitem(v, 1), b); +X} +X +Xint +Xgetstrstrintarg(v, a, b, c) +X object *v; +X object **a; +X object **b; +X int *c; +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 3) { +X return err_badarg(); +X } +X return getstrarg(gettupleitem(v, 0), a) && +X getstrarg(gettupleitem(v, 1), b) && +X getintarg(gettupleitem(v, 2), c); +X} +X +Xint +Xgetstrintarg(v, a, b) +X object *v; +X object **a; +X int *b; +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 2) { +X return err_badarg(); +X } +X return getstrarg(gettupleitem(v, 0), a) && +X getintarg(gettupleitem(v, 1), b); +X} +X +Xint +Xgetintstrarg(v, a, b) +X object *v; +X int *a; +X object **b; +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 2) { +X return err_badarg(); +X } +X return getintarg(gettupleitem(v, 0), a) && +X getstrarg(gettupleitem(v, 1), b); +X} +X +Xint +Xgetpointarg(v, a) +X object *v; +X int *a; /* [2] */ +X{ +X return getintintarg(v, a, a+1); +X} +X +Xint +Xget3pointarg(v, a) +X object *v; +X int *a; /* [6] */ +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 3) { +X return err_badarg(); +X } +X return getpointarg(gettupleitem(v, 0), a) && +X getpointarg(gettupleitem(v, 1), a+2) && +X getpointarg(gettupleitem(v, 2), a+4); +X} +X +Xint +Xgetrectarg(v, a) +X object *v; +X int *a; /* [2+2] */ +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 2) { +X return err_badarg(); +X } +X return getpointarg(gettupleitem(v, 0), a) && +X getpointarg(gettupleitem(v, 1), a+2); +X} +X +Xint +Xgetrectintarg(v, a) +X object *v; +X int *a; /* [4+1] */ +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 2) { +X return err_badarg(); +X } +X return getrectarg(gettupleitem(v, 0), a) && +X getintarg(gettupleitem(v, 1), a+4); +X} +X +Xint +Xgetpointintarg(v, a) +X object *v; +X int *a; /* [2+1] */ +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 2) { +X return err_badarg(); +X } +X return getpointarg(gettupleitem(v, 0), a) && +X getintarg(gettupleitem(v, 1), a+2); +X} +X +Xint +Xgetpointstrarg(v, a, b) +X object *v; +X int *a; /* [2] */ +X object **b; +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 2) { +X return err_badarg(); +X } +X return getpointarg(gettupleitem(v, 0), a) && +X getstrarg(gettupleitem(v, 1), b); +X} +X +Xint +Xgetstrintintarg(v, a, b, c) +X object *v; +X object *a; +X int *b, *c; +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 3) { +X return err_badarg(); +X } +X return getstrarg(gettupleitem(v, 0), a) && +X getintarg(gettupleitem(v, 1), b) && +X getintarg(gettupleitem(v, 2), c); +X} +X +Xint +Xgetrectpointarg(v, a) +X object *v; +X int *a; /* [4+2] */ +X{ +X if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 2) { +X return err_badarg(); +X } +X return getrectarg(gettupleitem(v, 0), a) && +X getpointarg(gettupleitem(v, 1), a+4); +X} +X +Xint +Xgetlongtuplearg(args, a, n) +X object *args; +X long *a; /* [n] */ +X int n; +X{ +X int i; +X if (!is_tupleobject(args) || gettuplesize(args) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X object *v = gettupleitem(args, i); +X if (!is_intobject(v)) { +X return err_badarg(); +X } +X a[i] = getintvalue(v); +X } +X return 1; +X} +X +Xint +Xgetshorttuplearg(args, a, n) +X object *args; +X short *a; /* [n] */ +X int n; +X{ +X int i; +X if (!is_tupleobject(args) || gettuplesize(args) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X object *v = gettupleitem(args, i); +X if (!is_intobject(v)) { +X return err_badarg(); +X } +X a[i] = getintvalue(v); +X } +X return 1; +X} +X +Xint +Xgetlonglistarg(args, a, n) +X object *args; +X long *a; /* [n] */ +X int n; +X{ +X int i; +X if (!is_listobject(args) || getlistsize(args) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X object *v = getlistitem(args, i); +X if (!is_intobject(v)) { +X return err_badarg(); +X } +X a[i] = getintvalue(v); +X } +X return 1; +X} +X +Xint +Xgetshortlistarg(args, a, n) +X object *args; +X short *a; /* [n] */ +X int n; +X{ +X int i; +X if (!is_listobject(args) || getlistsize(args) != n) { +X return err_badarg(); +X } +X for (i = 0; i < n; i++) { +X object *v = getlistitem(args, i); +X if (!is_intobject(v)) { +X return err_badarg(); +X } +X a[i] = getintvalue(v); +X } +X return 1; +X} +EOF +fi +if test -s 'src/pythonmain.c' +then echo '*** I will not over-write existing file src/pythonmain.c' +else +echo 'x - src/pythonmain.c' +sed 's/^X//' > 'src/pythonmain.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/* Python interpreter main program */ +X +X#include "patchlevel.h" +X +X#include "allobjects.h" +X +X#include "grammar.h" +X#include "node.h" +X#include "parsetok.h" +X#include "graminit.h" +X#include "errcode.h" +X#include "sysmodule.h" +X#include "compile.h" +X#include "ceval.h" +X#include "pythonrun.h" +X#include "import.h" +X +Xextern char *getpythonpath(); +X +Xextern grammar gram; /* From graminit.c */ +X +X#ifdef DEBUG +Xint debugging; /* Needed by parser.c */ +X#endif +X +Xmain(argc, argv) +X int argc; +X char **argv; +X{ +X char *filename = NULL; +X FILE *fp = stdin; +X +X initargs(&argc, &argv); +X +X if (argc > 1 && strcmp(argv[1], "-") != 0) +X filename = argv[1]; +X +X if (filename != NULL) { +X if ((fp = fopen(filename, "r")) == NULL) { +X fprintf(stderr, "python: can't open file '%s'\n", +X filename); +X exit(2); +X } +X } +X +X initall(); +X +X setpythonpath(getpythonpath()); +X setpythonargv(argc-1, argv+1); +X +X goaway(run(fp, filename == NULL ? "<stdin>" : filename)); +X /*NOTREACHED*/ +X} +X +X/* Initialize all */ +X +Xvoid +Xinitall() +X{ +X static int inited; +X +X if (inited) +X return; +X inited = 1; +X +X initimport(); +X +X /* Modules 'builtin' and 'sys' are initialized here, +X they are needed by random bits of the interpreter. +X All other modules are optional and should be initialized +X by the initcalls() of a specific configuration. */ +X +X initbuiltin(); /* Also initializes builtin exceptions */ +X initsys(); +X +X initcalls(); /* Configuration-dependent initializations */ +X +X initintr(); /* For intrcheck() */ +X} +X +X/* Parse input from a file and execute it */ +X +Xint +Xrun(fp, filename) +X FILE *fp; +X char *filename; +X{ +X if (filename == NULL) +X filename = "???"; +X if (isatty(fileno(fp))) +X return run_tty_loop(fp, filename); +X else +X return run_script(fp, filename); +X} +X +Xint +Xrun_tty_loop(fp, filename) +X FILE *fp; +X char *filename; +X{ +X object *v; +X int ret; +X v = sysget("ps1"); +X if (v == NULL) { +X sysset("ps1", v = newstringobject(">>> ")); +X XDECREF(v); +X } +X v = sysget("ps2"); +X if (v == NULL) { +X sysset("ps2", v = newstringobject("... ")); +X XDECREF(v); +X } +X for (;;) { +X ret = run_tty_1(fp, filename); +X#ifdef REF_DEBUG +X fprintf(stderr, "[%ld refs]\n", ref_total); +X#endif +X if (ret == E_EOF) +X return 0; +X /* +X if (ret == E_NOMEM) +X return -1; +X */ +X } +X} +X +Xint +Xrun_tty_1(fp, filename) +X FILE *fp; +X char *filename; +X{ +X object *m, *d, *v, *w; +X node *n; +X char *ps1, *ps2; +X int err; +X v = sysget("ps1"); +X w = sysget("ps2"); +X if (v != NULL && is_stringobject(v)) { +X INCREF(v); +X ps1 = getstringvalue(v); +X } +X else { +X v = NULL; +X ps1 = ""; +X } +X if (w != NULL && is_stringobject(w)) { +X INCREF(w); +X ps2 = getstringvalue(w); +X } +X else { +X w = NULL; +X ps2 = ""; +X } +X err = parsefile(fp, filename, &gram, single_input, ps1, ps2, &n); +X XDECREF(v); +X XDECREF(w); +X if (err == E_EOF) +X return E_EOF; +X if (err != E_DONE) { +X err_input(err); +X print_error(); +X return err; +X } +X m = add_module("__main__"); +X if (m == NULL) +X return -1; +X d = getmoduledict(m); +X v = run_node(n, filename, d, d); +X flushline(); +X if (v == NULL) { +X print_error(); +X return -1; +X } +X DECREF(v); +X return 0; +X} +X +Xint +Xrun_script(fp, filename) +X FILE *fp; +X char *filename; +X{ +X object *m, *d, *v; +X m = add_module("__main__"); +X if (m == NULL) +X return -1; +X d = getmoduledict(m); +X v = run_file(fp, filename, file_input, d, d); +X flushline(); +X if (v == NULL) { +X print_error(); +X return -1; +X } +X DECREF(v); +X return 0; +X} +X +Xvoid +Xprint_error() +X{ +X object *exception, *v; +X err_get(&exception, &v); +X fprintf(stderr, "Unhandled exception: "); +X printobject(exception, stderr, PRINT_RAW); +X if (v != NULL && v != None) { +X fprintf(stderr, ": "); +X printobject(v, stderr, PRINT_RAW); +X } +X fprintf(stderr, "\n"); +X XDECREF(exception); +X XDECREF(v); +X printtraceback(stderr); +X} +X +Xobject * +Xrun_string(str, start, globals, locals) +X char *str; +X int start; +X /*dict*/object *globals, *locals; +X{ +X node *n; +X int err; +X err = parse_string(str, start, &n); +X return run_err_node(err, n, "<string>", globals, locals); +X} +X +Xobject * +Xrun_file(fp, filename, start, globals, locals) +X FILE *fp; +X char *filename; +X int start; +X /*dict*/object *globals, *locals; +X{ +X node *n; +X int err; +X err = parse_file(fp, filename, start, &n); +X return run_err_node(err, n, filename, globals, locals); +X} +X +Xobject * +Xrun_err_node(err, n, filename, globals, locals) +X int err; +X node *n; +X char *filename; +X /*dict*/object *globals, *locals; +X{ +X if (err != E_DONE) { +X err_input(err); +X return NULL; +X } +X return run_node(n, filename, globals, locals); +X} +X +Xobject * +Xrun_node(n, filename, globals, locals) +X node *n; +X char *filename; +X /*dict*/object *globals, *locals; +X{ +X if (globals == NULL) { +X globals = getglobals(); +X if (locals == NULL) +X locals = getlocals(); +X } +X else { +X if (locals == NULL) +X locals = globals; +X } +X return eval_node(n, filename, globals, locals); +X} +X +Xobject * +Xeval_node(n, filename, globals, locals) +X node *n; +X char *filename; +X object *globals; +X object *locals; +X{ +X codeobject *co; +X object *v; +X co = compile(n, filename); +X freetree(n); +X if (co == NULL) +X return NULL; +X v = eval_code(co, globals, locals, (object *)NULL); +X DECREF(co); +X return v; +X} +X +X/* Simplified interface to parsefile */ +X +Xint +Xparse_file(fp, filename, start, n_ret) +X FILE *fp; +X char *filename; +X int start; +X node **n_ret; +X{ +X return parsefile(fp, filename, &gram, start, +X (char *)0, (char *)0, n_ret); +X} +X +X/* Simplified interface to parsestring */ +X +Xint +Xparse_string(str, start, n_ret) +X char *str; +X int start; +X node **n_ret; +X{ +X int err = parsestring(str, &gram, start, n_ret); +X /* Don't confuse early end of string with early end of input */ +X if (err == E_EOF) +X err = E_SYNTAX; +X return err; +X} +X +X/* Print fatal error message and abort */ +X +Xvoid +Xfatal(msg) +X char *msg; +X{ +X fprintf(stderr, "Fatal error: %s\n", msg); +X abort(); +X} +X +X/* Clean up and exit */ +X +Xvoid +Xgoaway(sts) +X int sts; +X{ +X flushline(); +X +X /* XXX Call doneimport() before donecalls(), since donecalls() +X calls wdone(), and doneimport() may close windows */ +X doneimport(); +X donecalls(); +X +X err_clear(); +X +X#ifdef REF_DEBUG +X fprintf(stderr, "[%ld refs]\n", ref_total); +X#endif +X +X#ifdef THINK_C_3_0 +X if (sts == 0) +X Click_On(0); +X#endif +X +X#ifdef TRACE_REFS +X if (askyesno("Print left references?")) { +X#ifdef THINK_C_3_0 +X Click_On(1); +X#endif +X printrefs(stderr); +X } +X#endif /* TRACE_REFS */ +X +X exit(sts); +X /*NOTREACHED*/ +X} +X +Xstatic +Xfinaloutput() +X{ +X#ifdef TRACE_REFS +X if (!askyesno("Print left references?")) +X return; +X#ifdef THINK_C_3_0 +X Click_On(1); +X#endif +X printrefs(stderr); +X#endif /* TRACE_REFS */ +X} +X +X/* Ask a yes/no question */ +X +Xstatic int +Xaskyesno(prompt) +X char *prompt; +X{ +X char buf[256]; +X +X printf("%s [ny] ", prompt); +X if (fgets(buf, sizeof buf, stdin) == NULL) +X return 0; +X return buf[0] == 'y' || buf[0] == 'Y'; +X} +X +X#ifdef THINK_C_3_0 +X +X/* Check for file descriptor connected to interactive device. +X Pretend that stdin is always interactive, other files never. */ +X +Xint +Xisatty(fd) +X int fd; +X{ +X return fd == fileno(stdin); +X} +X +X#endif +X +X/* XXX WISH LIST +X +X - possible new types: +X - iterator (for range, keys, ...) +X - improve interpreter error handling, e.g., true tracebacks +X - save precompiled modules on file? +X - fork threads, locking +X - allow syntax extensions +X*/ +X +X/* "Floccinaucinihilipilification" */ +EOF +fi +if test -s 'src/stringobject.c' +then echo '*** I will not over-write existing file src/stringobject.c' +else +echo 'x - src/stringobject.c' +sed 's/^X//' > 'src/stringobject.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/* String object implementation */ +X +X#include "allobjects.h" +X +Xobject * +Xnewsizedstringobject(str, size) +X char *str; +X int size; +X{ +X register stringobject *op = (stringobject *) +X malloc(sizeof(stringobject) + size * sizeof(char)); +X if (op == NULL) +X return err_nomem(); +X NEWREF(op); +X op->ob_type = &Stringtype; +X op->ob_size = size; +X if (str != NULL) +X memcpy(op->ob_sval, str, size); +X op->ob_sval[size] = '\0'; +X return (object *) op; +X} +X +Xobject * +Xnewstringobject(str) +X char *str; +X{ +X register unsigned int size = strlen(str); +X register stringobject *op = (stringobject *) +X malloc(sizeof(stringobject) + size * sizeof(char)); +X if (op == NULL) +X return err_nomem(); +X NEWREF(op); +X op->ob_type = &Stringtype; +X op->ob_size = size; +X strcpy(op->ob_sval, str); +X return (object *) op; +X} +X +Xunsigned int +Xgetstringsize(op) +X register object *op; +X{ +X if (!is_stringobject(op)) { +X err_badcall(); +X return -1; +X } +X return ((stringobject *)op) -> ob_size; +X} +X +X/*const*/ char * +Xgetstringvalue(op) +X register object *op; +X{ +X if (!is_stringobject(op)) { +X err_badcall(); +X return NULL; +X } +X return ((stringobject *)op) -> ob_sval; +X} +X +X/* Methods */ +X +Xstatic void +Xstringprint(op, fp, flags) +X stringobject *op; +X FILE *fp; +X int flags; +X{ +X int i; +X char c; +X if (flags & PRINT_RAW) { +X fwrite(op->ob_sval, 1, (int) op->ob_size, fp); +X return; +X } +X fprintf(fp, "'"); +X for (i = 0; i < op->ob_size; i++) { +X c = op->ob_sval[i]; +X if (c == '\'' || c == '\\') +X fprintf(fp, "\\%c", c); +X else if (c < ' ' || c >= 0177) +X fprintf(fp, "\\%03o", c&0377); +X else +X putc(c, fp); +X } +X fprintf(fp, "'"); +X} +X +Xstatic object * +Xstringrepr(op) +X register stringobject *op; +X{ +X /* XXX overflow? */ +X int newsize = 2 + 4 * op->ob_size * sizeof(char); +X object *v = newsizedstringobject((char *)NULL, newsize); +X if (v == NULL) { +X return err_nomem(); +X } +X else { +X register int i; +X register char c; +X register char *p; +X NEWREF(v); +X v->ob_type = &Stringtype; +X ((stringobject *)v)->ob_size = newsize; +X p = ((stringobject *)v)->ob_sval; +X *p++ = '\''; +X for (i = 0; i < op->ob_size; i++) { +X c = op->ob_sval[i]; +X if (c == '\'' || c == '\\') +X *p++ = '\\', *p++ = c; +X else if (c < ' ' || c >= 0177) { +X sprintf(p, "\\%03o", c&0377); +X while (*p != '\0') +X p++; +X +X } +X else +X *p++ = c; +X } +X *p++ = '\''; +X *p = '\0'; +X resizestring(&v, (int) (p - ((stringobject *)v)->ob_sval)); +X return v; +X } +X} +X +Xstatic int +Xstringlength(a) +X stringobject *a; +X{ +X return a->ob_size; +X} +X +Xstatic object * +Xstringconcat(a, bb) +X register stringobject *a; +X register object *bb; +X{ +X register unsigned int size; +X register stringobject *op; +X if (!is_stringobject(bb)) { +X err_badarg(); +X return NULL; +X } +X#define b ((stringobject *)bb) +X /* Optimize cases with empty left or right operand */ +X if (a->ob_size == 0) { +X INCREF(bb); +X return bb; +X } +X if (b->ob_size == 0) { +X INCREF(a); +X return (object *)a; +X } +X size = a->ob_size + b->ob_size; +X op = (stringobject *) +X malloc(sizeof(stringobject) + size * sizeof(char)); +X if (op == NULL) +X return err_nomem(); +X NEWREF(op); +X op->ob_type = &Stringtype; +X op->ob_size = size; +X memcpy(op->ob_sval, a->ob_sval, (int) a->ob_size); +X memcpy(op->ob_sval + a->ob_size, b->ob_sval, (int) b->ob_size); +X op->ob_sval[size] = '\0'; +X return (object *) op; +X#undef b +X} +X +Xstatic object * +Xstringrepeat(a, n) +X register stringobject *a; +X register int n; +X{ +X register int i; +X register unsigned int size; +X register stringobject *op; +X if (n < 0) +X n = 0; +X size = a->ob_size * n; +X if (size == a->ob_size) { +X INCREF(a); +X return (object *)a; +X } +X op = (stringobject *) +X malloc(sizeof(stringobject) + size * sizeof(char)); +X if (op == NULL) +X return err_nomem(); +X NEWREF(op); +X op->ob_type = &Stringtype; +X op->ob_size = size; +X for (i = 0; i < size; i += a->ob_size) +X memcpy(op->ob_sval+i, a->ob_sval, (int) a->ob_size); +X op->ob_sval[size] = '\0'; +X return (object *) op; +X} +X +X/* String slice a[i:j] consists of characters a[i] ... a[j-1] */ +X +Xstatic object * +Xstringslice(a, i, j) +X register stringobject *a; +X register int i, j; /* May be negative! */ +X{ +X if (i < 0) +X i = 0; +X if (j < 0) +X j = 0; /* Avoid signed/unsigned bug in next line */ +X if (j > a->ob_size) +X j = a->ob_size; +X if (i == 0 && j == a->ob_size) { /* It's the same as a */ +X INCREF(a); +X return (object *)a; +X } +X if (j < i) +X j = i; +X return newsizedstringobject(a->ob_sval + i, (int) (j-i)); +X} +X +Xstatic object * +Xstringitem(a, i) +X stringobject *a; +X register int i; +X{ +X if (i < 0 || i >= a->ob_size) { +X err_setstr(IndexError, "string index out of range"); +X return NULL; +X } +X return stringslice(a, i, i+1); +X} +X +Xstatic int +Xstringcompare(a, b) +X stringobject *a, *b; +X{ +X int len_a = a->ob_size, len_b = b->ob_size; +X int min_len = (len_a < len_b) ? len_a : len_b; +X int cmp = memcmp(a->ob_sval, b->ob_sval, min_len); +X if (cmp != 0) +X return cmp; +X return (len_a < len_b) ? -1 : (len_a > len_b) ? 1 : 0; +X} +X +Xstatic sequence_methods string_as_sequence = { +X stringlength, /*tp_length*/ +X stringconcat, /*tp_concat*/ +X stringrepeat, /*tp_repeat*/ +X stringitem, /*tp_item*/ +X stringslice, /*tp_slice*/ +X 0, /*tp_ass_item*/ +X 0, /*tp_ass_slice*/ +X}; +X +Xtypeobject Stringtype = { +X OB_HEAD_INIT(&Typetype) +X 0, +X "string", +X sizeof(stringobject), +X sizeof(char), +X free, /*tp_dealloc*/ +X stringprint, /*tp_print*/ +X 0, /*tp_getattr*/ +X 0, /*tp_setattr*/ +X stringcompare, /*tp_compare*/ +X stringrepr, /*tp_repr*/ +X 0, /*tp_as_number*/ +X &string_as_sequence, /*tp_as_sequence*/ +X 0, /*tp_as_mapping*/ +X}; +X +Xvoid +Xjoinstring(pv, w) +X register object **pv; +X register object *w; +X{ +X register object *v; +X if (*pv == NULL || w == NULL || !is_stringobject(*pv)) +X return; +X v = stringconcat((stringobject *) *pv, w); +X DECREF(*pv); +X *pv = v; +X} +X +X/* The following function breaks the notion that strings are immutable: +X it changes the size of a string. We get away with this only if there +X is only one module referencing the object. You can also think of it +X as creating a new string object and destroying the old one, only +X more efficiently. In any case, don't use this if the string may +X already be known to some other part of the code... */ +X +Xint +Xresizestring(pv, newsize) +X object **pv; +X int newsize; +X{ +X register object *v; +X register stringobject *sv; +X v = *pv; +X if (!is_stringobject(v) || v->ob_refcnt != 1) { +X *pv = 0; +X DECREF(v); +X err_badcall(); +X return -1; +X } +X /* XXX UNREF/NEWREF interface should be more symmetrical */ +X#ifdef REF_DEBUG +X --ref_total; +X#endif +X UNREF(v); +X *pv = (object *) +X realloc((char *)v, +X sizeof(stringobject) + newsize * sizeof(char)); +X if (*pv == NULL) { +X DEL(v); +X err_nomem(); +X return -1; +X } +X NEWREF(*pv); +X sv = (stringobject *) *pv; +X sv->ob_size = newsize; +X sv->ob_sval[newsize] = '\0'; +X return 0; +X} +EOF +fi +echo 'Part 12 out of 21 of pack.out complete.' +exit 0 |