Home | History | Annotate | Download | only in file 
      1 
      2 /* ========================== Module _File ========================== */
      3 
      4 #include "Python.h"
      5 
      6 
      7 
      8 #include "pymactoolbox.h"
      9 
     10 #ifndef HAVE_OSX105_SDK
     11 typedef SInt16  FSIORefNum;
     12 #endif
     13 
     14 /* Macro to test whether a weak-loaded CFM function exists */
     15 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
     16         PyErr_SetString(PyExc_NotImplementedError, \
     17             "Not available in this shared library/OS version"); \
     18         return NULL; \
     19     }} while(0)
     20 
     21 
     22 #include <Carbon/Carbon.h>
     23 
     24 #ifdef USE_TOOLBOX_OBJECT_GLUE
     25 
     26 #ifndef __LP64__
     27 extern int _PyMac_GetFSSpec(PyObject *v, FSSpec *spec);
     28 extern PyObject *_PyMac_BuildFSSpec(FSSpec *spec);
     29 #define PyMac_BuildFSSpec _PyMac_BuildFSSpec
     30 #endif /* __LP64__*/
     31 
     32 extern int _PyMac_GetFSRef(PyObject *v, FSRef *fsr);
     33 extern PyObject *_PyMac_BuildFSRef(FSRef *spec);
     34 #define PyMac_BuildFSRef _PyMac_BuildFSRef
     35 #define PyMac_GetFSSpec _PyMac_GetFSSpec
     36 #define PyMac_GetFSRef _PyMac_GetFSRef
     37 
     38 #else   /* !USE_TOOLBOX_OBJECT_GLUE */
     39 
     40 #ifndef __LP64__
     41 extern int PyMac_GetFSSpec(PyObject *v, FSSpec *spec);
     42 extern PyObject *PyMac_BuildFSSpec(FSSpec *spec);
     43 #endif /* !__LP64__*/
     44 
     45 extern int PyMac_GetFSRef(PyObject *v, FSRef *fsr);
     46 extern PyObject *PyMac_BuildFSRef(FSRef *spec);
     47 
     48 #endif  /* !USE_TOOLBOX_OBJECT_GLUE */
     49 
     50 /* Forward declarations */
     51 static PyObject *FSRef_New(FSRef *itself);
     52 #ifndef __LP64__
     53 static PyObject *FInfo_New(FInfo *itself);
     54 
     55 static PyObject *FSSpec_New(FSSpec *itself);
     56 #define FSSpec_Convert PyMac_GetFSSpec
     57 #endif /* !__LP64__ */
     58 
     59 static PyObject *Alias_New(AliasHandle itself);
     60 #ifndef __LP64__
     61 static int FInfo_Convert(PyObject *v, FInfo *p_itself);
     62 #endif /* !__LP64__ */
     63 #define FSRef_Convert PyMac_GetFSRef
     64 static int Alias_Convert(PyObject *v, AliasHandle *p_itself);
     65 
     66 /*
     67 ** UTCDateTime records
     68 */
     69 static int
     70 UTCDateTime_Convert(PyObject *v, UTCDateTime *ptr)
     71 {
     72     return PyArg_Parse(v, "(HlH)", &ptr->highSeconds, &ptr->lowSeconds, &ptr->fraction);
     73 }
     74 
     75 static PyObject *
     76 UTCDateTime_New(UTCDateTime *ptr)
     77 {
     78     return Py_BuildValue("(HlH)", ptr->highSeconds, ptr->lowSeconds, ptr->fraction);
     79 }
     80 
     81 /*
     82 ** Optional fsspec and fsref pointers. None will pass NULL
     83 */
     84 #ifndef __LP64__
     85 static int
     86 myPyMac_GetOptFSSpecPtr(PyObject *v, FSSpec **spec)
     87 {
     88     if (v == Py_None) {
     89         *spec = NULL;
     90         return 1;
     91     }
     92     return PyMac_GetFSSpec(v, *spec);
     93 }
     94 #endif /* !__LP64__ */
     95 
     96 static int
     97 myPyMac_GetOptFSRefPtr(PyObject *v, FSRef **ref)
     98 {
     99     if (v == Py_None) {
    100         *ref = NULL;
    101         return 1;
    102     }
    103     return PyMac_GetFSRef(v, *ref);
    104 }
    105 
    106 /*
    107 ** Parse/generate objsect
    108 */
    109 static PyObject *
    110 PyMac_BuildHFSUniStr255(HFSUniStr255 *itself)
    111 {
    112 
    113     return Py_BuildValue("u#", itself->unicode, itself->length);
    114 }
    115 
    116 #ifndef __LP64__
    117 static OSErr
    118 _PyMac_GetFullPathname(FSSpec *fss, char *path, int len)
    119 {
    120     FSRef fsr;
    121     OSErr err;
    122 
    123     *path = '\0';
    124     err = FSpMakeFSRef(fss, &fsr);
    125     if (err == fnfErr) {
    126         /* FSSpecs can point to non-existing files, fsrefs can't. */
    127         FSSpec fss2;
    128         int tocopy;
    129 
    130         err = FSMakeFSSpec(fss->vRefNum, fss->parID,
    131                            (unsigned char*)"", &fss2);
    132         if (err)
    133             return err;
    134         err = FSpMakeFSRef(&fss2, &fsr);
    135         if (err)
    136             return err;
    137         err = (OSErr)FSRefMakePath(&fsr, (unsigned char*)path, len-1);
    138         if (err)
    139             return err;
    140         /* This part is not 100% safe: we append the filename part, but
    141         ** I'm not sure that we don't run afoul of the various 8bit
    142         ** encodings here. Will have to look this up at some point...
    143         */
    144         strcat(path, "/");
    145         tocopy = fss->name[0];
    146         if ((strlen(path) + tocopy) >= len)
    147             tocopy = len - strlen(path) - 1;
    148         if (tocopy > 0)
    149             strncat(path, (char*)fss->name+1, tocopy);
    150     }
    151     else {
    152         if (err)
    153             return err;
    154         err = (OSErr)FSRefMakePath(&fsr, (unsigned char*)path, len);
    155         if (err)
    156             return err;
    157     }
    158     return 0;
    159 }
    160 #endif /* !__LP64__ */
    161 
    162 
    163 static PyObject *File_Error;
    164 
    165 /* ------------------- Object type FSCatalogInfo -------------------- */
    166 
    167 static PyTypeObject FSCatalogInfo_Type;
    168 
    169 #define FSCatalogInfo_Check(x) ((x)->ob_type == &FSCatalogInfo_Type || PyObject_TypeCheck((x), &FSCatalogInfo_Type))
    170 
    171 typedef struct FSCatalogInfoObject {
    172     PyObject_HEAD
    173     FSCatalogInfo ob_itself;
    174 } FSCatalogInfoObject;
    175 
    176 static PyObject *FSCatalogInfo_New(FSCatalogInfo *itself)
    177 {
    178     FSCatalogInfoObject *it;
    179     if (itself == NULL) { Py_INCREF(Py_None); return Py_None; }
    180     it = PyObject_NEW(FSCatalogInfoObject, &FSCatalogInfo_Type);
    181     if (it == NULL) return NULL;
    182     it->ob_itself = *itself;
    183     return (PyObject *)it;
    184 }
    185 
    186 static int FSCatalogInfo_Convert(PyObject *v, FSCatalogInfo *p_itself)
    187 {
    188     if (!FSCatalogInfo_Check(v))
    189     {
    190         PyErr_SetString(PyExc_TypeError, "FSCatalogInfo required");
    191         return 0;
    192     }
    193     *p_itself = ((FSCatalogInfoObject *)v)->ob_itself;
    194     return 1;
    195 }
    196 
    197 static void FSCatalogInfo_dealloc(FSCatalogInfoObject *self)
    198 {
    199     /* Cleanup of self->ob_itself goes here */
    200     self->ob_type->tp_free((PyObject *)self);
    201 }
    202 
    203 static PyMethodDef FSCatalogInfo_methods[] = {
    204     {NULL, NULL, 0}
    205 };
    206 
    207 static PyObject *FSCatalogInfo_get_nodeFlags(FSCatalogInfoObject *self, void *closure)
    208 {
    209     return Py_BuildValue("H", self->ob_itself.nodeFlags);
    210 }
    211 
    212 static int FSCatalogInfo_set_nodeFlags(FSCatalogInfoObject *self, PyObject *v, void *closure)
    213 {
    214     return PyArg_Parse(v, "H", &self->ob_itself.nodeFlags)-1;
    215     return 0;
    216 }
    217 
    218 static PyObject *FSCatalogInfo_get_volume(FSCatalogInfoObject *self, void *closure)
    219 {
    220     return Py_BuildValue("h", self->ob_itself.volume);
    221 }
    222 
    223 static int FSCatalogInfo_set_volume(FSCatalogInfoObject *self, PyObject *v, void *closure)
    224 {
    225     return PyArg_Parse(v, "h", &self->ob_itself.volume)-1;
    226     return 0;
    227 }
    228 
    229 static PyObject *FSCatalogInfo_get_parentDirID(FSCatalogInfoObject *self, void *closure)
    230 {
    231     return Py_BuildValue("l", self->ob_itself.parentDirID);
    232 }
    233 
    234 static int FSCatalogInfo_set_parentDirID(FSCatalogInfoObject *self, PyObject *v, void *closure)
    235 {
    236     return PyArg_Parse(v, "l", &self->ob_itself.parentDirID)-1;
    237     return 0;
    238 }
    239 
    240 static PyObject *FSCatalogInfo_get_nodeID(FSCatalogInfoObject *self, void *closure)
    241 {
    242     return Py_BuildValue("l", self->ob_itself.nodeID);
    243 }
    244 
    245 static int FSCatalogInfo_set_nodeID(FSCatalogInfoObject *self, PyObject *v, void *closure)
    246 {
    247     return PyArg_Parse(v, "l", &self->ob_itself.nodeID)-1;
    248     return 0;
    249 }
    250 
    251 static PyObject *FSCatalogInfo_get_createDate(FSCatalogInfoObject *self, void *closure)
    252 {
    253     return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.createDate);
    254 }
    255 
    256 static int FSCatalogInfo_set_createDate(FSCatalogInfoObject *self, PyObject *v, void *closure)
    257 {
    258     return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.createDate)-1;
    259     return 0;
    260 }
    261 
    262 static PyObject *FSCatalogInfo_get_contentModDate(FSCatalogInfoObject *self, void *closure)
    263 {
    264     return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.contentModDate);
    265 }
    266 
    267 static int FSCatalogInfo_set_contentModDate(FSCatalogInfoObject *self, PyObject *v, void *closure)
    268 {
    269     return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.contentModDate)-1;
    270     return 0;
    271 }
    272 
    273 static PyObject *FSCatalogInfo_get_attributeModDate(FSCatalogInfoObject *self, void *closure)
    274 {
    275     return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.attributeModDate);
    276 }
    277 
    278 static int FSCatalogInfo_set_attributeModDate(FSCatalogInfoObject *self, PyObject *v, void *closure)
    279 {
    280     return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.attributeModDate)-1;
    281     return 0;
    282 }
    283 
    284 static PyObject *FSCatalogInfo_get_accessDate(FSCatalogInfoObject *self, void *closure)
    285 {
    286     return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.accessDate);
    287 }
    288 
    289 static int FSCatalogInfo_set_accessDate(FSCatalogInfoObject *self, PyObject *v, void *closure)
    290 {
    291     return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.accessDate)-1;
    292     return 0;
    293 }
    294 
    295 static PyObject *FSCatalogInfo_get_backupDate(FSCatalogInfoObject *self, void *closure)
    296 {
    297     return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.backupDate);
    298 }
    299 
    300 static int FSCatalogInfo_set_backupDate(FSCatalogInfoObject *self, PyObject *v, void *closure)
    301 {
    302     return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.backupDate)-1;
    303     return 0;
    304 }
    305 
    306 static PyObject *FSCatalogInfo_get_permissions(FSCatalogInfoObject *self, void *closure)
    307 {
    308     FSPermissionInfo* info = (FSPermissionInfo*)&(self->ob_itself.permissions);
    309     return Py_BuildValue("(llll)", info->userID, info->groupID, info->userAccess, info->mode);
    310 }
    311 
    312 static int FSCatalogInfo_set_permissions(FSCatalogInfoObject *self, PyObject *v, void *closure)
    313 {
    314     long userID;
    315     long groupID;
    316     long userAccess;
    317     long mode;
    318     int r;
    319 
    320     FSPermissionInfo* info = (FSPermissionInfo*)&(self->ob_itself.permissions);
    321 
    322     r = PyArg_Parse(v, "(llll)", &userID, &groupID, &userAccess, &mode);
    323     if (!r) {
    324         return -1;
    325     }
    326     info->userID = userID;
    327     info->groupID = groupID;
    328     info->userAccess = userAccess;
    329     info->mode = mode;
    330     return 0;
    331 }
    332 
    333 static PyObject *FSCatalogInfo_get_valence(FSCatalogInfoObject *self, void *closure)
    334 {
    335     return Py_BuildValue("l", self->ob_itself.valence);
    336 }
    337 
    338 static int FSCatalogInfo_set_valence(FSCatalogInfoObject *self, PyObject *v, void *closure)
    339 {
    340     return PyArg_Parse(v, "l", &self->ob_itself.valence)-1;
    341     return 0;
    342 }
    343 
    344 static PyObject *FSCatalogInfo_get_dataLogicalSize(FSCatalogInfoObject *self, void *closure)
    345 {
    346     return Py_BuildValue("l", self->ob_itself.dataLogicalSize);
    347 }
    348 
    349 static int FSCatalogInfo_set_dataLogicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure)
    350 {
    351     return PyArg_Parse(v, "l", &self->ob_itself.dataLogicalSize)-1;
    352     return 0;
    353 }
    354 
    355 static PyObject *FSCatalogInfo_get_dataPhysicalSize(FSCatalogInfoObject *self, void *closure)
    356 {
    357     return Py_BuildValue("l", self->ob_itself.dataPhysicalSize);
    358 }
    359 
    360 static int FSCatalogInfo_set_dataPhysicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure)
    361 {
    362     return PyArg_Parse(v, "l", &self->ob_itself.dataPhysicalSize)-1;
    363     return 0;
    364 }
    365 
    366 static PyObject *FSCatalogInfo_get_rsrcLogicalSize(FSCatalogInfoObject *self, void *closure)
    367 {
    368     return Py_BuildValue("l", self->ob_itself.rsrcLogicalSize);
    369 }
    370 
    371 static int FSCatalogInfo_set_rsrcLogicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure)
    372 {
    373     return PyArg_Parse(v, "l", &self->ob_itself.rsrcLogicalSize)-1;
    374     return 0;
    375 }
    376 
    377 static PyObject *FSCatalogInfo_get_rsrcPhysicalSize(FSCatalogInfoObject *self, void *closure)
    378 {
    379     return Py_BuildValue("l", self->ob_itself.rsrcPhysicalSize);
    380 }
    381 
    382 static int FSCatalogInfo_set_rsrcPhysicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure)
    383 {
    384     return PyArg_Parse(v, "l", &self->ob_itself.rsrcPhysicalSize)-1;
    385     return 0;
    386 }
    387 
    388 static PyObject *FSCatalogInfo_get_sharingFlags(FSCatalogInfoObject *self, void *closure)
    389 {
    390     return Py_BuildValue("l", self->ob_itself.sharingFlags);
    391 }
    392 
    393 static int FSCatalogInfo_set_sharingFlags(FSCatalogInfoObject *self, PyObject *v, void *closure)
    394 {
    395     return PyArg_Parse(v, "l", &self->ob_itself.sharingFlags)-1;
    396     return 0;
    397 }
    398 
    399 static PyObject *FSCatalogInfo_get_userPrivileges(FSCatalogInfoObject *self, void *closure)
    400 {
    401     return Py_BuildValue("b", self->ob_itself.userPrivileges);
    402 }
    403 
    404 static int FSCatalogInfo_set_userPrivileges(FSCatalogInfoObject *self, PyObject *v, void *closure)
    405 {
    406     return PyArg_Parse(v, "b", &self->ob_itself.userPrivileges)-1;
    407     return 0;
    408 }
    409 
    410 static PyGetSetDef FSCatalogInfo_getsetlist[] = {
    411     {"nodeFlags", (getter)FSCatalogInfo_get_nodeFlags, (setter)FSCatalogInfo_set_nodeFlags, NULL},
    412     {"volume", (getter)FSCatalogInfo_get_volume, (setter)FSCatalogInfo_set_volume, NULL},
    413     {"parentDirID", (getter)FSCatalogInfo_get_parentDirID, (setter)FSCatalogInfo_set_parentDirID, NULL},
    414     {"nodeID", (getter)FSCatalogInfo_get_nodeID, (setter)FSCatalogInfo_set_nodeID, NULL},
    415     {"createDate", (getter)FSCatalogInfo_get_createDate, (setter)FSCatalogInfo_set_createDate, NULL},
    416     {"contentModDate", (getter)FSCatalogInfo_get_contentModDate, (setter)FSCatalogInfo_set_contentModDate, NULL},
    417     {"attributeModDate", (getter)FSCatalogInfo_get_attributeModDate, (setter)FSCatalogInfo_set_attributeModDate, NULL},
    418     {"accessDate", (getter)FSCatalogInfo_get_accessDate, (setter)FSCatalogInfo_set_accessDate, NULL},
    419     {"backupDate", (getter)FSCatalogInfo_get_backupDate, (setter)FSCatalogInfo_set_backupDate, NULL},
    420     {"permissions", (getter)FSCatalogInfo_get_permissions, (setter)FSCatalogInfo_set_permissions, NULL},
    421     {"valence", (getter)FSCatalogInfo_get_valence, (setter)FSCatalogInfo_set_valence, NULL},
    422     {"dataLogicalSize", (getter)FSCatalogInfo_get_dataLogicalSize, (setter)FSCatalogInfo_set_dataLogicalSize, NULL},
    423     {"dataPhysicalSize", (getter)FSCatalogInfo_get_dataPhysicalSize, (setter)FSCatalogInfo_set_dataPhysicalSize, NULL},
    424     {"rsrcLogicalSize", (getter)FSCatalogInfo_get_rsrcLogicalSize, (setter)FSCatalogInfo_set_rsrcLogicalSize, NULL},
    425     {"rsrcPhysicalSize", (getter)FSCatalogInfo_get_rsrcPhysicalSize, (setter)FSCatalogInfo_set_rsrcPhysicalSize, NULL},
    426     {"sharingFlags", (getter)FSCatalogInfo_get_sharingFlags, (setter)FSCatalogInfo_set_sharingFlags, NULL},
    427     {"userPrivileges", (getter)FSCatalogInfo_get_userPrivileges, (setter)FSCatalogInfo_set_userPrivileges, NULL},
    428     {NULL, NULL, NULL, NULL},
    429 };
    430 
    431 
    432 #define FSCatalogInfo_compare NULL
    433 
    434 #define FSCatalogInfo_repr NULL
    435 
    436 #define FSCatalogInfo_hash NULL
    437 static int FSCatalogInfo_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
    438 {
    439     static char *kw[] = {
    440                 "nodeFlags",
    441                 "volume",
    442                 "parentDirID",
    443                 "nodeID",
    444                 "createDate",
    445                 "contentModDate",
    446                 "atributeModDate",
    447                 "accessDate",
    448                 "backupDate",
    449                 "valence",
    450                 "dataLogicalSize",
    451                 "dataPhysicalSize",
    452                 "rsrcLogicalSize",
    453                 "rsrcPhysicalSize",
    454                 "sharingFlags",
    455                 "userPrivileges"
    456                 , 0};
    457 
    458     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|HhllO&O&O&O&O&llllllb", kw, &((FSCatalogInfoObject *)_self)->ob_itself.nodeFlags,
    459                 &((FSCatalogInfoObject *)_self)->ob_itself.volume,
    460                 &((FSCatalogInfoObject *)_self)->ob_itself.parentDirID,
    461                 &((FSCatalogInfoObject *)_self)->ob_itself.nodeID,
    462                 UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.createDate,
    463                 UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.contentModDate,
    464                 UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.attributeModDate,
    465                 UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.accessDate,
    466                 UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.backupDate,
    467                 &((FSCatalogInfoObject *)_self)->ob_itself.valence,
    468                 &((FSCatalogInfoObject *)_self)->ob_itself.dataLogicalSize,
    469                 &((FSCatalogInfoObject *)_self)->ob_itself.dataPhysicalSize,
    470                 &((FSCatalogInfoObject *)_self)->ob_itself.rsrcLogicalSize,
    471                 &((FSCatalogInfoObject *)_self)->ob_itself.rsrcPhysicalSize,
    472                 &((FSCatalogInfoObject *)_self)->ob_itself.sharingFlags,
    473                 &((FSCatalogInfoObject *)_self)->ob_itself.userPrivileges))
    474     {
    475         return -1;
    476     }
    477     return 0;
    478 }
    479 
    480 #define FSCatalogInfo_tp_alloc PyType_GenericAlloc
    481 
    482 static PyObject *FSCatalogInfo_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
    483 {
    484     PyObject *self;
    485 
    486     if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
    487     memset(&((FSCatalogInfoObject *)self)->ob_itself, 0, sizeof(FSCatalogInfo));
    488     return self;
    489 }
    490 
    491 #define FSCatalogInfo_tp_free PyObject_Del
    492 
    493 
    494 static PyTypeObject FSCatalogInfo_Type = {
    495     PyObject_HEAD_INIT(NULL)
    496     0, /*ob_size*/
    497     "Carbon.File.FSCatalogInfo", /*tp_name*/
    498     sizeof(FSCatalogInfoObject), /*tp_basicsize*/
    499     0, /*tp_itemsize*/
    500     /* methods */
    501     (destructor) FSCatalogInfo_dealloc, /*tp_dealloc*/
    502     0, /*tp_print*/
    503     (getattrfunc)0, /*tp_getattr*/
    504     (setattrfunc)0, /*tp_setattr*/
    505     (cmpfunc) FSCatalogInfo_compare, /*tp_compare*/
    506     (reprfunc) FSCatalogInfo_repr, /*tp_repr*/
    507     (PyNumberMethods *)0, /* tp_as_number */
    508     (PySequenceMethods *)0, /* tp_as_sequence */
    509     (PyMappingMethods *)0, /* tp_as_mapping */
    510     (hashfunc) FSCatalogInfo_hash, /*tp_hash*/
    511     0, /*tp_call*/
    512     0, /*tp_str*/
    513     PyObject_GenericGetAttr, /*tp_getattro*/
    514     PyObject_GenericSetAttr, /*tp_setattro */
    515     0, /*tp_as_buffer*/
    516     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    517     0, /*tp_doc*/
    518     0, /*tp_traverse*/
    519     0, /*tp_clear*/
    520     0, /*tp_richcompare*/
    521     0, /*tp_weaklistoffset*/
    522     0, /*tp_iter*/
    523     0, /*tp_iternext*/
    524     FSCatalogInfo_methods, /* tp_methods */
    525     0, /*tp_members*/
    526     FSCatalogInfo_getsetlist, /*tp_getset*/
    527     0, /*tp_base*/
    528     0, /*tp_dict*/
    529     0, /*tp_descr_get*/
    530     0, /*tp_descr_set*/
    531     0, /*tp_dictoffset*/
    532     FSCatalogInfo_tp_init, /* tp_init */
    533     FSCatalogInfo_tp_alloc, /* tp_alloc */
    534     FSCatalogInfo_tp_new, /* tp_new */
    535     FSCatalogInfo_tp_free, /* tp_free */
    536 };
    537 
    538 /* ----------------- End object type FSCatalogInfo ------------------ */
    539 
    540 
    541 /* ----------------------- Object type FInfo ------------------------ */
    542 
    543 #ifndef __LP64__
    544 
    545 static PyTypeObject FInfo_Type;
    546 
    547 #define FInfo_Check(x) ((x)->ob_type == &FInfo_Type || PyObject_TypeCheck((x), &FInfo_Type))
    548 
    549 typedef struct FInfoObject {
    550     PyObject_HEAD
    551     FInfo ob_itself;
    552 } FInfoObject;
    553 
    554 static PyObject *FInfo_New(FInfo *itself)
    555 {
    556     FInfoObject *it;
    557     if (itself == NULL) return PyMac_Error(resNotFound);
    558     it = PyObject_NEW(FInfoObject, &FInfo_Type);
    559     if (it == NULL) return NULL;
    560     it->ob_itself = *itself;
    561     return (PyObject *)it;
    562 }
    563 
    564 static int FInfo_Convert(PyObject *v, FInfo *p_itself)
    565 {
    566     if (!FInfo_Check(v))
    567     {
    568         PyErr_SetString(PyExc_TypeError, "FInfo required");
    569         return 0;
    570     }
    571     *p_itself = ((FInfoObject *)v)->ob_itself;
    572     return 1;
    573 }
    574 
    575 static void FInfo_dealloc(FInfoObject *self)
    576 {
    577     /* Cleanup of self->ob_itself goes here */
    578     self->ob_type->tp_free((PyObject *)self);
    579 }
    580 
    581 static PyMethodDef FInfo_methods[] = {
    582     {NULL, NULL, 0}
    583 };
    584 
    585 static PyObject *FInfo_get_Type(FInfoObject *self, void *closure)
    586 {
    587     return Py_BuildValue("O&", PyMac_BuildOSType, self->ob_itself.fdType);
    588 }
    589 
    590 static int FInfo_set_Type(FInfoObject *self, PyObject *v, void *closure)
    591 {
    592     return PyArg_Parse(v, "O&", PyMac_GetOSType, &self->ob_itself.fdType)-1;
    593     return 0;
    594 }
    595 
    596 static PyObject *FInfo_get_Creator(FInfoObject *self, void *closure)
    597 {
    598     return Py_BuildValue("O&", PyMac_BuildOSType, self->ob_itself.fdCreator);
    599 }
    600 
    601 static int FInfo_set_Creator(FInfoObject *self, PyObject *v, void *closure)
    602 {
    603     return PyArg_Parse(v, "O&", PyMac_GetOSType, &self->ob_itself.fdCreator)-1;
    604     return 0;
    605 }
    606 
    607 static PyObject *FInfo_get_Flags(FInfoObject *self, void *closure)
    608 {
    609     return Py_BuildValue("H", self->ob_itself.fdFlags);
    610 }
    611 
    612 static int FInfo_set_Flags(FInfoObject *self, PyObject *v, void *closure)
    613 {
    614     return PyArg_Parse(v, "H", &self->ob_itself.fdFlags)-1;
    615     return 0;
    616 }
    617 
    618 static PyObject *FInfo_get_Location(FInfoObject *self, void *closure)
    619 {
    620     return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself.fdLocation);
    621 }
    622 
    623 static int FInfo_set_Location(FInfoObject *self, PyObject *v, void *closure)
    624 {
    625     return PyArg_Parse(v, "O&", PyMac_GetPoint, &self->ob_itself.fdLocation)-1;
    626     return 0;
    627 }
    628 
    629 static PyObject *FInfo_get_Fldr(FInfoObject *self, void *closure)
    630 {
    631     return Py_BuildValue("h", self->ob_itself.fdFldr);
    632 }
    633 
    634 static int FInfo_set_Fldr(FInfoObject *self, PyObject *v, void *closure)
    635 {
    636     return PyArg_Parse(v, "h", &self->ob_itself.fdFldr)-1;
    637     return 0;
    638 }
    639 
    640 static PyGetSetDef FInfo_getsetlist[] = {
    641     {"Type", (getter)FInfo_get_Type, (setter)FInfo_set_Type, "4-char file type"},
    642     {"Creator", (getter)FInfo_get_Creator, (setter)FInfo_set_Creator, "4-char file creator"},
    643     {"Flags", (getter)FInfo_get_Flags, (setter)FInfo_set_Flags, "Finder flag bits"},
    644     {"Location", (getter)FInfo_get_Location, (setter)FInfo_set_Location, "(x, y) location of the file's icon in its parent finder window"},
    645     {"Fldr", (getter)FInfo_get_Fldr, (setter)FInfo_set_Fldr, "Original folder, for 'put away'"},
    646     {NULL, NULL, NULL, NULL},
    647 };
    648 
    649 
    650 #define FInfo_compare NULL
    651 
    652 #define FInfo_repr NULL
    653 
    654 #define FInfo_hash NULL
    655 static int FInfo_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
    656 {
    657     FInfo *itself = NULL;
    658     static char *kw[] = {"itself", 0};
    659 
    660     if (PyArg_ParseTupleAndKeywords(_args, _kwds, "|O&", kw, FInfo_Convert, &itself))
    661     {
    662         if (itself) memcpy(&((FInfoObject *)_self)->ob_itself, itself, sizeof(FInfo));
    663         return 0;
    664     }
    665     return -1;
    666 }
    667 
    668 #define FInfo_tp_alloc PyType_GenericAlloc
    669 
    670 static PyObject *FInfo_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
    671 {
    672     PyObject *self;
    673 
    674     if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
    675     memset(&((FInfoObject *)self)->ob_itself, 0, sizeof(FInfo));
    676     return self;
    677 }
    678 
    679 #define FInfo_tp_free PyObject_Del
    680 
    681 
    682 static PyTypeObject FInfo_Type = {
    683     PyObject_HEAD_INIT(NULL)
    684     0, /*ob_size*/
    685     "Carbon.File.FInfo", /*tp_name*/
    686     sizeof(FInfoObject), /*tp_basicsize*/
    687     0, /*tp_itemsize*/
    688     /* methods */
    689     (destructor) FInfo_dealloc, /*tp_dealloc*/
    690     0, /*tp_print*/
    691     (getattrfunc)0, /*tp_getattr*/
    692     (setattrfunc)0, /*tp_setattr*/
    693     (cmpfunc) FInfo_compare, /*tp_compare*/
    694     (reprfunc) FInfo_repr, /*tp_repr*/
    695     (PyNumberMethods *)0, /* tp_as_number */
    696     (PySequenceMethods *)0, /* tp_as_sequence */
    697     (PyMappingMethods *)0, /* tp_as_mapping */
    698     (hashfunc) FInfo_hash, /*tp_hash*/
    699     0, /*tp_call*/
    700     0, /*tp_str*/
    701     PyObject_GenericGetAttr, /*tp_getattro*/
    702     PyObject_GenericSetAttr, /*tp_setattro */
    703     0, /*tp_as_buffer*/
    704     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    705     0, /*tp_doc*/
    706     0, /*tp_traverse*/
    707     0, /*tp_clear*/
    708     0, /*tp_richcompare*/
    709     0, /*tp_weaklistoffset*/
    710     0, /*tp_iter*/
    711     0, /*tp_iternext*/
    712     FInfo_methods, /* tp_methods */
    713     0, /*tp_members*/
    714     FInfo_getsetlist, /*tp_getset*/
    715     0, /*tp_base*/
    716     0, /*tp_dict*/
    717     0, /*tp_descr_get*/
    718     0, /*tp_descr_set*/
    719     0, /*tp_dictoffset*/
    720     FInfo_tp_init, /* tp_init */
    721     FInfo_tp_alloc, /* tp_alloc */
    722     FInfo_tp_new, /* tp_new */
    723     FInfo_tp_free, /* tp_free */
    724 };
    725 
    726 #endif /* !__LP64__ */
    727 /* --------------------- End object type FInfo ---------------------- */
    728 
    729 
    730 /* ----------------------- Object type Alias ------------------------ */
    731 
    732 static PyTypeObject Alias_Type;
    733 
    734 #define Alias_Check(x) ((x)->ob_type == &Alias_Type || PyObject_TypeCheck((x), &Alias_Type))
    735 
    736 typedef struct AliasObject {
    737     PyObject_HEAD
    738     AliasHandle ob_itself;
    739     void (*ob_freeit)(AliasHandle ptr);
    740 } AliasObject;
    741 
    742 static PyObject *Alias_New(AliasHandle itself)
    743 {
    744     AliasObject *it;
    745     if (itself == NULL) return PyMac_Error(resNotFound);
    746     it = PyObject_NEW(AliasObject, &Alias_Type);
    747     if (it == NULL) return NULL;
    748     it->ob_itself = itself;
    749     it->ob_freeit = NULL;
    750     return (PyObject *)it;
    751 }
    752 
    753 static int Alias_Convert(PyObject *v, AliasHandle *p_itself)
    754 {
    755     if (!Alias_Check(v))
    756     {
    757         PyErr_SetString(PyExc_TypeError, "Alias required");
    758         return 0;
    759     }
    760     *p_itself = ((AliasObject *)v)->ob_itself;
    761     return 1;
    762 }
    763 
    764 static void Alias_dealloc(AliasObject *self)
    765 {
    766     if (self->ob_freeit && self->ob_itself)
    767     {
    768         self->ob_freeit(self->ob_itself);
    769     }
    770     self->ob_itself = NULL;
    771     self->ob_type->tp_free((PyObject *)self);
    772 }
    773 
    774 #ifndef __LP64__
    775 static PyObject *Alias_ResolveAlias(AliasObject *_self, PyObject *_args)
    776 {
    777     PyObject *_res = NULL;
    778     OSErr _err;
    779     FSSpec fromFile__buf__;
    780     FSSpec *fromFile = &fromFile__buf__;
    781     FSSpec target;
    782     Boolean wasChanged;
    783     if (!PyArg_ParseTuple(_args, "O&",
    784                           myPyMac_GetOptFSSpecPtr, &fromFile))
    785         return NULL;
    786     _err = ResolveAlias(fromFile,
    787                         _self->ob_itself,
    788                         &target,
    789                         &wasChanged);
    790     if (_err != noErr) return PyMac_Error(_err);
    791     _res = Py_BuildValue("O&b",
    792                          FSSpec_New, &target,
    793                          wasChanged);
    794     return _res;
    795 }
    796 
    797 static PyObject *Alias_GetAliasInfo(AliasObject *_self, PyObject *_args)
    798 {
    799     PyObject *_res = NULL;
    800     OSErr _err;
    801     AliasInfoType index;
    802     Str63 theString;
    803     if (!PyArg_ParseTuple(_args, "h",
    804                           &index))
    805         return NULL;
    806     _err = GetAliasInfo(_self->ob_itself,
    807                         index,
    808                         theString);
    809     if (_err != noErr) return PyMac_Error(_err);
    810     _res = Py_BuildValue("O&",
    811                          PyMac_BuildStr255, theString);
    812     return _res;
    813 }
    814 
    815 static PyObject *Alias_ResolveAliasWithMountFlags(AliasObject *_self, PyObject *_args)
    816 {
    817     PyObject *_res = NULL;
    818     OSErr _err;
    819     FSSpec fromFile__buf__;
    820     FSSpec *fromFile = &fromFile__buf__;
    821     FSSpec target;
    822     Boolean wasChanged;
    823     unsigned long mountFlags;
    824     if (!PyArg_ParseTuple(_args, "O&l",
    825                           myPyMac_GetOptFSSpecPtr, &fromFile,
    826                           &mountFlags))
    827         return NULL;
    828     _err = ResolveAliasWithMountFlags(fromFile,
    829                                       _self->ob_itself,
    830                                       &target,
    831                                       &wasChanged,
    832                                       mountFlags);
    833     if (_err != noErr) return PyMac_Error(_err);
    834     _res = Py_BuildValue("O&b",
    835                          FSSpec_New, &target,
    836                          wasChanged);
    837     return _res;
    838 }
    839 
    840 static PyObject *Alias_FollowFinderAlias(AliasObject *_self, PyObject *_args)
    841 {
    842     PyObject *_res = NULL;
    843     OSErr _err;
    844     FSSpec fromFile__buf__;
    845     FSSpec *fromFile = &fromFile__buf__;
    846     Boolean logon;
    847     FSSpec target;
    848     Boolean wasChanged;
    849     if (!PyArg_ParseTuple(_args, "O&b",
    850                           myPyMac_GetOptFSSpecPtr, &fromFile,
    851                           &logon))
    852         return NULL;
    853     _err = FollowFinderAlias(fromFile,
    854                              _self->ob_itself,
    855                              logon,
    856                              &target,
    857                              &wasChanged);
    858     if (_err != noErr) return PyMac_Error(_err);
    859     _res = Py_BuildValue("O&b",
    860                          FSSpec_New, &target,
    861                          wasChanged);
    862     return _res;
    863 }
    864 #endif /* !__LP64__ */
    865 
    866 static PyObject *Alias_FSResolveAliasWithMountFlags(AliasObject *_self, PyObject *_args)
    867 {
    868     PyObject *_res = NULL;
    869     OSErr _err;
    870     FSRef fromFile__buf__;
    871     FSRef *fromFile = &fromFile__buf__;
    872     FSRef target;
    873     Boolean wasChanged;
    874     unsigned long mountFlags;
    875     if (!PyArg_ParseTuple(_args, "O&l",
    876                           myPyMac_GetOptFSRefPtr, &fromFile,
    877                           &mountFlags))
    878         return NULL;
    879     _err = FSResolveAliasWithMountFlags(fromFile,
    880                                         _self->ob_itself,
    881                                         &target,
    882                                         &wasChanged,
    883                                         mountFlags);
    884     if (_err != noErr) return PyMac_Error(_err);
    885     _res = Py_BuildValue("O&b",
    886                          FSRef_New, &target,
    887                          wasChanged);
    888     return _res;
    889 }
    890 
    891 static PyObject *Alias_FSResolveAlias(AliasObject *_self, PyObject *_args)
    892 {
    893     PyObject *_res = NULL;
    894     OSErr _err;
    895     FSRef fromFile__buf__;
    896     FSRef *fromFile = &fromFile__buf__;
    897     FSRef target;
    898     Boolean wasChanged;
    899     if (!PyArg_ParseTuple(_args, "O&",
    900                           myPyMac_GetOptFSRefPtr, &fromFile))
    901         return NULL;
    902     _err = FSResolveAlias(fromFile,
    903                           _self->ob_itself,
    904                           &target,
    905                           &wasChanged);
    906     if (_err != noErr) return PyMac_Error(_err);
    907     _res = Py_BuildValue("O&b",
    908                          FSRef_New, &target,
    909                          wasChanged);
    910     return _res;
    911 }
    912 
    913 static PyObject *Alias_FSFollowFinderAlias(AliasObject *_self, PyObject *_args)
    914 {
    915     PyObject *_res = NULL;
    916     OSErr _err;
    917     FSRef fromFile;
    918     Boolean logon;
    919     FSRef target;
    920     Boolean wasChanged;
    921     if (!PyArg_ParseTuple(_args, "b",
    922                           &logon))
    923         return NULL;
    924     _err = FSFollowFinderAlias(&fromFile,
    925                                _self->ob_itself,
    926                                logon,
    927                                &target,
    928                                &wasChanged);
    929     if (_err != noErr) return PyMac_Error(_err);
    930     _res = Py_BuildValue("O&O&b",
    931                          FSRef_New, &fromFile,
    932                          FSRef_New, &target,
    933                          wasChanged);
    934     return _res;
    935 }
    936 
    937 static PyMethodDef Alias_methods[] = {
    938 #ifndef __LP64__
    939     {"ResolveAlias", (PyCFunction)Alias_ResolveAlias, 1,
    940      PyDoc_STR("(FSSpec fromFile) -> (FSSpec target, Boolean wasChanged)")},
    941     {"GetAliasInfo", (PyCFunction)Alias_GetAliasInfo, 1,
    942      PyDoc_STR("(AliasInfoType index) -> (Str63 theString)")},
    943     {"ResolveAliasWithMountFlags", (PyCFunction)Alias_ResolveAliasWithMountFlags, 1,
    944      PyDoc_STR("(FSSpec fromFile, unsigned long mountFlags) -> (FSSpec target, Boolean wasChanged)")},
    945     {"FollowFinderAlias", (PyCFunction)Alias_FollowFinderAlias, 1,
    946      PyDoc_STR("(FSSpec fromFile, Boolean logon) -> (FSSpec target, Boolean wasChanged)")},
    947 #endif /* !__LP64__ */
    948     {"FSResolveAliasWithMountFlags", (PyCFunction)Alias_FSResolveAliasWithMountFlags, 1,
    949      PyDoc_STR("(FSRef fromFile, unsigned long mountFlags) -> (FSRef target, Boolean wasChanged)")},
    950     {"FSResolveAlias", (PyCFunction)Alias_FSResolveAlias, 1,
    951      PyDoc_STR("(FSRef fromFile) -> (FSRef target, Boolean wasChanged)")},
    952     {"FSFollowFinderAlias", (PyCFunction)Alias_FSFollowFinderAlias, 1,
    953      PyDoc_STR("(Boolean logon) -> (FSRef fromFile, FSRef target, Boolean wasChanged)")},
    954     {NULL, NULL, 0}
    955 };
    956 
    957 static PyObject *Alias_get_data(AliasObject *self, void *closure)
    958 {
    959     int size;
    960                         PyObject *rv;
    961 
    962                         size = GetHandleSize((Handle)self->ob_itself);
    963                         HLock((Handle)self->ob_itself);
    964                         rv = PyString_FromStringAndSize(*(Handle)self->ob_itself, size);
    965                         HUnlock((Handle)self->ob_itself);
    966                         return rv;
    967 
    968 }
    969 
    970 #define Alias_set_data NULL
    971 
    972 static PyGetSetDef Alias_getsetlist[] = {
    973     {"data", (getter)Alias_get_data, (setter)Alias_set_data, "Raw data of the alias object"},
    974     {NULL, NULL, NULL, NULL},
    975 };
    976 
    977 
    978 #define Alias_compare NULL
    979 
    980 #define Alias_repr NULL
    981 
    982 #define Alias_hash NULL
    983 static int Alias_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
    984 {
    985     AliasHandle itself = NULL;
    986     char *rawdata = NULL;
    987     int rawdatalen = 0;
    988     Handle h;
    989     static char *kw[] = {"itself", "rawdata", 0};
    990 
    991     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|O&s#", kw, Alias_Convert, &itself, &rawdata, &rawdatalen))
    992     return -1;
    993     if (itself && rawdata)
    994     {
    995         PyErr_SetString(PyExc_TypeError, "Only one of itself or rawdata may be specified");
    996         return -1;
    997     }
    998     if (!itself && !rawdata)
    999     {
   1000         PyErr_SetString(PyExc_TypeError, "One of itself or rawdata must be specified");
   1001         return -1;
   1002     }
   1003     if (rawdata)
   1004     {
   1005         if ((h = NewHandle(rawdatalen)) == NULL)
   1006         {
   1007             PyErr_NoMemory();
   1008             return -1;
   1009         }
   1010         HLock(h);
   1011         memcpy((char *)*h, rawdata, rawdatalen);
   1012         HUnlock(h);
   1013         ((AliasObject *)_self)->ob_itself = (AliasHandle)h;
   1014         return 0;
   1015     }
   1016     ((AliasObject *)_self)->ob_itself = itself;
   1017     return 0;
   1018 }
   1019 
   1020 #define Alias_tp_alloc PyType_GenericAlloc
   1021 
   1022 static PyObject *Alias_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
   1023 {
   1024     PyObject *self;
   1025 
   1026     if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
   1027     ((AliasObject *)self)->ob_itself = NULL;
   1028     return self;
   1029 }
   1030 
   1031 #define Alias_tp_free PyObject_Del
   1032 
   1033 
   1034 static PyTypeObject Alias_Type = {
   1035     PyObject_HEAD_INIT(NULL)
   1036     0, /*ob_size*/
   1037     "Carbon.File.Alias", /*tp_name*/
   1038     sizeof(AliasObject), /*tp_basicsize*/
   1039     0, /*tp_itemsize*/
   1040     /* methods */
   1041     (destructor) Alias_dealloc, /*tp_dealloc*/
   1042     0, /*tp_print*/
   1043     (getattrfunc)0, /*tp_getattr*/
   1044     (setattrfunc)0, /*tp_setattr*/
   1045     (cmpfunc) Alias_compare, /*tp_compare*/
   1046     (reprfunc) Alias_repr, /*tp_repr*/
   1047     (PyNumberMethods *)0, /* tp_as_number */
   1048     (PySequenceMethods *)0, /* tp_as_sequence */
   1049     (PyMappingMethods *)0, /* tp_as_mapping */
   1050     (hashfunc) Alias_hash, /*tp_hash*/
   1051     0, /*tp_call*/
   1052     0, /*tp_str*/
   1053     PyObject_GenericGetAttr, /*tp_getattro*/
   1054     PyObject_GenericSetAttr, /*tp_setattro */
   1055     0, /*tp_as_buffer*/
   1056     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
   1057     0, /*tp_doc*/
   1058     0, /*tp_traverse*/
   1059     0, /*tp_clear*/
   1060     0, /*tp_richcompare*/
   1061     0, /*tp_weaklistoffset*/
   1062     0, /*tp_iter*/
   1063     0, /*tp_iternext*/
   1064     Alias_methods, /* tp_methods */
   1065     0, /*tp_members*/
   1066     Alias_getsetlist, /*tp_getset*/
   1067     0, /*tp_base*/
   1068     0, /*tp_dict*/
   1069     0, /*tp_descr_get*/
   1070     0, /*tp_descr_set*/
   1071     0, /*tp_dictoffset*/
   1072     Alias_tp_init, /* tp_init */
   1073     Alias_tp_alloc, /* tp_alloc */
   1074     Alias_tp_new, /* tp_new */
   1075     Alias_tp_free, /* tp_free */
   1076 };
   1077 
   1078 /* --------------------- End object type Alias ---------------------- */
   1079 
   1080 
   1081 /* ----------------------- Object type FSSpec ----------------------- */
   1082 #ifndef __LP64__
   1083 
   1084 static PyTypeObject FSSpec_Type;
   1085 
   1086 #define FSSpec_Check(x) ((x)->ob_type == &FSSpec_Type || PyObject_TypeCheck((x), &FSSpec_Type))
   1087 
   1088 typedef struct FSSpecObject {
   1089     PyObject_HEAD
   1090     FSSpec ob_itself;
   1091 } FSSpecObject;
   1092 
   1093 static PyObject *FSSpec_New(FSSpec *itself)
   1094 {
   1095     FSSpecObject *it;
   1096     if (itself == NULL) return PyMac_Error(resNotFound);
   1097     it = PyObject_NEW(FSSpecObject, &FSSpec_Type);
   1098     if (it == NULL) return NULL;
   1099     it->ob_itself = *itself;
   1100     return (PyObject *)it;
   1101 }
   1102 
   1103 static void FSSpec_dealloc(FSSpecObject *self)
   1104 {
   1105     /* Cleanup of self->ob_itself goes here */
   1106     self->ob_type->tp_free((PyObject *)self);
   1107 }
   1108 
   1109 static PyObject *FSSpec_FSpOpenDF(FSSpecObject *_self, PyObject *_args)
   1110 {
   1111     PyObject *_res = NULL;
   1112     OSErr _err;
   1113     SInt8 permission;
   1114     short refNum;
   1115     if (!PyArg_ParseTuple(_args, "b",
   1116                           &permission))
   1117         return NULL;
   1118     _err = FSpOpenDF(&_self->ob_itself,
   1119                      permission,
   1120                      &refNum);
   1121     if (_err != noErr) return PyMac_Error(_err);
   1122     _res = Py_BuildValue("h",
   1123                          refNum);
   1124     return _res;
   1125 }
   1126 
   1127 static PyObject *FSSpec_FSpOpenRF(FSSpecObject *_self, PyObject *_args)
   1128 {
   1129     PyObject *_res = NULL;
   1130     OSErr _err;
   1131     SInt8 permission;
   1132     short refNum;
   1133     if (!PyArg_ParseTuple(_args, "b",
   1134                           &permission))
   1135         return NULL;
   1136     _err = FSpOpenRF(&_self->ob_itself,
   1137                      permission,
   1138                      &refNum);
   1139     if (_err != noErr) return PyMac_Error(_err);
   1140     _res = Py_BuildValue("h",
   1141                          refNum);
   1142     return _res;
   1143 }
   1144 
   1145 static PyObject *FSSpec_FSpCreate(FSSpecObject *_self, PyObject *_args)
   1146 {
   1147     PyObject *_res = NULL;
   1148     OSErr _err;
   1149     OSType creator;
   1150     OSType fileType;
   1151     ScriptCode scriptTag;
   1152     if (!PyArg_ParseTuple(_args, "O&O&h",
   1153                           PyMac_GetOSType, &creator,
   1154                           PyMac_GetOSType, &fileType,
   1155                           &scriptTag))
   1156         return NULL;
   1157     _err = FSpCreate(&_self->ob_itself,
   1158                      creator,
   1159                      fileType,
   1160                      scriptTag);
   1161     if (_err != noErr) return PyMac_Error(_err);
   1162     Py_INCREF(Py_None);
   1163     _res = Py_None;
   1164     return _res;
   1165 }
   1166 
   1167 static PyObject *FSSpec_FSpDirCreate(FSSpecObject *_self, PyObject *_args)
   1168 {
   1169     PyObject *_res = NULL;
   1170     OSErr _err;
   1171     ScriptCode scriptTag;
   1172     long createdDirID;
   1173     if (!PyArg_ParseTuple(_args, "h",
   1174                           &scriptTag))
   1175         return NULL;
   1176     _err = FSpDirCreate(&_self->ob_itself,
   1177                         scriptTag,
   1178                         &createdDirID);
   1179     if (_err != noErr) return PyMac_Error(_err);
   1180     _res = Py_BuildValue("l",
   1181                          createdDirID);
   1182     return _res;
   1183 }
   1184 
   1185 static PyObject *FSSpec_FSpDelete(FSSpecObject *_self, PyObject *_args)
   1186 {
   1187     PyObject *_res = NULL;
   1188     OSErr _err;
   1189     if (!PyArg_ParseTuple(_args, ""))
   1190         return NULL;
   1191     _err = FSpDelete(&_self->ob_itself);
   1192     if (_err != noErr) return PyMac_Error(_err);
   1193     Py_INCREF(Py_None);
   1194     _res = Py_None;
   1195     return _res;
   1196 }
   1197 
   1198 static PyObject *FSSpec_FSpGetFInfo(FSSpecObject *_self, PyObject *_args)
   1199 {
   1200     PyObject *_res = NULL;
   1201     OSErr _err;
   1202     FInfo fndrInfo;
   1203     if (!PyArg_ParseTuple(_args, ""))
   1204         return NULL;
   1205     _err = FSpGetFInfo(&_self->ob_itself,
   1206                        &fndrInfo);
   1207     if (_err != noErr) return PyMac_Error(_err);
   1208     _res = Py_BuildValue("O&",
   1209                          FInfo_New, &fndrInfo);
   1210     return _res;
   1211 }
   1212 
   1213 static PyObject *FSSpec_FSpSetFInfo(FSSpecObject *_self, PyObject *_args)
   1214 {
   1215     PyObject *_res = NULL;
   1216     OSErr _err;
   1217     FInfo fndrInfo;
   1218     if (!PyArg_ParseTuple(_args, "O&",
   1219                           FInfo_Convert, &fndrInfo))
   1220         return NULL;
   1221     _err = FSpSetFInfo(&_self->ob_itself,
   1222                        &fndrInfo);
   1223     if (_err != noErr) return PyMac_Error(_err);
   1224     Py_INCREF(Py_None);
   1225     _res = Py_None;
   1226     return _res;
   1227 }
   1228 
   1229 static PyObject *FSSpec_FSpSetFLock(FSSpecObject *_self, PyObject *_args)
   1230 {
   1231     PyObject *_res = NULL;
   1232     OSErr _err;
   1233     if (!PyArg_ParseTuple(_args, ""))
   1234         return NULL;
   1235     _err = FSpSetFLock(&_self->ob_itself);
   1236     if (_err != noErr) return PyMac_Error(_err);
   1237     Py_INCREF(Py_None);
   1238     _res = Py_None;
   1239     return _res;
   1240 }
   1241 
   1242 static PyObject *FSSpec_FSpRstFLock(FSSpecObject *_self, PyObject *_args)
   1243 {
   1244     PyObject *_res = NULL;
   1245     OSErr _err;
   1246     if (!PyArg_ParseTuple(_args, ""))
   1247         return NULL;
   1248     _err = FSpRstFLock(&_self->ob_itself);
   1249     if (_err != noErr) return PyMac_Error(_err);
   1250     Py_INCREF(Py_None);
   1251     _res = Py_None;
   1252     return _res;
   1253 }
   1254 
   1255 static PyObject *FSSpec_FSpRename(FSSpecObject *_self, PyObject *_args)
   1256 {
   1257     PyObject *_res = NULL;
   1258     OSErr _err;
   1259     Str255 newName;
   1260     if (!PyArg_ParseTuple(_args, "O&",
   1261                           PyMac_GetStr255, newName))
   1262         return NULL;
   1263     _err = FSpRename(&_self->ob_itself,
   1264                      newName);
   1265     if (_err != noErr) return PyMac_Error(_err);
   1266     Py_INCREF(Py_None);
   1267     _res = Py_None;
   1268     return _res;
   1269 }
   1270 
   1271 static PyObject *FSSpec_FSpCatMove(FSSpecObject *_self, PyObject *_args)
   1272 {
   1273     PyObject *_res = NULL;
   1274     OSErr _err;
   1275     FSSpec dest;
   1276     if (!PyArg_ParseTuple(_args, "O&",
   1277                           FSSpec_Convert, &dest))
   1278         return NULL;
   1279     _err = FSpCatMove(&_self->ob_itself,
   1280                       &dest);
   1281     if (_err != noErr) return PyMac_Error(_err);
   1282     Py_INCREF(Py_None);
   1283     _res = Py_None;
   1284     return _res;
   1285 }
   1286 
   1287 static PyObject *FSSpec_FSpExchangeFiles(FSSpecObject *_self, PyObject *_args)
   1288 {
   1289     PyObject *_res = NULL;
   1290     OSErr _err;
   1291     FSSpec dest;
   1292     if (!PyArg_ParseTuple(_args, "O&",
   1293                           FSSpec_Convert, &dest))
   1294         return NULL;
   1295     _err = FSpExchangeFiles(&_self->ob_itself,
   1296                             &dest);
   1297     if (_err != noErr) return PyMac_Error(_err);
   1298     Py_INCREF(Py_None);
   1299     _res = Py_None;
   1300     return _res;
   1301 }
   1302 
   1303 static PyObject *FSSpec_FSpMakeFSRef(FSSpecObject *_self, PyObject *_args)
   1304 {
   1305     PyObject *_res = NULL;
   1306     OSErr _err;
   1307     FSRef newRef;
   1308     if (!PyArg_ParseTuple(_args, ""))
   1309         return NULL;
   1310     _err = FSpMakeFSRef(&_self->ob_itself,
   1311                         &newRef);
   1312     if (_err != noErr) return PyMac_Error(_err);
   1313     _res = Py_BuildValue("O&",
   1314                          FSRef_New, &newRef);
   1315     return _res;
   1316 }
   1317 
   1318 static PyObject *FSSpec_NewAliasMinimal(FSSpecObject *_self, PyObject *_args)
   1319 {
   1320     PyObject *_res = NULL;
   1321     OSErr _err;
   1322     AliasHandle alias;
   1323     if (!PyArg_ParseTuple(_args, ""))
   1324         return NULL;
   1325     _err = NewAliasMinimal(&_self->ob_itself,
   1326                            &alias);
   1327     if (_err != noErr) return PyMac_Error(_err);
   1328     _res = Py_BuildValue("O&",
   1329                          Alias_New, alias);
   1330     return _res;
   1331 }
   1332 
   1333 static PyObject *FSSpec_IsAliasFile(FSSpecObject *_self, PyObject *_args)
   1334 {
   1335     PyObject *_res = NULL;
   1336     OSErr _err;
   1337     Boolean aliasFileFlag;
   1338     Boolean folderFlag;
   1339     if (!PyArg_ParseTuple(_args, ""))
   1340         return NULL;
   1341     _err = IsAliasFile(&_self->ob_itself,
   1342                        &aliasFileFlag,
   1343                        &folderFlag);
   1344     if (_err != noErr) return PyMac_Error(_err);
   1345     _res = Py_BuildValue("bb",
   1346                          aliasFileFlag,
   1347                          folderFlag);
   1348     return _res;
   1349 }
   1350 
   1351 static PyObject *FSSpec_as_pathname(FSSpecObject *_self, PyObject *_args)
   1352 {
   1353     PyObject *_res = NULL;
   1354 
   1355     char strbuf[1024];
   1356     OSErr err;
   1357 
   1358     if (!PyArg_ParseTuple(_args, ""))
   1359         return NULL;
   1360     err = _PyMac_GetFullPathname(&_self->ob_itself, strbuf, sizeof(strbuf));
   1361     if ( err ) {
   1362         PyMac_Error(err);
   1363         return NULL;
   1364     }
   1365     _res = PyString_FromString(strbuf);
   1366     return _res;
   1367 
   1368 }
   1369 
   1370 static PyObject *FSSpec_as_tuple(FSSpecObject *_self, PyObject *_args)
   1371 {
   1372     PyObject *_res = NULL;
   1373 
   1374     if (!PyArg_ParseTuple(_args, ""))
   1375         return NULL;
   1376     _res = Py_BuildValue("(iis#)", _self->ob_itself.vRefNum, _self->ob_itself.parID,
   1377                                             &_self->ob_itself.name[1], _self->ob_itself.name[0]);
   1378     return _res;
   1379 
   1380 }
   1381 
   1382 static PyMethodDef FSSpec_methods[] = {
   1383     {"FSpOpenDF", (PyCFunction)FSSpec_FSpOpenDF, 1,
   1384      PyDoc_STR("(SInt8 permission) -> (short refNum)")},
   1385     {"FSpOpenRF", (PyCFunction)FSSpec_FSpOpenRF, 1,
   1386      PyDoc_STR("(SInt8 permission) -> (short refNum)")},
   1387     {"FSpCreate", (PyCFunction)FSSpec_FSpCreate, 1,
   1388      PyDoc_STR("(OSType creator, OSType fileType, ScriptCode scriptTag) -> None")},
   1389     {"FSpDirCreate", (PyCFunction)FSSpec_FSpDirCreate, 1,
   1390      PyDoc_STR("(ScriptCode scriptTag) -> (long createdDirID)")},
   1391     {"FSpDelete", (PyCFunction)FSSpec_FSpDelete, 1,
   1392      PyDoc_STR("() -> None")},
   1393     {"FSpGetFInfo", (PyCFunction)FSSpec_FSpGetFInfo, 1,
   1394      PyDoc_STR("() -> (FInfo fndrInfo)")},
   1395     {"FSpSetFInfo", (PyCFunction)FSSpec_FSpSetFInfo, 1,
   1396      PyDoc_STR("(FInfo fndrInfo) -> None")},
   1397     {"FSpSetFLock", (PyCFunction)FSSpec_FSpSetFLock, 1,
   1398      PyDoc_STR("() -> None")},
   1399     {"FSpRstFLock", (PyCFunction)FSSpec_FSpRstFLock, 1,
   1400      PyDoc_STR("() -> None")},
   1401     {"FSpRename", (PyCFunction)FSSpec_FSpRename, 1,
   1402      PyDoc_STR("(Str255 newName) -> None")},
   1403     {"FSpCatMove", (PyCFunction)FSSpec_FSpCatMove, 1,
   1404      PyDoc_STR("(FSSpec dest) -> None")},
   1405     {"FSpExchangeFiles", (PyCFunction)FSSpec_FSpExchangeFiles, 1,
   1406      PyDoc_STR("(FSSpec dest) -> None")},
   1407     {"FSpMakeFSRef", (PyCFunction)FSSpec_FSpMakeFSRef, 1,
   1408      PyDoc_STR("() -> (FSRef newRef)")},
   1409     {"NewAliasMinimal", (PyCFunction)FSSpec_NewAliasMinimal, 1,
   1410      PyDoc_STR("() -> (AliasHandle alias)")},
   1411     {"IsAliasFile", (PyCFunction)FSSpec_IsAliasFile, 1,
   1412      PyDoc_STR("() -> (Boolean aliasFileFlag, Boolean folderFlag)")},
   1413     {"as_pathname", (PyCFunction)FSSpec_as_pathname, 1,
   1414      PyDoc_STR("() -> string")},
   1415     {"as_tuple", (PyCFunction)FSSpec_as_tuple, 1,
   1416      PyDoc_STR("() -> (vRefNum, dirID, name)")},
   1417     {NULL, NULL, 0}
   1418 };
   1419 
   1420 static PyObject *FSSpec_get_data(FSSpecObject *self, void *closure)
   1421 {
   1422     return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));
   1423 }
   1424 
   1425 #define FSSpec_set_data NULL
   1426 
   1427 static PyGetSetDef FSSpec_getsetlist[] = {
   1428     {"data", (getter)FSSpec_get_data, (setter)FSSpec_set_data, "Raw data of the FSSpec object"},
   1429     {NULL, NULL, NULL, NULL},
   1430 };
   1431 
   1432 
   1433 #define FSSpec_compare NULL
   1434 
   1435 static PyObject * FSSpec_repr(FSSpecObject *self)
   1436 {
   1437     char buf[512];
   1438     PyOS_snprintf(buf, sizeof(buf), "%s((%d, %ld, '%.*s'))",
   1439         self->ob_type->tp_name,
   1440         self->ob_itself.vRefNum,
   1441         self->ob_itself.parID,
   1442         self->ob_itself.name[0], self->ob_itself.name+1);
   1443     return PyString_FromString(buf);
   1444 }
   1445 
   1446 #define FSSpec_hash NULL
   1447 static int FSSpec_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
   1448 {
   1449     PyObject *v = NULL;
   1450     char *rawdata = NULL;
   1451     int rawdatalen = 0;
   1452     static char *kw[] = {"itself", "rawdata", 0};
   1453 
   1454     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|Os#", kw, &v, &rawdata, &rawdatalen))
   1455     return -1;
   1456     if (v && rawdata)
   1457     {
   1458         PyErr_SetString(PyExc_TypeError, "Only one of itself or rawdata may be specified");
   1459         return -1;
   1460     }
   1461     if (!v && !rawdata)
   1462     {
   1463         PyErr_SetString(PyExc_TypeError, "One of itself or rawdata must be specified");
   1464         return -1;
   1465     }
   1466     if (rawdata)
   1467     {
   1468         if (rawdatalen != sizeof(FSSpec))
   1469         {
   1470             PyErr_SetString(PyExc_TypeError, "FSSpec rawdata incorrect size");
   1471             return -1;
   1472         }
   1473         memcpy(&((FSSpecObject *)_self)->ob_itself, rawdata, rawdatalen);
   1474         return 0;
   1475     }
   1476     if (PyMac_GetFSSpec(v, &((FSSpecObject *)_self)->ob_itself)) return 0;
   1477     return -1;
   1478 }
   1479 
   1480 #define FSSpec_tp_alloc PyType_GenericAlloc
   1481 
   1482 static PyObject *FSSpec_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
   1483 {
   1484     PyObject *self;
   1485 
   1486     if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
   1487     memset(&((FSSpecObject *)self)->ob_itself, 0, sizeof(FSSpec));
   1488     return self;
   1489 }
   1490 
   1491 #define FSSpec_tp_free PyObject_Del
   1492 
   1493 
   1494 static PyTypeObject FSSpec_Type = {
   1495     PyObject_HEAD_INIT(NULL)
   1496     0, /*ob_size*/
   1497     "Carbon.File.FSSpec", /*tp_name*/
   1498     sizeof(FSSpecObject), /*tp_basicsize*/
   1499     0, /*tp_itemsize*/
   1500     /* methods */
   1501     (destructor) FSSpec_dealloc, /*tp_dealloc*/
   1502     0, /*tp_print*/
   1503     (getattrfunc)0, /*tp_getattr*/
   1504     (setattrfunc)0, /*tp_setattr*/
   1505     (cmpfunc) FSSpec_compare, /*tp_compare*/
   1506     (reprfunc) FSSpec_repr, /*tp_repr*/
   1507     (PyNumberMethods *)0, /* tp_as_number */
   1508     (PySequenceMethods *)0, /* tp_as_sequence */
   1509     (PyMappingMethods *)0, /* tp_as_mapping */
   1510     (hashfunc) FSSpec_hash, /*tp_hash*/
   1511     0, /*tp_call*/
   1512     0, /*tp_str*/
   1513     PyObject_GenericGetAttr, /*tp_getattro*/
   1514     PyObject_GenericSetAttr, /*tp_setattro */
   1515     0, /*tp_as_buffer*/
   1516     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
   1517     0, /*tp_doc*/
   1518     0, /*tp_traverse*/
   1519     0, /*tp_clear*/
   1520     0, /*tp_richcompare*/
   1521     0, /*tp_weaklistoffset*/
   1522     0, /*tp_iter*/
   1523     0, /*tp_iternext*/
   1524     FSSpec_methods, /* tp_methods */
   1525     0, /*tp_members*/
   1526     FSSpec_getsetlist, /*tp_getset*/
   1527     0, /*tp_base*/
   1528     0, /*tp_dict*/
   1529     0, /*tp_descr_get*/
   1530     0, /*tp_descr_set*/
   1531     0, /*tp_dictoffset*/
   1532     FSSpec_tp_init, /* tp_init */
   1533     FSSpec_tp_alloc, /* tp_alloc */
   1534     FSSpec_tp_new, /* tp_new */
   1535     FSSpec_tp_free, /* tp_free */
   1536 };
   1537 
   1538 #endif /* !__LP64__ */
   1539 /* --------------------- End object type FSSpec --------------------- */
   1540 
   1541 
   1542 /* ----------------------- Object type FSRef ------------------------ */
   1543 
   1544 static PyTypeObject FSRef_Type;
   1545 
   1546 #define FSRef_Check(x) ((x)->ob_type == &FSRef_Type || PyObject_TypeCheck((x), &FSRef_Type))
   1547 
   1548 typedef struct FSRefObject {
   1549     PyObject_HEAD
   1550     FSRef ob_itself;
   1551 } FSRefObject;
   1552 
   1553 static PyObject *FSRef_New(FSRef *itself)
   1554 {
   1555     FSRefObject *it;
   1556     if (itself == NULL) return PyMac_Error(resNotFound);
   1557     it = PyObject_NEW(FSRefObject, &FSRef_Type);
   1558     if (it == NULL) return NULL;
   1559     it->ob_itself = *itself;
   1560     return (PyObject *)it;
   1561 }
   1562 
   1563 static void FSRef_dealloc(FSRefObject *self)
   1564 {
   1565     /* Cleanup of self->ob_itself goes here */
   1566     self->ob_type->tp_free((PyObject *)self);
   1567 }
   1568 
   1569 static PyObject *FSRef_FSMakeFSRefUnicode(FSRefObject *_self, PyObject *_args)
   1570 {
   1571     PyObject *_res = NULL;
   1572     OSErr _err;
   1573     UniChar *nameLength__in__;
   1574     UniCharCount nameLength__len__;
   1575     int nameLength__in_len__;
   1576     TextEncoding textEncodingHint;
   1577     FSRef newRef;
   1578     if (!PyArg_ParseTuple(_args, "u#l",
   1579                           &nameLength__in__, &nameLength__in_len__,
   1580                           &textEncodingHint))
   1581         return NULL;
   1582     nameLength__len__ = nameLength__in_len__;
   1583     _err = FSMakeFSRefUnicode(&_self->ob_itself,
   1584                               nameLength__len__, nameLength__in__,
   1585                               textEncodingHint,
   1586                               &newRef);
   1587     if (_err != noErr) return PyMac_Error(_err);
   1588     _res = Py_BuildValue("O&",
   1589                          FSRef_New, &newRef);
   1590     return _res;
   1591 }
   1592 
   1593 static PyObject *FSRef_FSCompareFSRefs(FSRefObject *_self, PyObject *_args)
   1594 {
   1595     PyObject *_res = NULL;
   1596     OSErr _err;
   1597     FSRef ref2;
   1598     if (!PyArg_ParseTuple(_args, "O&",
   1599                           FSRef_Convert, &ref2))
   1600         return NULL;
   1601     _err = FSCompareFSRefs(&_self->ob_itself,
   1602                            &ref2);
   1603     if (_err != noErr) return PyMac_Error(_err);
   1604     Py_INCREF(Py_None);
   1605     _res = Py_None;
   1606     return _res;
   1607 }
   1608 
   1609 static PyObject *FSRef_FSCreateFileUnicode(FSRefObject *_self, PyObject *_args)
   1610 {
   1611     PyObject *_res = NULL;
   1612     OSErr _err;
   1613     UniChar *nameLength__in__;
   1614     UniCharCount nameLength__len__;
   1615     int nameLength__in_len__;
   1616     FSCatalogInfoBitmap whichInfo;
   1617     FSCatalogInfo catalogInfo;
   1618     FSRef newRef;
   1619 #ifndef __LP64__
   1620     FSSpec newSpec;
   1621 #endif
   1622     if (!PyArg_ParseTuple(_args, "u#lO&",
   1623                           &nameLength__in__, &nameLength__in_len__,
   1624                           &whichInfo,
   1625                           FSCatalogInfo_Convert, &catalogInfo))
   1626         return NULL;
   1627     nameLength__len__ = nameLength__in_len__;
   1628     _err = FSCreateFileUnicode(&_self->ob_itself,
   1629                                nameLength__len__, nameLength__in__,
   1630                                whichInfo,
   1631                                &catalogInfo,
   1632                                &newRef,
   1633 #ifndef __LP64__
   1634                                &newSpec
   1635 #else   /* __LP64__ */
   1636                                NULL
   1637 #endif /* __LP64__*/
   1638                               );
   1639     if (_err != noErr) return PyMac_Error(_err);
   1640 
   1641 #ifndef __LP64__
   1642     _res = Py_BuildValue("O&O&",
   1643                          FSRef_New, &newRef,
   1644                          FSSpec_New, &newSpec);
   1645 #else /* __LP64__ */
   1646     _res = Py_BuildValue("O&O", FSRef_New, &newRef, Py_None);
   1647 #endif /* __LP64__ */
   1648 
   1649     return _res;
   1650 }
   1651 
   1652 static PyObject *FSRef_FSCreateDirectoryUnicode(FSRefObject *_self, PyObject *_args)
   1653 {
   1654     PyObject *_res = NULL;
   1655     OSErr _err;
   1656     UniChar *nameLength__in__;
   1657     UniCharCount nameLength__len__;
   1658     int nameLength__in_len__;
   1659     FSCatalogInfoBitmap whichInfo;
   1660     FSCatalogInfo catalogInfo;
   1661     FSRef newRef;
   1662 #ifndef __LP64__
   1663     FSSpec newSpec;
   1664 #endif /* !__LP64__ */
   1665     UInt32 newDirID;
   1666     if (!PyArg_ParseTuple(_args, "u#lO&",
   1667                           &nameLength__in__, &nameLength__in_len__,
   1668                           &whichInfo,
   1669                           FSCatalogInfo_Convert, &catalogInfo))
   1670         return NULL;
   1671     nameLength__len__ = nameLength__in_len__;
   1672     _err = FSCreateDirectoryUnicode(&_self->ob_itself,
   1673                                     nameLength__len__, nameLength__in__,
   1674                                     whichInfo,
   1675                                     &catalogInfo,
   1676                                     &newRef,
   1677 #ifndef __LP64__
   1678                                     &newSpec,
   1679 #else /* !__LP64__ */
   1680                                     NULL,
   1681 #endif /* !__LP64__ */
   1682                                     &newDirID);
   1683     if (_err != noErr) return PyMac_Error(_err);
   1684 
   1685 #ifndef __LP64__
   1686     _res = Py_BuildValue("O&O&l",
   1687                          FSRef_New, &newRef,
   1688                          FSSpec_New, &newSpec,
   1689                          newDirID);
   1690 #else   /* __LP64__ */
   1691     _res = Py_BuildValue("O&Ol",
   1692                          FSRef_New, &newRef,
   1693                          Py_None,
   1694                          newDirID);
   1695 #endif /* __LP64__ */
   1696     return _res;
   1697 }
   1698 
   1699 static PyObject *FSRef_FSDeleteObject(FSRefObject *_self, PyObject *_args)
   1700 {
   1701     PyObject *_res = NULL;
   1702     OSErr _err;
   1703     if (!PyArg_ParseTuple(_args, ""))
   1704         return NULL;
   1705     _err = FSDeleteObject(&_self->ob_itself);
   1706     if (_err != noErr) return PyMac_Error(_err);
   1707     Py_INCREF(Py_None);
   1708     _res = Py_None;
   1709     return _res;
   1710 }
   1711 
   1712 static PyObject *FSRef_FSMoveObject(FSRefObject *_self, PyObject *_args)
   1713 {
   1714     PyObject *_res = NULL;
   1715     OSErr _err;
   1716     FSRef destDirectory;
   1717     FSRef newRef;
   1718     if (!PyArg_ParseTuple(_args, "O&",
   1719                           FSRef_Convert, &destDirectory))
   1720         return NULL;
   1721     _err = FSMoveObject(&_self->ob_itself,
   1722                         &destDirectory,
   1723                         &newRef);
   1724     if (_err != noErr) return PyMac_Error(_err);
   1725     _res = Py_BuildValue("O&",
   1726                          FSRef_New, &newRef);
   1727     return _res;
   1728 }
   1729 
   1730 static PyObject *FSRef_FSExchangeObjects(FSRefObject *_self, PyObject *_args)
   1731 {
   1732     PyObject *_res = NULL;
   1733     OSErr _err;
   1734     FSRef destRef;
   1735     if (!PyArg_ParseTuple(_args, "O&",
   1736                           FSRef_Convert, &destRef))
   1737         return NULL;
   1738     _err = FSExchangeObjects(&_self->ob_itself,
   1739                              &destRef);
   1740     if (_err != noErr) return PyMac_Error(_err);
   1741     Py_INCREF(Py_None);
   1742     _res = Py_None;
   1743     return _res;
   1744 }
   1745 
   1746 static PyObject *FSRef_FSRenameUnicode(FSRefObject *_self, PyObject *_args)
   1747 {
   1748     PyObject *_res = NULL;
   1749     OSErr _err;
   1750     UniChar *nameLength__in__;
   1751     UniCharCount nameLength__len__;
   1752     int nameLength__in_len__;
   1753     TextEncoding textEncodingHint;
   1754     FSRef newRef;
   1755     if (!PyArg_ParseTuple(_args, "u#l",
   1756                           &nameLength__in__, &nameLength__in_len__,
   1757                           &textEncodingHint))
   1758         return NULL;
   1759     nameLength__len__ = nameLength__in_len__;
   1760     _err = FSRenameUnicode(&_self->ob_itself,
   1761                            nameLength__len__, nameLength__in__,
   1762                            textEncodingHint,
   1763                            &newRef);
   1764     if (_err != noErr) return PyMac_Error(_err);
   1765     _res = Py_BuildValue("O&",
   1766                          FSRef_New, &newRef);
   1767     return _res;
   1768 }
   1769 
   1770 static PyObject *FSRef_FSGetCatalogInfo(FSRefObject *_self, PyObject *_args)
   1771 {
   1772     PyObject *_res = NULL;
   1773     OSErr _err;
   1774     FSCatalogInfoBitmap whichInfo;
   1775     FSCatalogInfo catalogInfo;
   1776     HFSUniStr255 outName;
   1777 #ifndef __LP64__
   1778     FSSpec fsSpec;
   1779 #endif /* !__LP64__ */
   1780     FSRef parentRef;
   1781     if (!PyArg_ParseTuple(_args, "l",
   1782                           &whichInfo))
   1783         return NULL;
   1784     _err = FSGetCatalogInfo(&_self->ob_itself,
   1785                             whichInfo,
   1786                             &catalogInfo,
   1787                             &outName,
   1788 #ifndef __LP64__
   1789                             &fsSpec,
   1790 #else   /* __LP64__ */
   1791                             NULL,
   1792 #endif /* __LP64__ */
   1793                             &parentRef);
   1794     if (_err != noErr) return PyMac_Error(_err);
   1795 
   1796 #ifndef __LP64__
   1797     _res = Py_BuildValue("O&O&O&O&",
   1798                          FSCatalogInfo_New, &catalogInfo,
   1799                          PyMac_BuildHFSUniStr255, &outName,
   1800                          FSSpec_New, &fsSpec,
   1801                          FSRef_New, &parentRef);
   1802 #else   /* __LP64__ */
   1803     _res = Py_BuildValue("O&O&OO&",
   1804                          FSCatalogInfo_New, &catalogInfo,
   1805                          PyMac_BuildHFSUniStr255, &outName,
   1806                          Py_None,
   1807                          FSRef_New, &parentRef);
   1808 #endif /* __LP64__ */
   1809     return _res;
   1810 }
   1811 
   1812 static PyObject *FSRef_FSSetCatalogInfo(FSRefObject *_self, PyObject *_args)
   1813 {
   1814     PyObject *_res = NULL;
   1815     OSErr _err;
   1816     FSCatalogInfoBitmap whichInfo;
   1817     FSCatalogInfo catalogInfo;
   1818     if (!PyArg_ParseTuple(_args, "lO&",
   1819                           &whichInfo,
   1820                           FSCatalogInfo_Convert, &catalogInfo))
   1821         return NULL;
   1822     _err = FSSetCatalogInfo(&_self->ob_itself,
   1823                             whichInfo,
   1824                             &catalogInfo);
   1825     if (_err != noErr) return PyMac_Error(_err);
   1826     Py_INCREF(Py_None);
   1827     _res = Py_None;
   1828     return _res;
   1829 }
   1830 
   1831 static PyObject *FSRef_FSCreateFork(FSRefObject *_self, PyObject *_args)
   1832 {
   1833     PyObject *_res = NULL;
   1834     OSErr _err;
   1835     UniChar *forkNameLength__in__;
   1836     UniCharCount forkNameLength__len__;
   1837     int forkNameLength__in_len__;
   1838     if (!PyArg_ParseTuple(_args, "u#",
   1839                           &forkNameLength__in__, &forkNameLength__in_len__))
   1840         return NULL;
   1841     forkNameLength__len__ = forkNameLength__in_len__;
   1842     _err = FSCreateFork(&_self->ob_itself,
   1843                         forkNameLength__len__, forkNameLength__in__);
   1844     if (_err != noErr) return PyMac_Error(_err);
   1845     Py_INCREF(Py_None);
   1846     _res = Py_None;
   1847     return _res;
   1848 }
   1849 
   1850 static PyObject *FSRef_FSDeleteFork(FSRefObject *_self, PyObject *_args)
   1851 {
   1852     PyObject *_res = NULL;
   1853     OSErr _err;
   1854     UniChar *forkNameLength__in__;
   1855     UniCharCount forkNameLength__len__;
   1856     int forkNameLength__in_len__;
   1857     if (!PyArg_ParseTuple(_args, "u#",
   1858                           &forkNameLength__in__, &forkNameLength__in_len__))
   1859         return NULL;
   1860     forkNameLength__len__ = forkNameLength__in_len__;
   1861     _err = FSDeleteFork(&_self->ob_itself,
   1862                         forkNameLength__len__, forkNameLength__in__);
   1863     if (_err != noErr) return PyMac_Error(_err);
   1864     Py_INCREF(Py_None);
   1865     _res = Py_None;
   1866     return _res;
   1867 }
   1868 
   1869 static PyObject *FSRef_FSOpenFork(FSRefObject *_self, PyObject *_args)
   1870 {
   1871     PyObject *_res = NULL;
   1872     OSErr _err;
   1873     UniChar *forkNameLength__in__;
   1874     UniCharCount forkNameLength__len__;
   1875     int forkNameLength__in_len__;
   1876     SInt8 permissions;
   1877     FSIORefNum forkRefNum;
   1878     if (!PyArg_ParseTuple(_args, "u#b",
   1879                           &forkNameLength__in__, &forkNameLength__in_len__,
   1880                           &permissions))
   1881         return NULL;
   1882     forkNameLength__len__ = forkNameLength__in_len__;
   1883     _err = FSOpenFork(&_self->ob_itself,
   1884                       forkNameLength__len__, forkNameLength__in__,
   1885                       permissions,
   1886                       &forkRefNum);
   1887     if (_err != noErr) return PyMac_Error(_err);
   1888     _res = Py_BuildValue("h",
   1889                          forkRefNum);
   1890     return _res;
   1891 }
   1892 
   1893 static PyObject *FSRef_FNNotify(FSRefObject *_self, PyObject *_args)
   1894 {
   1895     PyObject *_res = NULL;
   1896     OSStatus _err;
   1897     FNMessage message;
   1898     OptionBits flags;
   1899     if (!PyArg_ParseTuple(_args, "ll",
   1900                           &message,
   1901                           &flags))
   1902         return NULL;
   1903     _err = FNNotify(&_self->ob_itself,
   1904                     message,
   1905                     flags);
   1906     if (_err != noErr) return PyMac_Error(_err);
   1907     Py_INCREF(Py_None);
   1908     _res = Py_None;
   1909     return _res;
   1910 }
   1911 
   1912 static PyObject *FSRef_FSNewAliasMinimal(FSRefObject *_self, PyObject *_args)
   1913 {
   1914     PyObject *_res = NULL;
   1915     OSErr _err;
   1916     AliasHandle inAlias;
   1917     if (!PyArg_ParseTuple(_args, ""))
   1918         return NULL;
   1919     _err = FSNewAliasMinimal(&_self->ob_itself,
   1920                              &inAlias);
   1921     if (_err != noErr) return PyMac_Error(_err);
   1922     _res = Py_BuildValue("O&",
   1923                          Alias_New, inAlias);
   1924     return _res;
   1925 }
   1926 
   1927 static PyObject *FSRef_FSIsAliasFile(FSRefObject *_self, PyObject *_args)
   1928 {
   1929     PyObject *_res = NULL;
   1930     OSErr _err;
   1931     Boolean aliasFileFlag;
   1932     Boolean folderFlag;
   1933     if (!PyArg_ParseTuple(_args, ""))
   1934         return NULL;
   1935     _err = FSIsAliasFile(&_self->ob_itself,
   1936                          &aliasFileFlag,
   1937                          &folderFlag);
   1938     if (_err != noErr) return PyMac_Error(_err);
   1939     _res = Py_BuildValue("bb",
   1940                          aliasFileFlag,
   1941                          folderFlag);
   1942     return _res;
   1943 }
   1944 
   1945 static PyObject *FSRef_FSRefMakePath(FSRefObject *_self, PyObject *_args)
   1946 {
   1947     PyObject *_res = NULL;
   1948 
   1949     OSStatus _err;
   1950 #define MAXPATHNAME 1024
   1951     UInt8 path[MAXPATHNAME];
   1952     UInt32 maxPathSize = MAXPATHNAME;
   1953 
   1954     if (!PyArg_ParseTuple(_args, ""))
   1955         return NULL;
   1956     _err = FSRefMakePath(&_self->ob_itself,
   1957                                              path,
   1958                                              maxPathSize);
   1959     if (_err != noErr) return PyMac_Error(_err);
   1960     _res = Py_BuildValue("s", path);
   1961     return _res;
   1962 
   1963 }
   1964 
   1965 static PyObject *FSRef_as_pathname(FSRefObject *_self, PyObject *_args)
   1966 {
   1967     PyObject *_res = NULL;
   1968 
   1969     if (!PyArg_ParseTuple(_args, ""))
   1970         return NULL;
   1971     _res = FSRef_FSRefMakePath(_self, _args);
   1972     return _res;
   1973 
   1974 }
   1975 
   1976 static PyMethodDef FSRef_methods[] = {
   1977     {"FSMakeFSRefUnicode", (PyCFunction)FSRef_FSMakeFSRefUnicode, 1,
   1978      PyDoc_STR("(Buffer nameLength, TextEncoding textEncodingHint) -> (FSRef newRef)")},
   1979     {"FSCompareFSRefs", (PyCFunction)FSRef_FSCompareFSRefs, 1,
   1980      PyDoc_STR("(FSRef ref2) -> None")},
   1981     {"FSCreateFileUnicode", (PyCFunction)FSRef_FSCreateFileUnicode, 1,
   1982      PyDoc_STR("(Buffer nameLength, FSCatalogInfoBitmap whichInfo, FSCatalogInfo catalogInfo) -> (FSRef newRef, FSSpec newSpec)")},
   1983     {"FSCreateDirectoryUnicode", (PyCFunction)FSRef_FSCreateDirectoryUnicode, 1,
   1984      PyDoc_STR("(Buffer nameLength, FSCatalogInfoBitmap whichInfo, FSCatalogInfo catalogInfo) -> (FSRef newRef, FSSpec newSpec, UInt32 newDirID)")},
   1985     {"FSDeleteObject", (PyCFunction)FSRef_FSDeleteObject, 1,
   1986      PyDoc_STR("() -> None")},
   1987     {"FSMoveObject", (PyCFunction)FSRef_FSMoveObject, 1,
   1988      PyDoc_STR("(FSRef destDirectory) -> (FSRef newRef)")},
   1989     {"FSExchangeObjects", (PyCFunction)FSRef_FSExchangeObjects, 1,
   1990      PyDoc_STR("(FSRef destRef) -> None")},
   1991     {"FSRenameUnicode", (PyCFunction)FSRef_FSRenameUnicode, 1,
   1992      PyDoc_STR("(Buffer nameLength, TextEncoding textEncodingHint) -> (FSRef newRef)")},
   1993     {"FSGetCatalogInfo", (PyCFunction)FSRef_FSGetCatalogInfo, 1,
   1994      PyDoc_STR("(FSCatalogInfoBitmap whichInfo) -> (FSCatalogInfo catalogInfo, HFSUniStr255 outName, FSSpec fsSpec, FSRef parentRef)")},
   1995     {"FSSetCatalogInfo", (PyCFunction)FSRef_FSSetCatalogInfo, 1,
   1996      PyDoc_STR("(FSCatalogInfoBitmap whichInfo, FSCatalogInfo catalogInfo) -> None")},
   1997     {"FSCreateFork", (PyCFunction)FSRef_FSCreateFork, 1,
   1998      PyDoc_STR("(Buffer forkNameLength) -> None")},
   1999     {"FSDeleteFork", (PyCFunction)FSRef_FSDeleteFork, 1,
   2000      PyDoc_STR("(Buffer forkNameLength) -> None")},
   2001     {"FSOpenFork", (PyCFunction)FSRef_FSOpenFork, 1,
   2002      PyDoc_STR("(Buffer forkNameLength, SInt8 permissions) -> (SInt16 forkRefNum)")},
   2003     {"FNNotify", (PyCFunction)FSRef_FNNotify, 1,
   2004      PyDoc_STR("(FNMessage message, OptionBits flags) -> None")},
   2005     {"FSNewAliasMinimal", (PyCFunction)FSRef_FSNewAliasMinimal, 1,
   2006      PyDoc_STR("() -> (AliasHandle inAlias)")},
   2007     {"FSIsAliasFile", (PyCFunction)FSRef_FSIsAliasFile, 1,
   2008      PyDoc_STR("() -> (Boolean aliasFileFlag, Boolean folderFlag)")},
   2009     {"FSRefMakePath", (PyCFunction)FSRef_FSRefMakePath, 1,
   2010      PyDoc_STR("() -> string")},
   2011     {"as_pathname", (PyCFunction)FSRef_as_pathname, 1,
   2012      PyDoc_STR("() -> string")},
   2013     {NULL, NULL, 0}
   2014 };
   2015 
   2016 static PyObject *FSRef_get_data(FSRefObject *self, void *closure)
   2017 {
   2018     return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));
   2019 }
   2020 
   2021 #define FSRef_set_data NULL
   2022 
   2023 static PyGetSetDef FSRef_getsetlist[] = {
   2024     {"data", (getter)FSRef_get_data, (setter)FSRef_set_data, "Raw data of the FSRef object"},
   2025     {NULL, NULL, NULL, NULL},
   2026 };
   2027 
   2028 
   2029 #define FSRef_compare NULL
   2030 
   2031 #define FSRef_repr NULL
   2032 
   2033 #define FSRef_hash NULL
   2034 static int FSRef_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
   2035 {
   2036     PyObject *v = NULL;
   2037     char *rawdata = NULL;
   2038     int rawdatalen = 0;
   2039     static char *kw[] = {"itself", "rawdata", 0};
   2040 
   2041     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|Os#", kw, &v, &rawdata, &rawdatalen))
   2042     return -1;
   2043     if (v && rawdata)
   2044     {
   2045         PyErr_SetString(PyExc_TypeError, "Only one of itself or rawdata may be specified");
   2046         return -1;
   2047     }
   2048     if (!v && !rawdata)
   2049     {
   2050         PyErr_SetString(PyExc_TypeError, "One of itself or rawdata must be specified");
   2051         return -1;
   2052     }
   2053     if (rawdata)
   2054     {
   2055         if (rawdatalen != sizeof(FSRef))
   2056         {
   2057             PyErr_SetString(PyExc_TypeError, "FSRef rawdata incorrect size");
   2058             return -1;
   2059         }
   2060         memcpy(&((FSRefObject *)_self)->ob_itself, rawdata, rawdatalen);
   2061         return 0;
   2062     }
   2063     if (PyMac_GetFSRef(v, &((FSRefObject *)_self)->ob_itself)) return 0;
   2064     return -1;
   2065 }
   2066 
   2067 #define FSRef_tp_alloc PyType_GenericAlloc
   2068 
   2069 static PyObject *FSRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
   2070 {
   2071     PyObject *self;
   2072 
   2073     if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
   2074     memset(&((FSRefObject *)self)->ob_itself, 0, sizeof(FSRef));
   2075     return self;
   2076 }
   2077 
   2078 #define FSRef_tp_free PyObject_Del
   2079 
   2080 
   2081 static PyTypeObject FSRef_Type = {
   2082     PyObject_HEAD_INIT(NULL)
   2083     0, /*ob_size*/
   2084     "Carbon.File.FSRef", /*tp_name*/
   2085     sizeof(FSRefObject), /*tp_basicsize*/
   2086     0, /*tp_itemsize*/
   2087     /* methods */
   2088     (destructor) FSRef_dealloc, /*tp_dealloc*/
   2089     0, /*tp_print*/
   2090     (getattrfunc)0, /*tp_getattr*/
   2091     (setattrfunc)0, /*tp_setattr*/
   2092     (cmpfunc) FSRef_compare, /*tp_compare*/
   2093     (reprfunc) FSRef_repr, /*tp_repr*/
   2094     (PyNumberMethods *)0, /* tp_as_number */
   2095     (PySequenceMethods *)0, /* tp_as_sequence */
   2096     (PyMappingMethods *)0, /* tp_as_mapping */
   2097     (hashfunc) FSRef_hash, /*tp_hash*/
   2098     0, /*tp_call*/
   2099     0, /*tp_str*/
   2100     PyObject_GenericGetAttr, /*tp_getattro*/
   2101     PyObject_GenericSetAttr, /*tp_setattro */
   2102     0, /*tp_as_buffer*/
   2103     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
   2104     0, /*tp_doc*/
   2105     0, /*tp_traverse*/
   2106     0, /*tp_clear*/
   2107     0, /*tp_richcompare*/
   2108     0, /*tp_weaklistoffset*/
   2109     0, /*tp_iter*/
   2110     0, /*tp_iternext*/
   2111     FSRef_methods, /* tp_methods */
   2112     0, /*tp_members*/
   2113     FSRef_getsetlist, /*tp_getset*/
   2114     0, /*tp_base*/
   2115     0, /*tp_dict*/
   2116     0, /*tp_descr_get*/
   2117     0, /*tp_descr_set*/
   2118     0, /*tp_dictoffset*/
   2119     FSRef_tp_init, /* tp_init */
   2120     FSRef_tp_alloc, /* tp_alloc */
   2121     FSRef_tp_new, /* tp_new */
   2122     FSRef_tp_free, /* tp_free */
   2123 };
   2124 
   2125 /* --------------------- End object type FSRef ---------------------- */
   2126 
   2127 #ifndef __LP64__
   2128 static PyObject *File_UnmountVol(PyObject *_self, PyObject *_args)
   2129 {
   2130     PyObject *_res = NULL;
   2131     OSErr _err;
   2132     Str63 volName;
   2133     short vRefNum;
   2134     if (!PyArg_ParseTuple(_args, "O&h",
   2135                           PyMac_GetStr255, volName,
   2136                           &vRefNum))
   2137         return NULL;
   2138     _err = UnmountVol(volName,
   2139                       vRefNum);
   2140     if (_err != noErr) return PyMac_Error(_err);
   2141     Py_INCREF(Py_None);
   2142     _res = Py_None;
   2143     return _res;
   2144 }
   2145 
   2146 static PyObject *File_FlushVol(PyObject *_self, PyObject *_args)
   2147 {
   2148     PyObject *_res = NULL;
   2149     OSErr _err;
   2150     Str63 volName;
   2151     short vRefNum;
   2152     if (!PyArg_ParseTuple(_args, "O&h",
   2153                           PyMac_GetStr255, volName,
   2154                           &vRefNum))
   2155         return NULL;
   2156     _err = FlushVol(volName,
   2157                     vRefNum);
   2158     if (_err != noErr) return PyMac_Error(_err);
   2159     Py_INCREF(Py_None);
   2160     _res = Py_None;
   2161     return _res;
   2162 }
   2163 
   2164 static PyObject *File_HSetVol(PyObject *_self, PyObject *_args)
   2165 {
   2166     PyObject *_res = NULL;
   2167     OSErr _err;
   2168     Str63 volName;
   2169     short vRefNum;
   2170     long dirID;
   2171     if (!PyArg_ParseTuple(_args, "O&hl",
   2172                           PyMac_GetStr255, volName,
   2173                           &vRefNum,
   2174                           &dirID))
   2175         return NULL;
   2176     _err = HSetVol(volName,
   2177                    vRefNum,
   2178                    dirID);
   2179     if (_err != noErr) return PyMac_Error(_err);
   2180     Py_INCREF(Py_None);
   2181     _res = Py_None;
   2182     return _res;
   2183 }
   2184 
   2185 static PyObject *File_FSClose(PyObject *_self, PyObject *_args)
   2186 {
   2187     PyObject *_res = NULL;
   2188     OSErr _err;
   2189     short refNum;
   2190     if (!PyArg_ParseTuple(_args, "h",
   2191                           &refNum))
   2192         return NULL;
   2193     _err = FSClose(refNum);
   2194     if (_err != noErr) return PyMac_Error(_err);
   2195     Py_INCREF(Py_None);
   2196     _res = Py_None;
   2197     return _res;
   2198 }
   2199 
   2200 static PyObject *File_Allocate(PyObject *_self, PyObject *_args)
   2201 {
   2202     PyObject *_res = NULL;
   2203     OSErr _err;
   2204     short refNum;
   2205     long count;
   2206     if (!PyArg_ParseTuple(_args, "h",
   2207                           &refNum))
   2208         return NULL;
   2209     _err = Allocate(refNum,
   2210                     &count);
   2211     if (_err != noErr) return PyMac_Error(_err);
   2212     _res = Py_BuildValue("l",
   2213                          count);
   2214     return _res;
   2215 }
   2216 
   2217 static PyObject *File_GetEOF(PyObject *_self, PyObject *_args)
   2218 {
   2219     PyObject *_res = NULL;
   2220     OSErr _err;
   2221     short refNum;
   2222     long logEOF;
   2223     if (!PyArg_ParseTuple(_args, "h",
   2224                           &refNum))
   2225         return NULL;
   2226     _err = GetEOF(refNum,
   2227                   &logEOF);
   2228     if (_err != noErr) return PyMac_Error(_err);
   2229     _res = Py_BuildValue("l",
   2230                          logEOF);
   2231     return _res;
   2232 }
   2233 
   2234 static PyObject *File_SetEOF(PyObject *_self, PyObject *_args)
   2235 {
   2236     PyObject *_res = NULL;
   2237     OSErr _err;
   2238     short refNum;
   2239     long logEOF;
   2240     if (!PyArg_ParseTuple(_args, "hl",
   2241                           &refNum,
   2242                           &logEOF))
   2243         return NULL;
   2244     _err = SetEOF(refNum,
   2245                   logEOF);
   2246     if (_err != noErr) return PyMac_Error(_err);
   2247     Py_INCREF(Py_None);
   2248     _res = Py_None;
   2249     return _res;
   2250 }
   2251 
   2252 static PyObject *File_GetFPos(PyObject *_self, PyObject *_args)
   2253 {
   2254     PyObject *_res = NULL;
   2255     OSErr _err;
   2256     short refNum;
   2257     long filePos;
   2258     if (!PyArg_ParseTuple(_args, "h",
   2259                           &refNum))
   2260         return NULL;
   2261     _err = GetFPos(refNum,
   2262                    &filePos);
   2263     if (_err != noErr) return PyMac_Error(_err);
   2264     _res = Py_BuildValue("l",
   2265                          filePos);
   2266     return _res;
   2267 }
   2268 
   2269 static PyObject *File_SetFPos(PyObject *_self, PyObject *_args)
   2270 {
   2271     PyObject *_res = NULL;
   2272     OSErr _err;
   2273     short refNum;
   2274     short posMode;
   2275     long posOff;
   2276     if (!PyArg_ParseTuple(_args, "hhl",
   2277                           &refNum,
   2278                           &posMode,
   2279                           &posOff))
   2280         return NULL;
   2281     _err = SetFPos(refNum,
   2282                    posMode,
   2283                    posOff);
   2284     if (_err != noErr) return PyMac_Error(_err);
   2285     Py_INCREF(Py_None);
   2286     _res = Py_None;
   2287     return _res;
   2288 }
   2289 
   2290 static PyObject *File_GetVRefNum(PyObject *_self, PyObject *_args)
   2291 {
   2292     PyObject *_res = NULL;
   2293     OSErr _err;
   2294     short fileRefNum;
   2295     short vRefNum;
   2296     if (!PyArg_ParseTuple(_args, "h",
   2297                           &fileRefNum))
   2298         return NULL;
   2299     _err = GetVRefNum(fileRefNum,
   2300                       &vRefNum);
   2301     if (_err != noErr) return PyMac_Error(_err);
   2302     _res = Py_BuildValue("h",
   2303                          vRefNum);
   2304     return _res;
   2305 }
   2306 
   2307 static PyObject *File_HGetVol(PyObject *_self, PyObject *_args)
   2308 {
   2309     PyObject *_res = NULL;
   2310     OSErr _err;
   2311     StringPtr volName;
   2312     short vRefNum;
   2313     long dirID;
   2314     if (!PyArg_ParseTuple(_args, "O&",
   2315                           PyMac_GetStr255, &volName))
   2316         return NULL;
   2317     _err = HGetVol(volName,
   2318                    &vRefNum,
   2319                    &dirID);
   2320     if (_err != noErr) return PyMac_Error(_err);
   2321     _res = Py_BuildValue("hl",
   2322                          vRefNum,
   2323                          dirID);
   2324     return _res;
   2325 }
   2326 
   2327 static PyObject *File_HOpen(PyObject *_self, PyObject *_args)
   2328 {
   2329     PyObject *_res = NULL;
   2330     OSErr _err;
   2331     short vRefNum;
   2332     long dirID;
   2333     Str255 fileName;
   2334     SInt8 permission;
   2335     short refNum;
   2336     if (!PyArg_ParseTuple(_args, "hlO&b",
   2337                           &vRefNum,
   2338                           &dirID,
   2339                           PyMac_GetStr255, fileName,
   2340                           &permission))
   2341         return NULL;
   2342     _err = HOpen(vRefNum,
   2343                  dirID,
   2344                  fileName,
   2345                  permission,
   2346                  &refNum);
   2347     if (_err != noErr) return PyMac_Error(_err);
   2348     _res = Py_BuildValue("h",
   2349                          refNum);
   2350     return _res;
   2351 }
   2352 
   2353 static PyObject *File_HOpenDF(PyObject *_self, PyObject *_args)
   2354 {
   2355     PyObject *_res = NULL;
   2356     OSErr _err;
   2357     short vRefNum;
   2358     long dirID;
   2359     Str255 fileName;
   2360     SInt8 permission;
   2361     short refNum;
   2362     if (!PyArg_ParseTuple(_args, "hlO&b",
   2363                           &vRefNum,
   2364                           &dirID,
   2365                           PyMac_GetStr255, fileName,
   2366                           &permission))
   2367         return NULL;
   2368     _err = HOpenDF(vRefNum,
   2369                    dirID,
   2370                    fileName,
   2371                    permission,
   2372                    &refNum);
   2373     if (_err != noErr) return PyMac_Error(_err);
   2374     _res = Py_BuildValue("h",
   2375                          refNum);
   2376     return _res;
   2377 }
   2378 
   2379 static PyObject *File_HOpenRF(PyObject *_self, PyObject *_args)
   2380 {
   2381     PyObject *_res = NULL;
   2382     OSErr _err;
   2383     short vRefNum;
   2384     long dirID;
   2385     Str255 fileName;
   2386     SInt8 permission;
   2387     short refNum;
   2388     if (!PyArg_ParseTuple(_args, "hlO&b",
   2389                           &vRefNum,
   2390                           &dirID,
   2391                           PyMac_GetStr255, fileName,
   2392                           &permission))
   2393         return NULL;
   2394     _err = HOpenRF(vRefNum,
   2395                    dirID,
   2396                    fileName,
   2397                    permission,
   2398                    &refNum);
   2399     if (_err != noErr) return PyMac_Error(_err);
   2400     _res = Py_BuildValue("h",
   2401                          refNum);
   2402     return _res;
   2403 }
   2404 
   2405 static PyObject *File_AllocContig(PyObject *_self, PyObject *_args)
   2406 {
   2407     PyObject *_res = NULL;
   2408     OSErr _err;
   2409     short refNum;
   2410     long count;
   2411     if (!PyArg_ParseTuple(_args, "h",
   2412                           &refNum))
   2413         return NULL;
   2414     _err = AllocContig(refNum,
   2415                        &count);
   2416     if (_err != noErr) return PyMac_Error(_err);
   2417     _res = Py_BuildValue("l",
   2418                          count);
   2419     return _res;
   2420 }
   2421 
   2422 static PyObject *File_HCreate(PyObject *_self, PyObject *_args)
   2423 {
   2424     PyObject *_res = NULL;
   2425     OSErr _err;
   2426     short vRefNum;
   2427     long dirID;
   2428     Str255 fileName;
   2429     OSType creator;
   2430     OSType fileType;
   2431     if (!PyArg_ParseTuple(_args, "hlO&O&O&",
   2432                           &vRefNum,
   2433                           &dirID,
   2434                           PyMac_GetStr255, fileName,
   2435                           PyMac_GetOSType, &creator,
   2436                           PyMac_GetOSType, &fileType))
   2437         return NULL;
   2438     _err = HCreate(vRefNum,
   2439                    dirID,
   2440                    fileName,
   2441                    creator,
   2442                    fileType);
   2443     if (_err != noErr) return PyMac_Error(_err);
   2444     Py_INCREF(Py_None);
   2445     _res = Py_None;
   2446     return _res;
   2447 }
   2448 
   2449 static PyObject *File_DirCreate(PyObject *_self, PyObject *_args)
   2450 {
   2451     PyObject *_res = NULL;
   2452     OSErr _err;
   2453     short vRefNum;
   2454     long parentDirID;
   2455     Str255 directoryName;
   2456     long createdDirID;
   2457     if (!PyArg_ParseTuple(_args, "hlO&",
   2458                           &vRefNum,
   2459                           &parentDirID,
   2460                           PyMac_GetStr255, directoryName))
   2461         return NULL;
   2462     _err = DirCreate(vRefNum,
   2463                      parentDirID,
   2464                      directoryName,
   2465                      &createdDirID);
   2466     if (_err != noErr) return PyMac_Error(_err);
   2467     _res = Py_BuildValue("l",
   2468                          createdDirID);
   2469     return _res;
   2470 }
   2471 
   2472 static PyObject *File_HDelete(PyObject *_self, PyObject *_args)
   2473 {
   2474     PyObject *_res = NULL;
   2475     OSErr _err;
   2476     short vRefNum;
   2477     long dirID;
   2478     Str255 fileName;
   2479     if (!PyArg_ParseTuple(_args, "hlO&",
   2480                           &vRefNum,
   2481                           &dirID,
   2482                           PyMac_GetStr255, fileName))
   2483         return NULL;
   2484     _err = HDelete(vRefNum,
   2485                    dirID,
   2486                    fileName);
   2487     if (_err != noErr) return PyMac_Error(_err);
   2488     Py_INCREF(Py_None);
   2489     _res = Py_None;
   2490     return _res;
   2491 }
   2492 
   2493 static PyObject *File_HGetFInfo(PyObject *_self, PyObject *_args)
   2494 {
   2495     PyObject *_res = NULL;
   2496     OSErr _err;
   2497     short vRefNum;
   2498     long dirID;
   2499     Str255 fileName;
   2500     FInfo fndrInfo;
   2501     if (!PyArg_ParseTuple(_args, "hlO&",
   2502                           &vRefNum,
   2503                           &dirID,
   2504                           PyMac_GetStr255, fileName))
   2505         return NULL;
   2506     _err = HGetFInfo(vRefNum,
   2507                      dirID,
   2508                      fileName,
   2509                      &fndrInfo);
   2510     if (_err != noErr) return PyMac_Error(_err);
   2511     _res = Py_BuildValue("O&",
   2512                          FInfo_New, &fndrInfo);
   2513     return _res;
   2514 }
   2515 
   2516 static PyObject *File_HSetFInfo(PyObject *_self, PyObject *_args)
   2517 {
   2518     PyObject *_res = NULL;
   2519     OSErr _err;
   2520     short vRefNum;
   2521     long dirID;
   2522     Str255 fileName;
   2523     FInfo fndrInfo;
   2524     if (!PyArg_ParseTuple(_args, "hlO&O&",
   2525                           &vRefNum,
   2526                           &dirID,
   2527                           PyMac_GetStr255, fileName,
   2528                           FInfo_Convert, &fndrInfo))
   2529         return NULL;
   2530     _err = HSetFInfo(vRefNum,
   2531                      dirID,
   2532                      fileName,
   2533                      &fndrInfo);
   2534     if (_err != noErr) return PyMac_Error(_err);
   2535     Py_INCREF(Py_None);
   2536     _res = Py_None;
   2537     return _res;
   2538 }
   2539 
   2540 static PyObject *File_HSetFLock(PyObject *_self, PyObject *_args)
   2541 {
   2542     PyObject *_res = NULL;
   2543     OSErr _err;
   2544     short vRefNum;
   2545     long dirID;
   2546     Str255 fileName;
   2547     if (!PyArg_ParseTuple(_args, "hlO&",
   2548                           &vRefNum,
   2549                           &dirID,
   2550                           PyMac_GetStr255, fileName))
   2551         return NULL;
   2552     _err = HSetFLock(vRefNum,
   2553                      dirID,
   2554                      fileName);
   2555     if (_err != noErr) return PyMac_Error(_err);
   2556     Py_INCREF(Py_None);
   2557     _res = Py_None;
   2558     return _res;
   2559 }
   2560 
   2561 static PyObject *File_HRstFLock(PyObject *_self, PyObject *_args)
   2562 {
   2563     PyObject *_res = NULL;
   2564     OSErr _err;
   2565     short vRefNum;
   2566     long dirID;
   2567     Str255 fileName;
   2568     if (!PyArg_ParseTuple(_args, "hlO&",
   2569                           &vRefNum,
   2570                           &dirID,
   2571                           PyMac_GetStr255, fileName))
   2572         return NULL;
   2573     _err = HRstFLock(vRefNum,
   2574                      dirID,
   2575                      fileName);
   2576     if (_err != noErr) return PyMac_Error(_err);
   2577     Py_INCREF(Py_None);
   2578     _res = Py_None;
   2579     return _res;
   2580 }
   2581 
   2582 static PyObject *File_HRename(PyObject *_self, PyObject *_args)
   2583 {
   2584     PyObject *_res = NULL;
   2585     OSErr _err;
   2586     short vRefNum;
   2587     long dirID;
   2588     Str255 oldName;
   2589     Str255 newName;
   2590     if (!PyArg_ParseTuple(_args, "hlO&O&",
   2591                           &vRefNum,
   2592                           &dirID,
   2593                           PyMac_GetStr255, oldName,
   2594                           PyMac_GetStr255, newName))
   2595         return NULL;
   2596     _err = HRename(vRefNum,
   2597                    dirID,
   2598                    oldName,
   2599                    newName);
   2600     if (_err != noErr) return PyMac_Error(_err);
   2601     Py_INCREF(Py_None);
   2602     _res = Py_None;
   2603     return _res;
   2604 }
   2605 
   2606 static PyObject *File_CatMove(PyObject *_self, PyObject *_args)
   2607 {
   2608     PyObject *_res = NULL;
   2609     OSErr _err;
   2610     short vRefNum;
   2611     long dirID;
   2612     Str255 oldName;
   2613     long newDirID;
   2614     Str255 newName;
   2615     if (!PyArg_ParseTuple(_args, "hlO&lO&",
   2616                           &vRefNum,
   2617                           &dirID,
   2618                           PyMac_GetStr255, oldName,
   2619                           &newDirID,
   2620                           PyMac_GetStr255, newName))
   2621         return NULL;
   2622     _err = CatMove(vRefNum,
   2623                    dirID,
   2624                    oldName,
   2625                    newDirID,
   2626                    newName);
   2627     if (_err != noErr) return PyMac_Error(_err);
   2628     Py_INCREF(Py_None);
   2629     _res = Py_None;
   2630     return _res;
   2631 }
   2632 
   2633 static PyObject *File_FSMakeFSSpec(PyObject *_self, PyObject *_args)
   2634 {
   2635     PyObject *_res = NULL;
   2636     OSErr _err;
   2637     short vRefNum;
   2638     long dirID;
   2639     Str255 fileName;
   2640     FSSpec spec;
   2641     if (!PyArg_ParseTuple(_args, "hlO&",
   2642                           &vRefNum,
   2643                           &dirID,
   2644                           PyMac_GetStr255, fileName))
   2645         return NULL;
   2646     _err = FSMakeFSSpec(vRefNum,
   2647                         dirID,
   2648                         fileName,
   2649                         &spec);
   2650     if (_err != noErr) return PyMac_Error(_err);
   2651     _res = Py_BuildValue("O&",
   2652                          FSSpec_New, &spec);
   2653     return _res;
   2654 }
   2655 #endif /* !__LP64__ */
   2656 
   2657 static PyObject *File_FSGetForkPosition(PyObject *_self, PyObject *_args)
   2658 {
   2659     PyObject *_res = NULL;
   2660     OSErr _err;
   2661     SInt16 forkRefNum;
   2662     SInt64 position;
   2663     if (!PyArg_ParseTuple(_args, "h",
   2664                           &forkRefNum))
   2665         return NULL;
   2666     _err = FSGetForkPosition(forkRefNum,
   2667                              &position);
   2668     if (_err != noErr) return PyMac_Error(_err);
   2669     _res = Py_BuildValue("L",
   2670                          position);
   2671     return _res;
   2672 }
   2673 
   2674 static PyObject *File_FSSetForkPosition(PyObject *_self, PyObject *_args)
   2675 {
   2676     PyObject *_res = NULL;
   2677     OSErr _err;
   2678     SInt16 forkRefNum;
   2679     UInt16 positionMode;
   2680     SInt64 positionOffset;
   2681     if (!PyArg_ParseTuple(_args, "hHL",
   2682                           &forkRefNum,
   2683                           &positionMode,
   2684                           &positionOffset))
   2685         return NULL;
   2686     _err = FSSetForkPosition(forkRefNum,
   2687                              positionMode,
   2688                              positionOffset);
   2689     if (_err != noErr) return PyMac_Error(_err);
   2690     Py_INCREF(Py_None);
   2691     _res = Py_None;
   2692     return _res;
   2693 }
   2694 
   2695 static PyObject *File_FSGetForkSize(PyObject *_self, PyObject *_args)
   2696 {
   2697     PyObject *_res = NULL;
   2698     OSErr _err;
   2699     SInt16 forkRefNum;
   2700     SInt64 forkSize;
   2701     if (!PyArg_ParseTuple(_args, "h",
   2702                           &forkRefNum))
   2703         return NULL;
   2704     _err = FSGetForkSize(forkRefNum,
   2705                          &forkSize);
   2706     if (_err != noErr) return PyMac_Error(_err);
   2707     _res = Py_BuildValue("L",
   2708                          forkSize);
   2709     return _res;
   2710 }
   2711 
   2712 static PyObject *File_FSSetForkSize(PyObject *_self, PyObject *_args)
   2713 {
   2714     PyObject *_res = NULL;
   2715     OSErr _err;
   2716     SInt16 forkRefNum;
   2717     UInt16 positionMode;
   2718     SInt64 positionOffset;
   2719     if (!PyArg_ParseTuple(_args, "hHL",
   2720                           &forkRefNum,
   2721                           &positionMode,
   2722                           &positionOffset))
   2723         return NULL;
   2724     _err = FSSetForkSize(forkRefNum,
   2725                          positionMode,
   2726                          positionOffset);
   2727     if (_err != noErr) return PyMac_Error(_err);
   2728     Py_INCREF(Py_None);
   2729     _res = Py_None;
   2730     return _res;
   2731 }
   2732 
   2733 static PyObject *File_FSAllocateFork(PyObject *_self, PyObject *_args)
   2734 {
   2735     PyObject *_res = NULL;
   2736     OSErr _err;
   2737     SInt16 forkRefNum;
   2738     FSAllocationFlags flags;
   2739     UInt16 positionMode;
   2740     SInt64 positionOffset;
   2741     UInt64 requestCount;
   2742     UInt64 actualCount;
   2743     if (!PyArg_ParseTuple(_args, "hHHLL",
   2744                           &forkRefNum,
   2745                           &flags,
   2746                           &positionMode,
   2747                           &positionOffset,
   2748                           &requestCount))
   2749         return NULL;
   2750     _err = FSAllocateFork(forkRefNum,
   2751                           flags,
   2752                           positionMode,
   2753                           positionOffset,
   2754                           requestCount,
   2755                           &actualCount);
   2756     if (_err != noErr) return PyMac_Error(_err);
   2757     _res = Py_BuildValue("L",
   2758                          actualCount);
   2759     return _res;
   2760 }
   2761 
   2762 static PyObject *File_FSFlushFork(PyObject *_self, PyObject *_args)
   2763 {
   2764     PyObject *_res = NULL;
   2765     OSErr _err;
   2766     SInt16 forkRefNum;
   2767     if (!PyArg_ParseTuple(_args, "h",
   2768                           &forkRefNum))
   2769         return NULL;
   2770     _err = FSFlushFork(forkRefNum);
   2771     if (_err != noErr) return PyMac_Error(_err);
   2772     Py_INCREF(Py_None);
   2773     _res = Py_None;
   2774     return _res;
   2775 }
   2776 
   2777 static PyObject *File_FSCloseFork(PyObject *_self, PyObject *_args)
   2778 {
   2779     PyObject *_res = NULL;
   2780     OSErr _err;
   2781     SInt16 forkRefNum;
   2782     if (!PyArg_ParseTuple(_args, "h",
   2783                           &forkRefNum))
   2784         return NULL;
   2785     _err = FSCloseFork(forkRefNum);
   2786     if (_err != noErr) return PyMac_Error(_err);
   2787     Py_INCREF(Py_None);
   2788     _res = Py_None;
   2789     return _res;
   2790 }
   2791 
   2792 static PyObject *File_FSGetDataForkName(PyObject *_self, PyObject *_args)
   2793 {
   2794     PyObject *_res = NULL;
   2795     OSErr _err;
   2796     HFSUniStr255 dataForkName;
   2797     if (!PyArg_ParseTuple(_args, ""))
   2798         return NULL;
   2799     _err = FSGetDataForkName(&dataForkName);
   2800     if (_err != noErr) return PyMac_Error(_err);
   2801     _res = Py_BuildValue("O&",
   2802                          PyMac_BuildHFSUniStr255, &dataForkName);
   2803     return _res;
   2804 }
   2805 
   2806 static PyObject *File_FSGetResourceForkName(PyObject *_self, PyObject *_args)
   2807 {
   2808     PyObject *_res = NULL;
   2809     OSErr _err;
   2810     HFSUniStr255 resourceForkName;
   2811     if (!PyArg_ParseTuple(_args, ""))
   2812         return NULL;
   2813     _err = FSGetResourceForkName(&resourceForkName);
   2814     if (_err != noErr) return PyMac_Error(_err);
   2815     _res = Py_BuildValue("O&",
   2816                          PyMac_BuildHFSUniStr255, &resourceForkName);
   2817     return _res;
   2818 }
   2819 
   2820 static PyObject *File_FSPathMakeRef(PyObject *_self, PyObject *_args)
   2821 {
   2822     PyObject *_res = NULL;
   2823     OSStatus _err;
   2824     UInt8 * path;
   2825     FSRef ref;
   2826     Boolean isDirectory;
   2827     if (!PyArg_ParseTuple(_args, "s",
   2828                           &path))
   2829         return NULL;
   2830     _err = FSPathMakeRef(path,
   2831                          &ref,
   2832                          &isDirectory);
   2833     if (_err != noErr) return PyMac_Error(_err);
   2834     _res = Py_BuildValue("O&b",
   2835                          FSRef_New, &ref,
   2836                          isDirectory);
   2837     return _res;
   2838 }
   2839 
   2840 static PyObject *File_FNNotifyByPath(PyObject *_self, PyObject *_args)
   2841 {
   2842     PyObject *_res = NULL;
   2843     OSStatus _err;
   2844     UInt8 * path;
   2845     FNMessage message;
   2846     OptionBits flags;
   2847     if (!PyArg_ParseTuple(_args, "sll",
   2848                           &path,
   2849                           &message,
   2850                           &flags))
   2851         return NULL;
   2852     _err = FNNotifyByPath(path,
   2853                           message,
   2854                           flags);
   2855     if (_err != noErr) return PyMac_Error(_err);
   2856     Py_INCREF(Py_None);
   2857     _res = Py_None;
   2858     return _res;
   2859 }
   2860 
   2861 static PyObject *File_FNNotifyAll(PyObject *_self, PyObject *_args)
   2862 {
   2863     PyObject *_res = NULL;
   2864     OSStatus _err;
   2865     FNMessage message;
   2866     OptionBits flags;
   2867     if (!PyArg_ParseTuple(_args, "ll",
   2868                           &message,
   2869                           &flags))
   2870         return NULL;
   2871     _err = FNNotifyAll(message,
   2872                        flags);
   2873     if (_err != noErr) return PyMac_Error(_err);
   2874     Py_INCREF(Py_None);
   2875     _res = Py_None;
   2876     return _res;
   2877 }
   2878 
   2879 #ifndef __LP64__
   2880 static PyObject *File_NewAlias(PyObject *_self, PyObject *_args)
   2881 {
   2882     PyObject *_res = NULL;
   2883     OSErr _err;
   2884     FSSpec fromFile__buf__;
   2885     FSSpec *fromFile = &fromFile__buf__;
   2886     FSSpec target;
   2887     AliasHandle alias;
   2888     if (!PyArg_ParseTuple(_args, "O&O&",
   2889                           myPyMac_GetOptFSSpecPtr, &fromFile,
   2890                           FSSpec_Convert, &target))
   2891         return NULL;
   2892     _err = NewAlias(fromFile,
   2893                     &target,
   2894                     &alias);
   2895     if (_err != noErr) return PyMac_Error(_err);
   2896     _res = Py_BuildValue("O&",
   2897                          Alias_New, alias);
   2898     return _res;
   2899 }
   2900 
   2901 static PyObject *File_NewAliasMinimalFromFullPath(PyObject *_self, PyObject *_args)
   2902 {
   2903     PyObject *_res = NULL;
   2904     OSErr _err;
   2905     char *fullPath__in__;
   2906     int fullPath__len__;
   2907     int fullPath__in_len__;
   2908     Str32 zoneName;
   2909     Str31 serverName;
   2910     AliasHandle alias;
   2911     if (!PyArg_ParseTuple(_args, "s#O&O&",
   2912                           &fullPath__in__, &fullPath__in_len__,
   2913                           PyMac_GetStr255, zoneName,
   2914                           PyMac_GetStr255, serverName))
   2915         return NULL;
   2916     fullPath__len__ = fullPath__in_len__;
   2917     _err = NewAliasMinimalFromFullPath(fullPath__len__, fullPath__in__,
   2918                                        zoneName,
   2919                                        serverName,
   2920                                        &alias);
   2921     if (_err != noErr) return PyMac_Error(_err);
   2922     _res = Py_BuildValue("O&",
   2923                          Alias_New, alias);
   2924     return _res;
   2925 }
   2926 
   2927 static PyObject *File_ResolveAliasFile(PyObject *_self, PyObject *_args)
   2928 {
   2929     PyObject *_res = NULL;
   2930     OSErr _err;
   2931     FSSpec theSpec;
   2932     Boolean resolveAliasChains;
   2933     Boolean targetIsFolder;
   2934     Boolean wasAliased;
   2935     if (!PyArg_ParseTuple(_args, "O&b",
   2936                           FSSpec_Convert, &theSpec,
   2937                           &resolveAliasChains))
   2938         return NULL;
   2939     _err = ResolveAliasFile(&theSpec,
   2940                             resolveAliasChains,
   2941                             &targetIsFolder,
   2942                             &wasAliased);
   2943     if (_err != noErr) return PyMac_Error(_err);
   2944     _res = Py_BuildValue("O&bb",
   2945                          FSSpec_New, &theSpec,
   2946                          targetIsFolder,
   2947                          wasAliased);
   2948     return _res;
   2949 }
   2950 
   2951 static PyObject *File_ResolveAliasFileWithMountFlags(PyObject *_self, PyObject *_args)
   2952 {
   2953     PyObject *_res = NULL;
   2954     OSErr _err;
   2955     FSSpec theSpec;
   2956     Boolean resolveAliasChains;
   2957     Boolean targetIsFolder;
   2958     Boolean wasAliased;
   2959     unsigned long mountFlags;
   2960     if (!PyArg_ParseTuple(_args, "O&bl",
   2961                           FSSpec_Convert, &theSpec,
   2962                           &resolveAliasChains,
   2963                           &mountFlags))
   2964         return NULL;
   2965     _err = ResolveAliasFileWithMountFlags(&theSpec,
   2966                                           resolveAliasChains,
   2967                                           &targetIsFolder,
   2968                                           &wasAliased,
   2969                                           mountFlags);
   2970     if (_err != noErr) return PyMac_Error(_err);
   2971     _res = Py_BuildValue("O&bb",
   2972                          FSSpec_New, &theSpec,
   2973                          targetIsFolder,
   2974                          wasAliased);
   2975     return _res;
   2976 }
   2977 
   2978 static PyObject *File_UpdateAlias(PyObject *_self, PyObject *_args)
   2979 {
   2980     PyObject *_res = NULL;
   2981     OSErr _err;
   2982     FSSpec fromFile__buf__;
   2983     FSSpec *fromFile = &fromFile__buf__;
   2984     FSSpec target;
   2985     AliasHandle alias;
   2986     Boolean wasChanged;
   2987     if (!PyArg_ParseTuple(_args, "O&O&O&",
   2988                           myPyMac_GetOptFSSpecPtr, &fromFile,
   2989                           FSSpec_Convert, &target,
   2990                           Alias_Convert, &alias))
   2991         return NULL;
   2992     _err = UpdateAlias(fromFile,
   2993                        &target,
   2994                        alias,
   2995                        &wasChanged);
   2996     if (_err != noErr) return PyMac_Error(_err);
   2997     _res = Py_BuildValue("b",
   2998                          wasChanged);
   2999     return _res;
   3000 }
   3001 
   3002 static PyObject *File_ResolveAliasFileWithMountFlagsNoUI(PyObject *_self, PyObject *_args)
   3003 {
   3004     PyObject *_res = NULL;
   3005     OSErr _err;
   3006     FSSpec theSpec;
   3007     Boolean resolveAliasChains;
   3008     Boolean targetIsFolder;
   3009     Boolean wasAliased;
   3010     unsigned long mountFlags;
   3011     if (!PyArg_ParseTuple(_args, "O&bl",
   3012                           FSSpec_Convert, &theSpec,
   3013                           &resolveAliasChains,
   3014                           &mountFlags))
   3015         return NULL;
   3016     _err = ResolveAliasFileWithMountFlagsNoUI(&theSpec,
   3017                                               resolveAliasChains,
   3018                                               &targetIsFolder,
   3019                                               &wasAliased,
   3020                                               mountFlags);
   3021     if (_err != noErr) return PyMac_Error(_err);
   3022     _res = Py_BuildValue("O&bb",
   3023                          FSSpec_New, &theSpec,
   3024                          targetIsFolder,
   3025                          wasAliased);
   3026     return _res;
   3027 }
   3028 #endif /* !__LP64__ */
   3029 
   3030 static PyObject *File_FSNewAlias(PyObject *_self, PyObject *_args)
   3031 {
   3032     PyObject *_res = NULL;
   3033     OSErr _err;
   3034     FSRef fromFile__buf__;
   3035     FSRef *fromFile = &fromFile__buf__;
   3036     FSRef target;
   3037     AliasHandle inAlias;
   3038     if (!PyArg_ParseTuple(_args, "O&O&",
   3039                           myPyMac_GetOptFSRefPtr, &fromFile,
   3040                           FSRef_Convert, &target))
   3041         return NULL;
   3042     _err = FSNewAlias(fromFile,
   3043                       &target,
   3044                       &inAlias);
   3045     if (_err != noErr) return PyMac_Error(_err);
   3046     _res = Py_BuildValue("O&",
   3047                          Alias_New, inAlias);
   3048     return _res;
   3049 }
   3050 
   3051 static PyObject *File_FSResolveAliasFileWithMountFlags(PyObject *_self, PyObject *_args)
   3052 {
   3053     PyObject *_res = NULL;
   3054     OSErr _err;
   3055     FSRef theRef;
   3056     Boolean resolveAliasChains;
   3057     Boolean targetIsFolder;
   3058     Boolean wasAliased;
   3059     unsigned long mountFlags;
   3060     if (!PyArg_ParseTuple(_args, "O&bl",
   3061                           FSRef_Convert, &theRef,
   3062                           &resolveAliasChains,
   3063                           &mountFlags))
   3064         return NULL;
   3065     _err = FSResolveAliasFileWithMountFlags(&theRef,
   3066                                             resolveAliasChains,
   3067                                             &targetIsFolder,
   3068                                             &wasAliased,
   3069                                             mountFlags);
   3070     if (_err != noErr) return PyMac_Error(_err);
   3071     _res = Py_BuildValue("O&bb",
   3072                          FSRef_New, &theRef,
   3073                          targetIsFolder,
   3074                          wasAliased);
   3075     return _res;
   3076 }
   3077 
   3078 static PyObject *File_FSResolveAliasFile(PyObject *_self, PyObject *_args)
   3079 {
   3080     PyObject *_res = NULL;
   3081     OSErr _err;
   3082     FSRef theRef;
   3083     Boolean resolveAliasChains;
   3084     Boolean targetIsFolder;
   3085     Boolean wasAliased;
   3086     if (!PyArg_ParseTuple(_args, "O&b",
   3087                           FSRef_Convert, &theRef,
   3088                           &resolveAliasChains))
   3089         return NULL;
   3090     _err = FSResolveAliasFile(&theRef,
   3091                               resolveAliasChains,
   3092                               &targetIsFolder,
   3093                               &wasAliased);
   3094     if (_err != noErr) return PyMac_Error(_err);
   3095     _res = Py_BuildValue("O&bb",
   3096                          FSRef_New, &theRef,
   3097                          targetIsFolder,
   3098                          wasAliased);
   3099     return _res;
   3100 }
   3101 
   3102 static PyObject *File_FSUpdateAlias(PyObject *_self, PyObject *_args)
   3103 {
   3104     PyObject *_res = NULL;
   3105     OSErr _err;
   3106     FSRef fromFile__buf__;
   3107     FSRef *fromFile = &fromFile__buf__;
   3108     FSRef target;
   3109     AliasHandle alias;
   3110     Boolean wasChanged;
   3111     if (!PyArg_ParseTuple(_args, "O&O&O&",
   3112                           myPyMac_GetOptFSRefPtr, &fromFile,
   3113                           FSRef_Convert, &target,
   3114                           Alias_Convert, &alias))
   3115         return NULL;
   3116     _err = FSUpdateAlias(fromFile,
   3117                          &target,
   3118                          alias,
   3119                          &wasChanged);
   3120     if (_err != noErr) return PyMac_Error(_err);
   3121     _res = Py_BuildValue("b",
   3122                          wasChanged);
   3123     return _res;
   3124 }
   3125 
   3126 static PyObject *File_pathname(PyObject *_self, PyObject *_args)
   3127 {
   3128     PyObject *_res = NULL;
   3129 
   3130     PyObject *obj;
   3131 
   3132     if (!PyArg_ParseTuple(_args, "O", &obj))
   3133         return NULL;
   3134     if (PyString_Check(obj)) {
   3135         Py_INCREF(obj);
   3136         return obj;
   3137     }
   3138     if (PyUnicode_Check(obj))
   3139         return PyUnicode_AsEncodedString(obj, "utf8", "strict");
   3140     _res = PyObject_CallMethod(obj, "as_pathname", NULL);
   3141     return _res;
   3142 
   3143 }
   3144 
   3145 static PyMethodDef File_methods[] = {
   3146 #ifndef __LP64__
   3147     {"UnmountVol", (PyCFunction)File_UnmountVol, 1,
   3148      PyDoc_STR("(Str63 volName, short vRefNum) -> None")},
   3149     {"FlushVol", (PyCFunction)File_FlushVol, 1,
   3150      PyDoc_STR("(Str63 volName, short vRefNum) -> None")},
   3151     {"HSetVol", (PyCFunction)File_HSetVol, 1,
   3152      PyDoc_STR("(Str63 volName, short vRefNum, long dirID) -> None")},
   3153     {"FSClose", (PyCFunction)File_FSClose, 1,
   3154      PyDoc_STR("(short refNum) -> None")},
   3155     {"Allocate", (PyCFunction)File_Allocate, 1,
   3156      PyDoc_STR("(short refNum) -> (long count)")},
   3157     {"GetEOF", (PyCFunction)File_GetEOF, 1,
   3158      PyDoc_STR("(short refNum) -> (long logEOF)")},
   3159     {"SetEOF", (PyCFunction)File_SetEOF, 1,
   3160      PyDoc_STR("(short refNum, long logEOF) -> None")},
   3161     {"GetFPos", (PyCFunction)File_GetFPos, 1,
   3162      PyDoc_STR("(short refNum) -> (long filePos)")},
   3163     {"SetFPos", (PyCFunction)File_SetFPos, 1,
   3164      PyDoc_STR("(short refNum, short posMode, long posOff) -> None")},
   3165     {"GetVRefNum", (PyCFunction)File_GetVRefNum, 1,
   3166      PyDoc_STR("(short fileRefNum) -> (short vRefNum)")},
   3167     {"HGetVol", (PyCFunction)File_HGetVol, 1,
   3168      PyDoc_STR("(StringPtr volName) -> (short vRefNum, long dirID)")},
   3169     {"HOpen", (PyCFunction)File_HOpen, 1,
   3170      PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")},
   3171     {"HOpenDF", (PyCFunction)File_HOpenDF, 1,
   3172      PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")},
   3173     {"HOpenRF", (PyCFunction)File_HOpenRF, 1,
   3174      PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")},
   3175     {"AllocContig", (PyCFunction)File_AllocContig, 1,
   3176      PyDoc_STR("(short refNum) -> (long count)")},
   3177     {"HCreate", (PyCFunction)File_HCreate, 1,
   3178      PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, OSType creator, OSType fileType) -> None")},
   3179     {"DirCreate", (PyCFunction)File_DirCreate, 1,
   3180      PyDoc_STR("(short vRefNum, long parentDirID, Str255 directoryName) -> (long createdDirID)")},
   3181     {"HDelete", (PyCFunction)File_HDelete, 1,
   3182      PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")},
   3183     {"HGetFInfo", (PyCFunction)File_HGetFInfo, 1,
   3184      PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> (FInfo fndrInfo)")},
   3185     {"HSetFInfo", (PyCFunction)File_HSetFInfo, 1,
   3186      PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, FInfo fndrInfo) -> None")},
   3187     {"HSetFLock", (PyCFunction)File_HSetFLock, 1,
   3188      PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")},
   3189     {"HRstFLock", (PyCFunction)File_HRstFLock, 1,
   3190      PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")},
   3191     {"HRename", (PyCFunction)File_HRename, 1,
   3192      PyDoc_STR("(short vRefNum, long dirID, Str255 oldName, Str255 newName) -> None")},
   3193     {"CatMove", (PyCFunction)File_CatMove, 1,
   3194      PyDoc_STR("(short vRefNum, long dirID, Str255 oldName, long newDirID, Str255 newName) -> None")},
   3195     {"FSMakeFSSpec", (PyCFunction)File_FSMakeFSSpec, 1,
   3196      PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> (FSSpec spec)")},
   3197 #endif /* !__LP64__*/
   3198     {"FSGetForkPosition", (PyCFunction)File_FSGetForkPosition, 1,
   3199      PyDoc_STR("(SInt16 forkRefNum) -> (SInt64 position)")},
   3200     {"FSSetForkPosition", (PyCFunction)File_FSSetForkPosition, 1,
   3201      PyDoc_STR("(SInt16 forkRefNum, UInt16 positionMode, SInt64 positionOffset) -> None")},
   3202     {"FSGetForkSize", (PyCFunction)File_FSGetForkSize, 1,
   3203      PyDoc_STR("(SInt16 forkRefNum) -> (SInt64 forkSize)")},
   3204     {"FSSetForkSize", (PyCFunction)File_FSSetForkSize, 1,
   3205      PyDoc_STR("(SInt16 forkRefNum, UInt16 positionMode, SInt64 positionOffset) -> None")},
   3206     {"FSAllocateFork", (PyCFunction)File_FSAllocateFork, 1,
   3207      PyDoc_STR("(SInt16 forkRefNum, FSAllocationFlags flags, UInt16 positionMode, SInt64 positionOffset, UInt64 requestCount) -> (UInt64 actualCount)")},
   3208     {"FSFlushFork", (PyCFunction)File_FSFlushFork, 1,
   3209      PyDoc_STR("(SInt16 forkRefNum) -> None")},
   3210     {"FSCloseFork", (PyCFunction)File_FSCloseFork, 1,
   3211      PyDoc_STR("(SInt16 forkRefNum) -> None")},
   3212     {"FSGetDataForkName", (PyCFunction)File_FSGetDataForkName, 1,
   3213      PyDoc_STR("() -> (HFSUniStr255 dataForkName)")},
   3214     {"FSGetResourceForkName", (PyCFunction)File_FSGetResourceForkName, 1,
   3215      PyDoc_STR("() -> (HFSUniStr255 resourceForkName)")},
   3216     {"FSPathMakeRef", (PyCFunction)File_FSPathMakeRef, 1,
   3217      PyDoc_STR("(UInt8 * path) -> (FSRef ref, Boolean isDirectory)")},
   3218     {"FNNotifyByPath", (PyCFunction)File_FNNotifyByPath, 1,
   3219      PyDoc_STR("(UInt8 * path, FNMessage message, OptionBits flags) -> None")},
   3220     {"FNNotifyAll", (PyCFunction)File_FNNotifyAll, 1,
   3221      PyDoc_STR("(FNMessage message, OptionBits flags) -> None")},
   3222 #ifndef  __LP64__
   3223     {"NewAlias", (PyCFunction)File_NewAlias, 1,
   3224      PyDoc_STR("(FSSpec fromFile, FSSpec target) -> (AliasHandle alias)")},
   3225     {"NewAliasMinimalFromFullPath", (PyCFunction)File_NewAliasMinimalFromFullPath, 1,
   3226      PyDoc_STR("(Buffer fullPath, Str32 zoneName, Str31 serverName) -> (AliasHandle alias)")},
   3227     {"ResolveAliasFile", (PyCFunction)File_ResolveAliasFile, 1,
   3228      PyDoc_STR("(FSSpec theSpec, Boolean resolveAliasChains) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")},
   3229     {"ResolveAliasFileWithMountFlags", (PyCFunction)File_ResolveAliasFileWithMountFlags, 1,
   3230      PyDoc_STR("(FSSpec theSpec, Boolean resolveAliasChains, unsigned long mountFlags) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")},
   3231     {"UpdateAlias", (PyCFunction)File_UpdateAlias, 1,
   3232      PyDoc_STR("(FSSpec fromFile, FSSpec target, AliasHandle alias) -> (Boolean wasChanged)")},
   3233     {"ResolveAliasFileWithMountFlagsNoUI", (PyCFunction)File_ResolveAliasFileWithMountFlagsNoUI, 1,
   3234      PyDoc_STR("(FSSpec theSpec, Boolean resolveAliasChains, unsigned long mountFlags) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")},
   3235 #endif /* !__LP64__ */
   3236     {"FSNewAlias", (PyCFunction)File_FSNewAlias, 1,
   3237      PyDoc_STR("(FSRef fromFile, FSRef target) -> (AliasHandle inAlias)")},
   3238     {"FSResolveAliasFileWithMountFlags", (PyCFunction)File_FSResolveAliasFileWithMountFlags, 1,
   3239      PyDoc_STR("(FSRef theRef, Boolean resolveAliasChains, unsigned long mountFlags) -> (FSRef theRef, Boolean targetIsFolder, Boolean wasAliased)")},
   3240     {"FSResolveAliasFile", (PyCFunction)File_FSResolveAliasFile, 1,
   3241      PyDoc_STR("(FSRef theRef, Boolean resolveAliasChains) -> (FSRef theRef, Boolean targetIsFolder, Boolean wasAliased)")},
   3242     {"FSUpdateAlias", (PyCFunction)File_FSUpdateAlias, 1,
   3243      PyDoc_STR("(FSRef fromFile, FSRef target, AliasHandle alias) -> (Boolean wasChanged)")},
   3244     {"pathname", (PyCFunction)File_pathname, 1,
   3245      PyDoc_STR("(str|unicode|FSSpec|FSref) -> pathname")},
   3246     {NULL, NULL, 0}
   3247 };
   3248 
   3249 
   3250 #ifndef __LP64__
   3251 int
   3252 PyMac_GetFSSpec(PyObject *v, FSSpec *spec)
   3253 {
   3254     Str255 path;
   3255     short refnum;
   3256     long parid;
   3257     OSErr err;
   3258     FSRef fsr;
   3259 
   3260     if (FSSpec_Check(v)) {
   3261         *spec = ((FSSpecObject *)v)->ob_itself;
   3262         return 1;
   3263     }
   3264 
   3265     if (PyArg_Parse(v, "(hlO&)",
   3266                                             &refnum, &parid, PyMac_GetStr255, &path)) {
   3267         err = FSMakeFSSpec(refnum, parid, path, spec);
   3268         if ( err && err != fnfErr ) {
   3269             PyMac_Error(err);
   3270             return 0;
   3271         }
   3272         return 1;
   3273     }
   3274     PyErr_Clear();
   3275     /* Otherwise we try to go via an FSRef. On OSX we go all the way,
   3276     ** on OS9 we accept only a real FSRef object
   3277     */
   3278     if ( PyMac_GetFSRef(v, &fsr) ) {
   3279         err = FSGetCatalogInfo(&fsr, kFSCatInfoNone, NULL, NULL, spec, NULL);
   3280         if (err != noErr) {
   3281             PyMac_Error(err);
   3282             return 0;
   3283         }
   3284         return 1;
   3285     }
   3286     return 0;
   3287 }
   3288 #endif /* !__LP64__ */
   3289 
   3290 int
   3291 PyMac_GetFSRef(PyObject *v, FSRef *fsr)
   3292 {
   3293     OSStatus err;
   3294 #ifndef __LP64__
   3295     FSSpec fss;
   3296 #endif /* !__LP64__ */
   3297 
   3298     if (FSRef_Check(v)) {
   3299         *fsr = ((FSRefObject *)v)->ob_itself;
   3300         return 1;
   3301     }
   3302 
   3303     /* On OSX we now try a pathname */
   3304     if ( PyString_Check(v) || PyUnicode_Check(v)) {
   3305         char *path = NULL;
   3306         if (!PyArg_Parse(v, "et", Py_FileSystemDefaultEncoding, &path))
   3307             return 0;
   3308         if ( (err=FSPathMakeRef((unsigned char*)path, fsr, NULL)) )
   3309             PyMac_Error(err);
   3310         PyMem_Free(path);
   3311         return !err;
   3312     }
   3313     /* XXXX Should try unicode here too */
   3314 
   3315 #ifndef __LP64__
   3316     /* Otherwise we try to go via an FSSpec */
   3317     if (FSSpec_Check(v)) {
   3318         fss = ((FSSpecObject *)v)->ob_itself;
   3319         if ((err=FSpMakeFSRef(&fss, fsr)) == 0)
   3320             return 1;
   3321         PyMac_Error(err);
   3322         return 0;
   3323     }
   3324 #endif /* !__LP64__ */
   3325 
   3326     PyErr_SetString(PyExc_TypeError, "FSRef, FSSpec or pathname required");
   3327     return 0;
   3328 }
   3329 
   3330 #ifndef __LP64__
   3331 extern PyObject *
   3332 PyMac_BuildFSSpec(FSSpec *spec)
   3333 {
   3334     return FSSpec_New(spec);
   3335 }
   3336 #endif /* !__LP64__ */
   3337 
   3338 extern PyObject *
   3339 PyMac_BuildFSRef(FSRef *spec)
   3340 {
   3341     return FSRef_New(spec);
   3342 }
   3343 
   3344 
   3345 void init_File(void)
   3346 {
   3347     PyObject *m;
   3348     PyObject *d;
   3349 
   3350 
   3351 #ifndef __LP64__
   3352     PyMac_INIT_TOOLBOX_OBJECT_NEW(FSSpec *, PyMac_BuildFSSpec);
   3353     PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSSpec, PyMac_GetFSSpec);
   3354 #endif /* !__LP64__ */
   3355 
   3356     PyMac_INIT_TOOLBOX_OBJECT_NEW(FSRef *, PyMac_BuildFSRef);
   3357     PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSRef, PyMac_GetFSRef);
   3358 
   3359 
   3360     m = Py_InitModule("_File", File_methods);
   3361     d = PyModule_GetDict(m);
   3362     File_Error = PyMac_GetOSErrException();
   3363     if (File_Error == NULL ||
   3364         PyDict_SetItemString(d, "Error", File_Error) != 0)
   3365         return;
   3366     FSCatalogInfo_Type.ob_type = &PyType_Type;
   3367     if (PyType_Ready(&FSCatalogInfo_Type) < 0) return;
   3368     Py_INCREF(&FSCatalogInfo_Type);
   3369     PyModule_AddObject(m, "FSCatalogInfo", (PyObject *)&FSCatalogInfo_Type);
   3370     /* Backward-compatible name */
   3371     Py_INCREF(&FSCatalogInfo_Type);
   3372     PyModule_AddObject(m, "FSCatalogInfoType", (PyObject *)&FSCatalogInfo_Type);
   3373 
   3374 #ifndef __LP64__
   3375     FInfo_Type.ob_type = &PyType_Type;
   3376     if (PyType_Ready(&FInfo_Type) < 0) return;
   3377     Py_INCREF(&FInfo_Type);
   3378     PyModule_AddObject(m, "FInfo", (PyObject *)&FInfo_Type);
   3379     /* Backward-compatible name */
   3380     Py_INCREF(&FInfo_Type);
   3381     PyModule_AddObject(m, "FInfoType", (PyObject *)&FInfo_Type);
   3382 #endif /* !__LP64__ */
   3383     Alias_Type.ob_type = &PyType_Type;
   3384     if (PyType_Ready(&Alias_Type) < 0) return;
   3385     Py_INCREF(&Alias_Type);
   3386     PyModule_AddObject(m, "Alias", (PyObject *)&Alias_Type);
   3387     /* Backward-compatible name */
   3388     Py_INCREF(&Alias_Type);
   3389     PyModule_AddObject(m, "AliasType", (PyObject *)&Alias_Type);
   3390 
   3391 #ifndef __LP64__
   3392     FSSpec_Type.ob_type = &PyType_Type;
   3393     if (PyType_Ready(&FSSpec_Type) < 0) return;
   3394     Py_INCREF(&FSSpec_Type);
   3395     PyModule_AddObject(m, "FSSpec", (PyObject *)&FSSpec_Type);
   3396     /* Backward-compatible name */
   3397     Py_INCREF(&FSSpec_Type);
   3398     PyModule_AddObject(m, "FSSpecType", (PyObject *)&FSSpec_Type);
   3399 #endif /* !__LP64__ */
   3400     FSRef_Type.ob_type = &PyType_Type;
   3401     if (PyType_Ready(&FSRef_Type) < 0) return;
   3402     Py_INCREF(&FSRef_Type);
   3403     PyModule_AddObject(m, "FSRef", (PyObject *)&FSRef_Type);
   3404     /* Backward-compatible name */
   3405     Py_INCREF(&FSRef_Type);
   3406     PyModule_AddObject(m, "FSRefType", (PyObject *)&FSRef_Type);
   3407 }
   3408 
   3409 /* ======================== End module _File ======================== */
   3410 
   3411