Mac/Modules/file/filesupport.py

   1 # This script generates a Python interface for an Apple Macintosh Manager.
   2 # It uses the "bgen" package to generate C code.
   3 # The function specifications are generated by scanning the mamager's header file,
   4 # using the "scantools" package (customized for this particular manager).
   5 #
   6 # XXXX TO DO:
   7 # - Implement correct missing FSSpec handling for Alias methods
   8 # - Implement FInfo
   9 #
  10 # WARNING WARNING WARNING
  11 #   The file _Filemodule.c was modified manually, don't run this script
  12 #   unless you really know what you're doing.
  13
  14 import sys
  15 sys.exit(42)
  16
  17 import string
  18
  19 # Declarations that change for each manager
  20 #MACHEADERFILE = 'Files.h'              # The Apple header file
  21 MODNAME = '_File'                               # The name of the module
  22 LONGMODNAME = 'Carbon.File'             # The "normal" external name of the module
  23
  24 # The following is *usually* unchanged but may still require tuning
  25 MODPREFIX = 'File'                      # The prefix for module-wide routines
  26 INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
  27 OUTPUTFILE = MODNAME + "module.c"       # The file generated by this program
  28
  29 from macsupport import *
  30
  31 # Various integers:
  32 SInt64 = Type("SInt64", "L")
  33 UInt64 = Type("UInt64", "L")
  34 FNMessage = Type("FNMessage", "l")
  35 FSAllocationFlags = Type("FSAllocationFlags", "H")
  36 FSCatalogInfoBitmap = Type("FSCatalogInfoBitmap", "l")
  37 FSIteratorFlags = Type("FSIteratorFlags", "l")
  38 FSVolumeRefNum = Type("FSVolumeRefNum", "h")
  39 AliasInfoType = Type("AliasInfoType", "h")
  40
  41 # Various types of strings:
  42 #class UniCharCountBuffer(InputOnlyType):
  43 #       pass
  44 class VarReverseInputBufferType(ReverseInputBufferMixin, VarInputBufferType):
  45     pass
  46 FullPathName = VarReverseInputBufferType()
  47 ConstStr31Param = OpaqueArrayType("Str31", "PyMac_BuildStr255", "PyMac_GetStr255")
  48 ConstStr32Param = OpaqueArrayType("Str32", "PyMac_BuildStr255", "PyMac_GetStr255")
  49 ConstStr63Param = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255")
  50 Str63 = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255")
  51
  52 HFSUniStr255 = OpaqueType("HFSUniStr255", "PyMac_BuildHFSUniStr255", "PyMac_GetHFSUniStr255")
  53 UInt8_ptr = InputOnlyType("UInt8 *", "s")
  54
  55 # Other types:
  56 class OptionalFSxxxType(OpaqueByValueType):
  57     def declare(self, name):
  58         Output("%s %s__buf__;", self.typeName, name)
  59         Output("%s *%s = &%s__buf__;", self.typeName, name, name)
  60
  61 class FSCatalogInfoAndBitmapType(InputOnlyType):
  62
  63     def __init__(self):
  64         InputOnlyType.__init__(self, "BUG", "BUG")
  65
  66     def declare(self, name):
  67         Output("PyObject *%s__object = NULL;", name)
  68         Output("FSCatalogInfoBitmap %s__bitmap = 0;", name)
  69         Output("FSCatalogInfo %s;", name)
  70
  71     def getargsFormat(self):
  72         return "lO"
  73
  74     def getargsArgs(self, name):
  75         return "%s__bitmap, %s__object"%(name, name)
  76
  77     def getargsCheck(self, name):
  78         Output("if (!convert_FSCatalogInfo(%s__object, %s__bitmap, &%s)) return NULL;", name, name, name)
  79
  80     def passInput(self, name):
  81         return "%s__bitmap, &%s"% (name, name)
  82
  83     def passOutput(self, name):
  84         return "%s__bitmap, &%s"% (name, name)
  85
  86     def mkvalueFormat(self):
  87         return "O"
  88
  89     def mkvalueArgs(self, name):
  90         return "%s__object" % (name)
  91
  92     def xxxxmkvalueCheck(self, name):
  93         Output("if ((%s__object = new_FSCatalogInfo(%s__bitmap, &%s)) == NULL) return NULL;", name, name)
  94
  95 class FSCatalogInfoAndBitmap_inType(FSCatalogInfoAndBitmapType, InputOnlyMixIn):
  96
  97     def xxxxmkvalueCheck(self, name):
  98         pass
  99
 100 class FSCatalogInfoAndBitmap_outType(FSCatalogInfoAndBitmapType):
 101
 102     def getargsFormat(self):
 103         return "l"
 104
 105     def getargsArgs(self, name):
 106         return "%s__bitmap" % name
 107
 108     def getargsCheck(self, name):
 109         pass
 110
 111 FInfo = OpaqueType("FInfo", "FInfo")
 112 FInfo_ptr = OpaqueType("FInfo", "FInfo")
 113 AliasHandle = OpaqueByValueType("AliasHandle", "Alias")
 114 FSSpec = OpaqueType("FSSpec", "FSSpec")
 115 FSSpec_ptr = OpaqueType("FSSpec", "FSSpec")
 116 OptFSSpecPtr = OptionalFSxxxType("FSSpec", "BUG", "myPyMac_GetOptFSSpecPtr")
 117 FSRef = OpaqueType("FSRef", "FSRef")
 118 FSRef_ptr = OpaqueType("FSRef", "FSRef")
 119 OptFSRefPtr = OptionalFSxxxType("FSRef", "BUG", "myPyMac_GetOptFSRefPtr")
 120 FSCatalogInfo = OpaqueType("FSCatalogInfo", "FSCatalogInfo")
 121 FSCatalogInfo_ptr = OpaqueType("FSCatalogInfo", "FSCatalogInfo")
 122
 123 # To be done:
 124 #CatPositionRec
 125 #FSCatalogInfo
 126 #FSForkInfo
 127 #FSIterator
 128 #FSVolumeInfo
 129 #FSSpecArrayPtr
 130
 131 includestuff = includestuff + """
 132 #include <Carbon/Carbon.h>
 133
 134 #ifdef USE_TOOLBOX_OBJECT_GLUE
 135 extern int _PyMac_GetFSSpec(PyObject *v, FSSpec *spec);
 136 extern int _PyMac_GetFSRef(PyObject *v, FSRef *fsr);
 137 extern PyObject *_PyMac_BuildFSSpec(FSSpec *spec);
 138 extern PyObject *_PyMac_BuildFSRef(FSRef *spec);
 139
 140 #define PyMac_GetFSSpec _PyMac_GetFSSpec
 141 #define PyMac_GetFSRef _PyMac_GetFSRef
 142 #define PyMac_BuildFSSpec _PyMac_BuildFSSpec
 143 #define PyMac_BuildFSRef _PyMac_BuildFSRef
 144 #else
 145 extern int PyMac_GetFSSpec(PyObject *v, FSSpec *spec);
 146 extern int PyMac_GetFSRef(PyObject *v, FSRef *fsr);
 147 extern PyObject *PyMac_BuildFSSpec(FSSpec *spec);
 148 extern PyObject *PyMac_BuildFSRef(FSRef *spec);
 149 #endif
 150
 151 /* Forward declarations */
 152 static PyObject *FInfo_New(FInfo *itself);
 153 static PyObject *FSRef_New(FSRef *itself);
 154 static PyObject *FSSpec_New(FSSpec *itself);
 155 static PyObject *Alias_New(AliasHandle itself);
 156 static int FInfo_Convert(PyObject *v, FInfo *p_itself);
 157 #define FSRef_Convert PyMac_GetFSRef
 158 #define FSSpec_Convert PyMac_GetFSSpec
 159 static int Alias_Convert(PyObject *v, AliasHandle *p_itself);
 160
 161 /*
 162 ** UTCDateTime records
 163 */
 164 static int
 165 UTCDateTime_Convert(PyObject *v, UTCDateTime *ptr)
 166 {
 167         return PyArg_Parse(v, "(HlH)", &ptr->highSeconds, &ptr->lowSeconds, &ptr->fraction);
 168 }
 169
 170 static PyObject *
 171 UTCDateTime_New(UTCDateTime *ptr)
 172 {
 173         return Py_BuildValue("(HlH)", ptr->highSeconds, ptr->lowSeconds, ptr->fraction);
 174 }
 175
 176 /*
 177 ** Optional fsspec and fsref pointers. None will pass NULL
 178 */
 179 static int
 180 myPyMac_GetOptFSSpecPtr(PyObject *v, FSSpec **spec)
 181 {
 182         if (v == Py_None) {
 183                 *spec = NULL;
 184                 return 1;
 185         }
 186         return PyMac_GetFSSpec(v, *spec);
 187 }
 188
 189 static int
 190 myPyMac_GetOptFSRefPtr(PyObject *v, FSRef **ref)
 191 {
 192         if (v == Py_None) {
 193                 *ref = NULL;
 194                 return 1;
 195         }
 196         return PyMac_GetFSRef(v, *ref);
 197 }
 198
 199 /*
 200 ** Parse/generate objsect
 201 */
 202 static PyObject *
 203 PyMac_BuildHFSUniStr255(HFSUniStr255 *itself)
 204 {
 205
 206         return Py_BuildValue("u#", itself->unicode, itself->length);
 207 }
 208
 209 #ifndef __LP64__
 210 /*
 211 ** Get pathname for a given FSSpec
 212 */
 213 static OSErr
 214 _PyMac_GetFullPathname(FSSpec *fss, char *path, int len)
 215 {
 216         FSRef fsr;
 217         OSErr err;
 218
 219         *path = '\0';
 220         err = FSpMakeFSRef(fss, &fsr);
 221         if (err == fnfErr) {
 222                 /* FSSpecs can point to non-existing files, fsrefs can't. */
 223                 FSSpec fss2;
 224                 int tocopy;
 225
 226                 err = FSMakeFSSpec(fss->vRefNum, fss->parID, "", &fss2);
 227                 if (err)
 228                         return err;
 229                 err = FSpMakeFSRef(&fss2, &fsr);
 230                 if (err)
 231                         return err;
 232                 err = (OSErr)FSRefMakePath(&fsr, path, len-1);
 233                 if (err)
 234                         return err;
 235                 /* This part is not 100% safe: we append the filename part, but
 236                 ** I'm not sure that we don't run afoul of the various 8bit
 237                 ** encodings here. Will have to look this up at some point...
 238                 */
 239                 strcat(path, "/");
 240                 tocopy = fss->name[0];
 241                 if ((strlen(path) + tocopy) >= len)
 242                         tocopy = len - strlen(path) - 1;
 243                 if (tocopy > 0)
 244                         strncat(path, fss->name+1, tocopy);
 245         }
 246         else {
 247                 if (err)
 248                         return err;
 249                 err = (OSErr)FSRefMakePath(&fsr, path, len);
 250                 if (err)
 251                         return err;
 252         }
 253         return 0;
 254 }
 255 #endif /* !__LP64__ */
 256
 257 """
 258
 259 finalstuff = finalstuff + """
 260
 261 #ifndef __LP64__
 262 int
 263 PyMac_GetFSSpec(PyObject *v, FSSpec *spec)
 264 {
 265         Str255 path;
 266         short refnum;
 267         long parid;
 268         OSErr err;
 269         FSRef fsr;
 270
 271         if (FSSpec_Check(v)) {
 272                 *spec = ((FSSpecObject *)v)->ob_itself;
 273                 return 1;
 274         }
 275
 276         if (PyArg_Parse(v, "(hlO&)",
 277                                                 &refnum, &parid, PyMac_GetStr255, &path)) {
 278                 err = FSMakeFSSpec(refnum, parid, path, spec);
 279                 if ( err && err != fnfErr ) {
 280                         PyMac_Error(err);
 281                         return 0;
 282                 }
 283                 return 1;
 284         }
 285         PyErr_Clear();
 286         /* Otherwise we try to go via an FSRef. On OSX we go all the way,
 287         ** on OS9 we accept only a real FSRef object
 288         */
 289         if ( PyMac_GetFSRef(v, &fsr) ) {
 290                 err = FSGetCatalogInfo(&fsr, kFSCatInfoNone, NULL, NULL, spec, NULL);
 291                 if (err != noErr) {
 292                         PyMac_Error(err);
 293                         return 0;
 294                 }
 295                 return 1;
 296         }
 297         return 0;
 298 }
 299
 300 #endif /* !__LP64__ */
 301
 302 int
 303 PyMac_GetFSRef(PyObject *v, FSRef *fsr)
 304 {
 305         OSStatus err;
 306         FSSpec fss;
 307
 308         if (FSRef_Check(v)) {
 309                 *fsr = ((FSRefObject *)v)->ob_itself;
 310                 return 1;
 311         }
 312
 313         /* On OSX we now try a pathname */
 314         if ( PyString_Check(v) || PyUnicode_Check(v)) {
 315                 char *path = NULL;
 316                 if (!PyArg_Parse(v, "et", Py_FileSystemDefaultEncoding, &path))
 317                         return 0;
 318                 if ( (err=FSPathMakeRef(path, fsr, NULL)) )
 319                         PyMac_Error(err);
 320                 PyMem_Free(path);
 321                 return !err;
 322         }
 323         /* XXXX Should try unicode here too */
 324         /* Otherwise we try to go via an FSSpec */
 325 #ifndef __LP64__
 326         if (FSSpec_Check(v)) {
 327                 fss = ((FSSpecObject *)v)->ob_itself;
 328                 if ((err=FSpMakeFSRef(&fss, fsr)) == 0)
 329                         return 1;
 330                 PyMac_Error(err);
 331                 return 0;
 332         }
 333         PyErr_SetString(PyExc_TypeError, "FSRef, FSSpec or pathname required");
 334 #else /* __LP64__ */
 335         PyErr_SetString(PyExc_TypeError, "FSRef or pathname required");
 336 #endif /* __LP64__ */
 337         return 0;
 338 }
 339
 340 #ifndef __LP64__
 341 extern PyObject *
 342 PyMac_BuildFSSpec(FSSpec *spec)
 343 {
 344         return FSSpec_New(spec);
 345 }
 346 #endif /* __LP64__ */
 347
 348 extern PyObject *
 349 PyMac_BuildFSRef(FSRef *spec)
 350 {
 351         return FSRef_New(spec);
 352 }
 353 """
 354
 355 initstuff = initstuff + """
 356 #ifndef __LP64__
 357 PyMac_INIT_TOOLBOX_OBJECT_NEW(FSSpec *, PyMac_BuildFSSpec);
 358 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSSpec, PyMac_GetFSSpec);
 359 #endif /* !__LP64__*/
 360 PyMac_INIT_TOOLBOX_OBJECT_NEW(FSRef *, PyMac_BuildFSRef);
 361 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSRef, PyMac_GetFSRef);
 362 """
 363
 364 execfile(string.lower(MODPREFIX) + 'typetest.py')
 365
 366 # Our object types:
 367 class FSCatalogInfoDefinition(PEP253Mixin, ObjectDefinition):
 368     getsetlist = [
 369             ("nodeFlags",
 370              "return Py_BuildValue(\"H\", self->ob_itself.nodeFlags);",
 371              "return PyArg_Parse(v, \"H\", &self->ob_itself.nodeFlags)-1;",
 372              None
 373             ),
 374             ("volume",
 375              "return Py_BuildValue(\"h\", self->ob_itself.volume);",
 376              "return PyArg_Parse(v, \"h\", &self->ob_itself.volume)-1;",
 377              None
 378             ),
 379             ("parentDirID",
 380              "return Py_BuildValue(\"l\", self->ob_itself.parentDirID);",
 381              "return PyArg_Parse(v, \"l\", &self->ob_itself.parentDirID)-1;",
 382              None
 383             ),
 384             ("nodeID",
 385              "return Py_BuildValue(\"l\", self->ob_itself.nodeID);",
 386              "return PyArg_Parse(v, \"l\", &self->ob_itself.nodeID)-1;",
 387              None
 388             ),
 389             ("createDate",
 390              "return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.createDate);",
 391              "return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.createDate)-1;",
 392              None
 393             ),
 394             ("contentModDate",
 395              "return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.contentModDate);",
 396              "return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.contentModDate)-1;",
 397              None
 398             ),
 399             ("attributeModDate",
 400              "return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.attributeModDate);",
 401              "return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.attributeModDate)-1;",
 402              None
 403             ),
 404             ("accessDate",
 405              "return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.accessDate);",
 406              "return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.accessDate)-1;",
 407              None
 408             ),
 409             ("backupDate",
 410              "return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.backupDate);",
 411              "return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.backupDate)-1;",
 412              None
 413             ),
 414             ("permissions",
 415              "return Py_BuildValue(\"(llll)\", self->ob_itself.permissions[0], self->ob_itself.permissions[1], self->ob_itself.permissions[2], self->ob_itself.permissions[3]);",
 416              "return PyArg_Parse(v, \"(llll)\", &self->ob_itself.permissions[0], &self->ob_itself.permissions[1], &self->ob_itself.permissions[2], &self->ob_itself.permissions[3])-1;",
 417              None
 418             ),
 419             # XXXX FinderInfo TBD
 420             # XXXX FinderXInfo TBD
 421             ("valence",
 422              "return Py_BuildValue(\"l\", self->ob_itself.valence);",
 423              "return PyArg_Parse(v, \"l\", &self->ob_itself.valence)-1;",
 424              None
 425             ),
 426             ("dataLogicalSize",
 427              "return Py_BuildValue(\"l\", self->ob_itself.dataLogicalSize);",
 428              "return PyArg_Parse(v, \"l\", &self->ob_itself.dataLogicalSize)-1;",
 429              None
 430             ),
 431             ("dataPhysicalSize",
 432              "return Py_BuildValue(\"l\", self->ob_itself.dataPhysicalSize);",
 433              "return PyArg_Parse(v, \"l\", &self->ob_itself.dataPhysicalSize)-1;",
 434              None
 435             ),
 436             ("rsrcLogicalSize",
 437              "return Py_BuildValue(\"l\", self->ob_itself.rsrcLogicalSize);",
 438              "return PyArg_Parse(v, \"l\", &self->ob_itself.rsrcLogicalSize)-1;",
 439              None
 440             ),
 441             ("rsrcPhysicalSize",
 442              "return Py_BuildValue(\"l\", self->ob_itself.rsrcPhysicalSize);",
 443              "return PyArg_Parse(v, \"l\", &self->ob_itself.rsrcPhysicalSize)-1;",
 444              None
 445             ),
 446             ("sharingFlags",
 447              "return Py_BuildValue(\"l\", self->ob_itself.sharingFlags);",
 448              "return PyArg_Parse(v, \"l\", &self->ob_itself.sharingFlags)-1;",
 449              None
 450             ),
 451             ("userPrivileges",
 452              "return Py_BuildValue(\"b\", self->ob_itself.userPrivileges);",
 453              "return PyArg_Parse(v, \"b\", &self->ob_itself.userPrivileges)-1;",
 454              None
 455             ),
 456     ]
 457     # The same info, but in a different form
 458     INITFORMAT = "HhllO&O&O&O&O&llllllb"
 459     INITARGS = """&((FSCatalogInfoObject *)_self)->ob_itself.nodeFlags,
 460             &((FSCatalogInfoObject *)_self)->ob_itself.volume,
 461             &((FSCatalogInfoObject *)_self)->ob_itself.parentDirID,
 462             &((FSCatalogInfoObject *)_self)->ob_itself.nodeID,
 463             UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.createDate,
 464             UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.contentModDate,
 465             UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.attributeModDate,
 466             UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.accessDate,
 467             UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.backupDate,
 468             &((FSCatalogInfoObject *)_self)->ob_itself.valence,
 469             &((FSCatalogInfoObject *)_self)->ob_itself.dataLogicalSize,
 470             &((FSCatalogInfoObject *)_self)->ob_itself.dataPhysicalSize,
 471             &((FSCatalogInfoObject *)_self)->ob_itself.rsrcLogicalSize,
 472             &((FSCatalogInfoObject *)_self)->ob_itself.rsrcPhysicalSize,
 473             &((FSCatalogInfoObject *)_self)->ob_itself.sharingFlags,
 474             &((FSCatalogInfoObject *)_self)->ob_itself.userPrivileges"""
 475     INITNAMES = """
 476             "nodeFlags",
 477             "volume",
 478             "parentDirID",
 479             "nodeID",
 480             "createDate",
 481             "contentModDate",
 482             "atributeModDate",
 483             "accessDate",
 484             "backupDate",
 485             "valence",
 486             "dataLogicalSize",
 487             "dataPhysicalSize",
 488             "rsrcLogicalSize",
 489             "rsrcPhysicalSize",
 490             "sharingFlags",
 491             "userPrivileges"
 492             """
 493
 494     def __init__(self, name, prefix, itselftype):
 495         ObjectDefinition.__init__(self, name, prefix, itselftype)
 496         self.argref = "*"       # Store FSSpecs, but pass them by address
 497
 498     def outputCheckNewArg(self):
 499         Output("if (itself == NULL) { Py_INCREF(Py_None); return Py_None; }")
 500
 501     def output_tp_newBody(self):
 502         Output("PyObject *self;");
 503         Output()
 504         Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
 505         Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",
 506                 self.objecttype, self.itselftype)
 507         Output("return self;")
 508
 509     def output_tp_initBody(self):
 510         Output("static char *kw[] = {%s, 0};", self.INITNAMES)
 511         Output()
 512         Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|%s\", kw, %s))",
 513                 self.INITFORMAT, self.INITARGS)
 514         OutLbrace()
 515         Output("return -1;")
 516         OutRbrace()
 517         Output("return 0;")
 518
 519 class FInfoDefinition(PEP253Mixin, ObjectDefinition):
 520     getsetlist = [
 521             ("Type",
 522              "return Py_BuildValue(\"O&\", PyMac_BuildOSType, self->ob_itself.fdType);",
 523              "return PyArg_Parse(v, \"O&\", PyMac_GetOSType, &self->ob_itself.fdType)-1;",
 524              "4-char file type"
 525             ),
 526             ("Creator",
 527              "return Py_BuildValue(\"O&\", PyMac_BuildOSType, self->ob_itself.fdCreator);",
 528              "return PyArg_Parse(v, \"O&\", PyMac_GetOSType, &self->ob_itself.fdCreator)-1;",
 529              "4-char file creator"
 530             ),
 531             ("Flags",
 532              "return Py_BuildValue(\"H\", self->ob_itself.fdFlags);",
 533              "return PyArg_Parse(v, \"H\", &self->ob_itself.fdFlags)-1;",
 534              "Finder flag bits"
 535             ),
 536             ("Location",
 537              "return Py_BuildValue(\"O&\", PyMac_BuildPoint, self->ob_itself.fdLocation);",
 538              "return PyArg_Parse(v, \"O&\", PyMac_GetPoint, &self->ob_itself.fdLocation)-1;",
 539              "(x, y) location of the file's icon in its parent finder window"
 540             ),
 541             ("Fldr",
 542              "return Py_BuildValue(\"h\", self->ob_itself.fdFldr);",
 543              "return PyArg_Parse(v, \"h\", &self->ob_itself.fdFldr)-1;",
 544              "Original folder, for 'put away'"
 545             ),
 546
 547     ]
 548
 549     def __init__(self, name, prefix, itselftype):
 550         ObjectDefinition.__init__(self, name, prefix, itselftype)
 551         self.argref = "*"       # Store FSSpecs, but pass them by address
 552
 553     def outputCheckNewArg(self):
 554         Output("if (itself == NULL) return PyMac_Error(resNotFound);")
 555
 556     def output_tp_newBody(self):
 557         Output("PyObject *self;");
 558         Output()
 559         Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
 560         Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",
 561                 self.objecttype, self.itselftype)
 562         Output("return self;")
 563
 564     def output_tp_initBody(self):
 565         Output("%s *itself = NULL;", self.itselftype)
 566         Output("static char *kw[] = {\"itself\", 0};")
 567         Output()
 568         Output("if (PyArg_ParseTupleAndKeywords(_args, _kwds, \"|O&\", kw, FInfo_Convert, &itself))")
 569         OutLbrace()
 570         Output("if (itself) memcpy(&((%s *)_self)->ob_itself, itself, sizeof(%s));",
 571                 self.objecttype, self.itselftype)
 572         Output("return 0;")
 573         OutRbrace()
 574         Output("return -1;")
 575
 576 class FSSpecDefinition(PEP253Mixin, ObjectDefinition):
 577     getsetlist = [
 578             ("data",
 579              "return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));",
 580              None,
 581              "Raw data of the FSSpec object"
 582             )
 583     ]
 584
 585     def __init__(self, name, prefix, itselftype):
 586         ObjectDefinition.__init__(self, name, prefix, itselftype)
 587         self.argref = "*"       # Store FSSpecs, but pass them by address
 588
 589     def outputCheckNewArg(self):
 590         Output("if (itself == NULL) return PyMac_Error(resNotFound);")
 591
 592     # We do Convert ourselves (with PyMac_GetFSxxx)
 593     def outputConvert(self):
 594         pass
 595
 596     def output_tp_newBody(self):
 597         Output("PyObject *self;");
 598         Output()
 599         Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
 600         Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",
 601                 self.objecttype, self.itselftype)
 602         Output("return self;")
 603
 604     def output_tp_initBody(self):
 605         Output("PyObject *v = NULL;")
 606         Output("char *rawdata = NULL;")
 607         Output("int rawdatalen = 0;")
 608         Output("static char *kw[] = {\"itself\", \"rawdata\", 0};")
 609         Output()
 610         Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|Os#\", kw, &v, &rawdata, &rawdatalen))")
 611         Output("return -1;")
 612         Output("if (v && rawdata)")
 613         OutLbrace()
 614         Output("PyErr_SetString(PyExc_TypeError, \"Only one of itself or rawdata may be specified\");")
 615         Output("return -1;")
 616         OutRbrace()
 617         Output("if (!v && !rawdata)")
 618         OutLbrace()
 619         Output("PyErr_SetString(PyExc_TypeError, \"One of itself or rawdata must be specified\");")
 620         Output("return -1;")
 621         OutRbrace()
 622         Output("if (rawdata)")
 623         OutLbrace()
 624         Output("if (rawdatalen != sizeof(%s))", self.itselftype)
 625         OutLbrace()
 626         Output("PyErr_SetString(PyExc_TypeError, \"%s rawdata incorrect size\");",
 627                 self.itselftype)
 628         Output("return -1;")
 629         OutRbrace()
 630         Output("memcpy(&((%s *)_self)->ob_itself, rawdata, rawdatalen);", self.objecttype)
 631         Output("return 0;")
 632         OutRbrace()
 633         Output("if (PyMac_GetFSSpec(v, &((%s *)_self)->ob_itself)) return 0;", self.objecttype)
 634         Output("return -1;")
 635
 636     def outputRepr(self):
 637         Output()
 638         Output("static PyObject * %s_repr(%s *self)", self.prefix, self.objecttype)
 639         OutLbrace()
 640         Output("char buf[512];")
 641         Output("""PyOS_snprintf(buf, sizeof(buf), \"%%s((%%d, %%ld, '%%.*s'))\",
 642         self->ob_type->tp_name,
 643         self->ob_itself.vRefNum,
 644         self->ob_itself.parID,
 645         self->ob_itself.name[0], self->ob_itself.name+1);""")
 646         Output("return PyString_FromString(buf);")
 647         OutRbrace()
 648
 649 class FSRefDefinition(PEP253Mixin, ObjectDefinition):
 650     getsetlist = [
 651             ("data",
 652              "return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));",
 653              None,
 654              "Raw data of the FSRef object"
 655             )
 656     ]
 657
 658     def __init__(self, name, prefix, itselftype):
 659         ObjectDefinition.__init__(self, name, prefix, itselftype)
 660         self.argref = "*"       # Store FSRefs, but pass them by address
 661
 662     def outputCheckNewArg(self):
 663         Output("if (itself == NULL) return PyMac_Error(resNotFound);")
 664
 665     # We do Convert ourselves (with PyMac_GetFSxxx)
 666     def outputConvert(self):
 667         pass
 668
 669     def output_tp_newBody(self):
 670         Output("PyObject *self;");
 671         Output()
 672         Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
 673         Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",
 674                 self.objecttype, self.itselftype)
 675         Output("return self;")
 676
 677     def output_tp_initBody(self):
 678         Output("PyObject *v = NULL;")
 679         Output("char *rawdata = NULL;")
 680         Output("int rawdatalen = 0;")
 681         Output("static char *kw[] = {\"itself\", \"rawdata\", 0};")
 682         Output()
 683         Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|Os#\", kw, &v, &rawdata, &rawdatalen))")
 684         Output("return -1;")
 685         Output("if (v && rawdata)")
 686         OutLbrace()
 687         Output("PyErr_SetString(PyExc_TypeError, \"Only one of itself or rawdata may be specified\");")
 688         Output("return -1;")
 689         OutRbrace()
 690         Output("if (!v && !rawdata)")
 691         OutLbrace()
 692         Output("PyErr_SetString(PyExc_TypeError, \"One of itself or rawdata must be specified\");")
 693         Output("return -1;")
 694         OutRbrace()
 695         Output("if (rawdata)")
 696         OutLbrace()
 697         Output("if (rawdatalen != sizeof(%s))", self.itselftype)
 698         OutLbrace()
 699         Output("PyErr_SetString(PyExc_TypeError, \"%s rawdata incorrect size\");",
 700                 self.itselftype)
 701         Output("return -1;")
 702         OutRbrace()
 703         Output("memcpy(&((%s *)_self)->ob_itself, rawdata, rawdatalen);", self.objecttype)
 704         Output("return 0;")
 705         OutRbrace()
 706         Output("if (PyMac_GetFSRef(v, &((%s *)_self)->ob_itself)) return 0;", self.objecttype)
 707         Output("return -1;")
 708
 709 class AliasDefinition(PEP253Mixin, ObjectDefinition):
 710     # XXXX Should inherit from resource?
 711     getsetlist = [
 712             ("data",
 713              """int size;
 714                     PyObject *rv;
 715
 716                     size = GetHandleSize((Handle)self->ob_itself);
 717                     HLock((Handle)self->ob_itself);
 718                     rv = PyString_FromStringAndSize(*(Handle)self->ob_itself, size);
 719                     HUnlock((Handle)self->ob_itself);
 720                     return rv;
 721             """,
 722              None,
 723              "Raw data of the alias object"
 724             )
 725     ]
 726
 727     def outputCheckNewArg(self):
 728         Output("if (itself == NULL) return PyMac_Error(resNotFound);")
 729
 730     def outputStructMembers(self):
 731         ObjectDefinition.outputStructMembers(self)
 732         Output("void (*ob_freeit)(%s ptr);", self.itselftype)
 733
 734     def outputInitStructMembers(self):
 735         ObjectDefinition.outputInitStructMembers(self)
 736         Output("it->ob_freeit = NULL;")
 737
 738     def outputCleanupStructMembers(self):
 739         Output("if (self->ob_freeit && self->ob_itself)")
 740         OutLbrace()
 741         Output("self->ob_freeit(self->ob_itself);")
 742         OutRbrace()
 743         Output("self->ob_itself = NULL;")
 744
 745     def output_tp_newBody(self):
 746         Output("PyObject *self;");
 747         Output()
 748         Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
 749         Output("((%s *)self)->ob_itself = NULL;", self.objecttype)
 750         Output("return self;")
 751
 752     def output_tp_initBody(self):
 753         Output("%s itself = NULL;", self.itselftype)
 754         Output("char *rawdata = NULL;")
 755         Output("int rawdatalen = 0;")
 756         Output("Handle h;")
 757         Output("static char *kw[] = {\"itself\", \"rawdata\", 0};")
 758         Output()
 759         Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|O&s#\", kw, %s_Convert, &itself, &rawdata, &rawdatalen))",
 760                 self.prefix)
 761         Output("return -1;")
 762         Output("if (itself && rawdata)")
 763         OutLbrace()
 764         Output("PyErr_SetString(PyExc_TypeError, \"Only one of itself or rawdata may be specified\");")
 765         Output("return -1;")
 766         OutRbrace()
 767         Output("if (!itself && !rawdata)")
 768         OutLbrace()
 769         Output("PyErr_SetString(PyExc_TypeError, \"One of itself or rawdata must be specified\");")
 770         Output("return -1;")
 771         OutRbrace()
 772         Output("if (rawdata)")
 773         OutLbrace()
 774         Output("if ((h = NewHandle(rawdatalen)) == NULL)")
 775         OutLbrace()
 776         Output("PyErr_NoMemory();")
 777         Output("return -1;")
 778         OutRbrace()
 779         Output("HLock(h);")
 780         Output("memcpy((char *)*h, rawdata, rawdatalen);")
 781         Output("HUnlock(h);")
 782         Output("((%s *)_self)->ob_itself = (%s)h;", self.objecttype, self.itselftype)
 783         Output("return 0;")
 784         OutRbrace()
 785         Output("((%s *)_self)->ob_itself = itself;", self.objecttype)
 786         Output("return 0;")
 787
 788 # Alias methods come in two flavors: those with the alias as arg1 and
 789 # those with the alias as arg 2.
 790 class Arg2MethodGenerator(OSErrMethodGenerator):
 791     """Similar to MethodGenerator, but has self as second argument"""
 792
 793     def parseArgumentList(self, args):
 794         args0, arg1, argsrest = args[:1], args[1], args[2:]
 795         t0, n0, m0 = arg1
 796         args = args0 + argsrest
 797         if m0 != InMode:
 798             raise ValueError, "method's 'self' must be 'InMode'"
 799         self.itself = Variable(t0, "_self->ob_itself", SelfMode)
 800         FunctionGenerator.parseArgumentList(self, args)
 801         self.argumentList.insert(2, self.itself)
 802
 803 # From here on it's basically all boiler plate...
 804
 805 # Create the generator groups and link them
 806 module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff,
 807         longname=LONGMODNAME)
 808
 809 fscataloginfoobject = FSCatalogInfoDefinition('FSCatalogInfo', 'FSCatalogInfo', 'FSCatalogInfo')
 810 finfoobject = FInfoDefinition('FInfo', 'FInfo', 'FInfo')
 811 aliasobject = AliasDefinition('Alias', 'Alias', 'AliasHandle')
 812 fsspecobject = FSSpecDefinition('FSSpec', 'FSSpec', 'FSSpec')
 813 fsrefobject = FSRefDefinition('FSRef', 'FSRef', 'FSRef')
 814
 815 module.addobject(fscataloginfoobject)
 816 module.addobject(finfoobject)
 817 module.addobject(aliasobject)
 818 module.addobject(fsspecobject)
 819 module.addobject(fsrefobject)
 820
 821 # Create the generator classes used to populate the lists
 822 Function = OSErrFunctionGenerator
 823 Method = OSErrMethodGenerator
 824
 825 # Create and populate the lists
 826 functions = []
 827 alias_methods = []
 828 fsref_methods = []
 829 fsspec_methods = []
 830 execfile(INPUTFILE)
 831
 832 # Manual generators:
 833 FSRefMakePath_body = """
 834 OSStatus _err;
 835 #define MAXPATHNAME 1024
 836 UInt8 path[MAXPATHNAME];
 837 UInt32 maxPathSize = MAXPATHNAME;
 838
 839 if (!PyArg_ParseTuple(_args, ""))
 840         return NULL;
 841 _err = FSRefMakePath(&_self->ob_itself,
 842                                          path,
 843                                          maxPathSize);
 844 if (_err != noErr) return PyMac_Error(_err);
 845 _res = Py_BuildValue("s", path);
 846 return _res;
 847 """
 848 f = ManualGenerator("FSRefMakePath", FSRefMakePath_body)
 849 f.docstring = lambda: "() -> string"
 850 fsref_methods.append(f)
 851
 852 FSRef_as_pathname_body = """
 853 if (!PyArg_ParseTuple(_args, ""))
 854         return NULL;
 855 _res = FSRef_FSRefMakePath(_self, _args);
 856 return _res;
 857 """
 858 f = ManualGenerator("as_pathname", FSRef_as_pathname_body)
 859 f.docstring = lambda: "() -> string"
 860 fsref_methods.append(f)
 861
 862 FSSpec_as_pathname_body = """
 863 char strbuf[1024];
 864 OSErr err;
 865
 866 if (!PyArg_ParseTuple(_args, ""))
 867         return NULL;
 868 err = _PyMac_GetFullPathname(&_self->ob_itself, strbuf, sizeof(strbuf));
 869 if ( err ) {
 870         PyMac_Error(err);
 871         return NULL;
 872 }
 873 _res = PyString_FromString(strbuf);
 874 return _res;
 875 """
 876 f = ManualGenerator("as_pathname", FSSpec_as_pathname_body)
 877 f.docstring = lambda: "() -> string"
 878 fsspec_methods.append(f)
 879
 880 FSSpec_as_tuple_body = """
 881 if (!PyArg_ParseTuple(_args, ""))
 882         return NULL;
 883 _res = Py_BuildValue("(iis#)", _self->ob_itself.vRefNum, _self->ob_itself.parID,
 884                                         &_self->ob_itself.name[1], _self->ob_itself.name[0]);
 885 return _res;
 886 """
 887 f = ManualGenerator("as_tuple", FSSpec_as_tuple_body)
 888 f.docstring = lambda: "() -> (vRefNum, dirID, name)"
 889 fsspec_methods.append(f)
 890
 891 pathname_body = """
 892 PyObject *obj;
 893
 894 if (!PyArg_ParseTuple(_args, "O", &obj))
 895         return NULL;
 896 if (PyString_Check(obj)) {
 897         Py_INCREF(obj);
 898         return obj;
 899 }
 900 if (PyUnicode_Check(obj))
 901         return PyUnicode_AsEncodedString(obj, "utf8", "strict");
 902 _res = PyObject_CallMethod(obj, "as_pathname", NULL);
 903 return _res;
 904 """
 905 f = ManualGenerator("pathname", pathname_body)
 906 f.docstring = lambda: "(str|unicode|FSSpec|FSref) -> pathname"
 907 functions.append(f)
 908
 909 # add the populated lists to the generator groups
 910 # (in a different wordl the scan program would generate this)
 911 for f in functions: module.add(f)
 912 for f in alias_methods: aliasobject.add(f)
 913 for f in fsspec_methods: fsspecobject.add(f)
 914 for f in fsref_methods: fsrefobject.add(f)
 915
 916 # generate output (open the output file as late as possible)
 917 SetOutputFileName(OUTPUTFILE)
 918 module.generate()