Lib/plat-mac/cfmfile.py

   1 """codefragments.py -- wrapper to modify code fragments."""
   2
   3 # (c) 1998, Just van Rossum, Letterror
   4
   5 __version__ = "0.8b3"
   6 __author__ = "jvr"
   7
   8 import warnings
   9 warnings.warnpy3k("the cfmfile module is deprecated and is removed in 3,0",
  10               stacklevel=2)
  11
  12 import Carbon.File
  13 import struct
  14 from Carbon import Res
  15 import os
  16 import sys
  17
  18 DEBUG = 0
  19
  20 error = "cfm.error"
  21
  22 BUFSIZE = 0x80000
  23
  24 def mergecfmfiles(srclist, dst, architecture = 'fat'):
  25     """Merge all files in srclist into a new file dst.
  26
  27     If architecture is given, only code fragments of that type will be used:
  28     "pwpc" for PPC, "m68k" for cfm68k. This does not work for "classic"
  29     68k code, since it does not use code fragments to begin with.
  30     If architecture is None, all fragments will be used, enabling FAT binaries.
  31     """
  32
  33     srclist = list(srclist)
  34     for i in range(len(srclist)):
  35         srclist[i] = Carbon.File.pathname(srclist[i])
  36     dst = Carbon.File.pathname(dst)
  37
  38     dstfile = open(dst, "wb")
  39     rf = Res.FSpOpenResFile(dst, 3)
  40     try:
  41         dstcfrg = CfrgResource()
  42         for src in srclist:
  43             srccfrg = CfrgResource(src)
  44             for frag in srccfrg.fragments:
  45                 if frag.architecture == 'pwpc' and architecture == 'm68k':
  46                     continue
  47                 if frag.architecture == 'm68k' and architecture == 'pwpc':
  48                     continue
  49                 dstcfrg.append(frag)
  50
  51                 frag.copydata(dstfile)
  52
  53         cfrgres = Res.Resource(dstcfrg.build())
  54         Res.UseResFile(rf)
  55         cfrgres.AddResource('cfrg', 0, "")
  56     finally:
  57         dstfile.close()
  58         rf = Res.CloseResFile(rf)
  59
  60
  61 class CfrgResource:
  62
  63     def __init__(self, path = None):
  64         self.version = 1
  65         self.fragments = []
  66         self.path = path
  67         if path is not None and os.path.exists(path):
  68             currentresref = Res.CurResFile()
  69             resref = Res.FSpOpenResFile(path, 1)
  70             Res.UseResFile(resref)
  71             try:
  72                 try:
  73                     data = Res.Get1Resource('cfrg', 0).data
  74                 except Res.Error:
  75                     raise Res.Error, "no 'cfrg' resource found", sys.exc_traceback
  76             finally:
  77                 Res.CloseResFile(resref)
  78                 Res.UseResFile(currentresref)
  79             self.parse(data)
  80             if self.version <> 1:
  81                 raise error, "unknown 'cfrg' resource format"
  82
  83     def parse(self, data):
  84         (res1, res2, self.version,
  85             res3, res4, res5, res6,
  86             self.memberCount) = struct.unpack("8l", data[:32])
  87         data = data[32:]
  88         while data:
  89             frag = FragmentDescriptor(self.path, data)
  90             data = data[frag.memberSize:]
  91             self.fragments.append(frag)
  92
  93     def build(self):
  94         self.memberCount = len(self.fragments)
  95         data = struct.pack("8l", 0, 0, self.version, 0, 0, 0, 0, self.memberCount)
  96         for frag in self.fragments:
  97             data = data + frag.build()
  98         return data
  99
 100     def append(self, frag):
 101         self.fragments.append(frag)
 102
 103
 104 class FragmentDescriptor:
 105
 106     def __init__(self, path, data = None):
 107         self.path = path
 108         if data is not None:
 109             self.parse(data)
 110
 111     def parse(self, data):
 112         self.architecture = data[:4]
 113         (   self.updatelevel,
 114             self.currentVersion,
 115             self.oldDefVersion,
 116             self.stacksize,
 117             self.applibdir,
 118             self.fragtype,
 119             self.where,
 120             self.offset,
 121             self.length,
 122             self.res1, self.res2,
 123             self.memberSize,) = struct.unpack("4lhBB4lh", data[4:42])
 124         pname = data[42:self.memberSize]
 125         self.name = pname[1:1+ord(pname[0])]
 126
 127     def build(self):
 128         data = self.architecture
 129         data = data + struct.pack("4lhBB4l",
 130                 self.updatelevel,
 131                 self.currentVersion,
 132                 self.oldDefVersion,
 133                 self.stacksize,
 134                 self.applibdir,
 135                 self.fragtype,
 136                 self.where,
 137                 self.offset,
 138                 self.length,
 139                 self.res1, self.res2)
 140         self.memberSize = len(data) + 2 + 1 + len(self.name)
 141         # pad to 4 byte boundaries
 142         if self.memberSize % 4:
 143             self.memberSize = self.memberSize + 4 - (self.memberSize % 4)
 144         data = data + struct.pack("hb", self.memberSize, len(self.name))
 145         data = data + self.name
 146         data = data + '\000' * (self.memberSize - len(data))
 147         return data
 148
 149     def getfragment(self):
 150         if self.where <> 1:
 151             raise error, "can't read fragment, unsupported location"
 152         f = open(self.path, "rb")
 153         f.seek(self.offset)
 154         if self.length:
 155             frag = f.read(self.length)
 156         else:
 157             frag = f.read()
 158         f.close()
 159         return frag
 160
 161     def copydata(self, outfile):
 162         if self.where <> 1:
 163             raise error, "can't read fragment, unsupported location"
 164         infile = open(self.path, "rb")
 165         if self.length == 0:
 166             infile.seek(0, 2)
 167             self.length = infile.tell()
 168
 169         # Position input file and record new offset from output file
 170         infile.seek(self.offset)
 171
 172         # pad to 16 byte boundaries
 173         offset = outfile.tell()
 174         if offset % 16:
 175             offset = offset + 16 - (offset % 16)
 176         outfile.seek(offset)
 177         self.offset = offset
 178
 179         l = self.length
 180         while l:
 181             if l > BUFSIZE:
 182                 outfile.write(infile.read(BUFSIZE))
 183                 l = l - BUFSIZE
 184             else:
 185                 outfile.write(infile.read(l))
 186                 l = 0
 187         infile.close()