1
2/* ========================== Module _File ========================== */
3
4#include "Python.h"
5
6
7
8#include "pymactoolbox.h"
9
10#ifndef HAVE_OSX105_SDK
11typedef 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__
27extern int _PyMac_GetFSSpec(PyObject *v, FSSpec *spec);
28extern PyObject *_PyMac_BuildFSSpec(FSSpec *spec);
29#define PyMac_BuildFSSpec _PyMac_BuildFSSpec
30#endif /* __LP64__*/
31
32extern int _PyMac_GetFSRef(PyObject *v, FSRef *fsr);
33extern 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__
41extern int PyMac_GetFSSpec(PyObject *v, FSSpec *spec);
42extern PyObject *PyMac_BuildFSSpec(FSSpec *spec);
43#endif /* !__LP64__*/
44
45extern int PyMac_GetFSRef(PyObject *v, FSRef *fsr);
46extern PyObject *PyMac_BuildFSRef(FSRef *spec);
47
48#endif  /* !USE_TOOLBOX_OBJECT_GLUE */
49
50/* Forward declarations */
51static PyObject *FSRef_New(FSRef *itself);
52#ifndef __LP64__
53static PyObject *FInfo_New(FInfo *itself);
54
55static PyObject *FSSpec_New(FSSpec *itself);
56#define FSSpec_Convert PyMac_GetFSSpec
57#endif /* !__LP64__ */
58
59static PyObject *Alias_New(AliasHandle itself);
60#ifndef __LP64__
61static int FInfo_Convert(PyObject *v, FInfo *p_itself);
62#endif /* !__LP64__ */
63#define FSRef_Convert PyMac_GetFSRef
64static int Alias_Convert(PyObject *v, AliasHandle *p_itself);
65
66/*
67** UTCDateTime records
68*/
69static int
70UTCDateTime_Convert(PyObject *v, UTCDateTime *ptr)
71{
72    return PyArg_Parse(v, "(HlH)", &ptr->highSeconds, &ptr->lowSeconds, &ptr->fraction);
73}
74
75static PyObject *
76UTCDateTime_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__
85static int
86myPyMac_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
96static int
97myPyMac_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*/
109static PyObject *
110PyMac_BuildHFSUniStr255(HFSUniStr255 *itself)
111{
112
113    return Py_BuildValue("u#", itself->unicode, itself->length);
114}
115
116#ifndef __LP64__
117static 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
163static PyObject *File_Error;
164
165/* ------------------- Object type FSCatalogInfo -------------------- */
166
167static PyTypeObject FSCatalogInfo_Type;
168
169#define FSCatalogInfo_Check(x) ((x)->ob_type == &FSCatalogInfo_Type || PyObject_TypeCheck((x), &FSCatalogInfo_Type))
170
171typedef struct FSCatalogInfoObject {
172    PyObject_HEAD
173    FSCatalogInfo ob_itself;
174} FSCatalogInfoObject;
175
176static 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
186static 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
197static void FSCatalogInfo_dealloc(FSCatalogInfoObject *self)
198{
199    /* Cleanup of self->ob_itself goes here */
200    self->ob_type->tp_free((PyObject *)self);
201}
202
203static PyMethodDef FSCatalogInfo_methods[] = {
204    {NULL, NULL, 0}
205};
206
207static PyObject *FSCatalogInfo_get_nodeFlags(FSCatalogInfoObject *self, void *closure)
208{
209    return Py_BuildValue("H", self->ob_itself.nodeFlags);
210}
211
212static 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
218static PyObject *FSCatalogInfo_get_volume(FSCatalogInfoObject *self, void *closure)
219{
220    return Py_BuildValue("h", self->ob_itself.volume);
221}
222
223static 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
229static PyObject *FSCatalogInfo_get_parentDirID(FSCatalogInfoObject *self, void *closure)
230{
231    return Py_BuildValue("l", self->ob_itself.parentDirID);
232}
233
234static 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
240static PyObject *FSCatalogInfo_get_nodeID(FSCatalogInfoObject *self, void *closure)
241{
242    return Py_BuildValue("l", self->ob_itself.nodeID);
243}
244
245static 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
251static PyObject *FSCatalogInfo_get_createDate(FSCatalogInfoObject *self, void *closure)
252{
253    return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.createDate);
254}
255
256static 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
262static PyObject *FSCatalogInfo_get_contentModDate(FSCatalogInfoObject *self, void *closure)
263{
264    return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.contentModDate);
265}
266
267static 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
273static PyObject *FSCatalogInfo_get_attributeModDate(FSCatalogInfoObject *self, void *closure)
274{
275    return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.attributeModDate);
276}
277
278static 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
284static PyObject *FSCatalogInfo_get_accessDate(FSCatalogInfoObject *self, void *closure)
285{
286    return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.accessDate);
287}
288
289static 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
295static PyObject *FSCatalogInfo_get_backupDate(FSCatalogInfoObject *self, void *closure)
296{
297    return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.backupDate);
298}
299
300static 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
306static 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
312static 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
333static PyObject *FSCatalogInfo_get_valence(FSCatalogInfoObject *self, void *closure)
334{
335    return Py_BuildValue("l", self->ob_itself.valence);
336}
337
338static 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
344static PyObject *FSCatalogInfo_get_dataLogicalSize(FSCatalogInfoObject *self, void *closure)
345{
346    return Py_BuildValue("l", self->ob_itself.dataLogicalSize);
347}
348
349static 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
355static PyObject *FSCatalogInfo_get_dataPhysicalSize(FSCatalogInfoObject *self, void *closure)
356{
357    return Py_BuildValue("l", self->ob_itself.dataPhysicalSize);
358}
359
360static 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
366static PyObject *FSCatalogInfo_get_rsrcLogicalSize(FSCatalogInfoObject *self, void *closure)
367{
368    return Py_BuildValue("l", self->ob_itself.rsrcLogicalSize);
369}
370
371static 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
377static PyObject *FSCatalogInfo_get_rsrcPhysicalSize(FSCatalogInfoObject *self, void *closure)
378{
379    return Py_BuildValue("l", self->ob_itself.rsrcPhysicalSize);
380}
381
382static 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
388static PyObject *FSCatalogInfo_get_sharingFlags(FSCatalogInfoObject *self, void *closure)
389{
390    return Py_BuildValue("l", self->ob_itself.sharingFlags);
391}
392
393static 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
399static PyObject *FSCatalogInfo_get_userPrivileges(FSCatalogInfoObject *self, void *closure)
400{
401    return Py_BuildValue("b", self->ob_itself.userPrivileges);
402}
403
404static 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
410static 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
437static 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
482static 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
494static 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
545static PyTypeObject FInfo_Type;
546
547#define FInfo_Check(x) ((x)->ob_type == &FInfo_Type || PyObject_TypeCheck((x), &FInfo_Type))
548
549typedef struct FInfoObject {
550    PyObject_HEAD
551    FInfo ob_itself;
552} FInfoObject;
553
554static 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
564static 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
575static void FInfo_dealloc(FInfoObject *self)
576{
577    /* Cleanup of self->ob_itself goes here */
578    self->ob_type->tp_free((PyObject *)self);
579}
580
581static PyMethodDef FInfo_methods[] = {
582    {NULL, NULL, 0}
583};
584
585static PyObject *FInfo_get_Type(FInfoObject *self, void *closure)
586{
587    return Py_BuildValue("O&", PyMac_BuildOSType, self->ob_itself.fdType);
588}
589
590static 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
596static PyObject *FInfo_get_Creator(FInfoObject *self, void *closure)
597{
598    return Py_BuildValue("O&", PyMac_BuildOSType, self->ob_itself.fdCreator);
599}
600
601static 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
607static PyObject *FInfo_get_Flags(FInfoObject *self, void *closure)
608{
609    return Py_BuildValue("H", self->ob_itself.fdFlags);
610}
611
612static 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
618static PyObject *FInfo_get_Location(FInfoObject *self, void *closure)
619{
620    return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself.fdLocation);
621}
622
623static 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
629static PyObject *FInfo_get_Fldr(FInfoObject *self, void *closure)
630{
631    return Py_BuildValue("h", self->ob_itself.fdFldr);
632}
633
634static 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
640static 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
655static 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
670static 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
682static 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
732static PyTypeObject Alias_Type;
733
734#define Alias_Check(x) ((x)->ob_type == &Alias_Type || PyObject_TypeCheck((x), &Alias_Type))
735
736typedef struct AliasObject {
737    PyObject_HEAD
738    AliasHandle ob_itself;
739    void (*ob_freeit)(AliasHandle ptr);
740} AliasObject;
741
742static 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
753static 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
764static 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__
775static 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
797static 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
815static 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
840static 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
866static 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
891static 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
913static 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
937static 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
957static 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
972static 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
983static 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
1022static 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
1034static 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
1084static PyTypeObject FSSpec_Type;
1085
1086#define FSSpec_Check(x) ((x)->ob_type == &FSSpec_Type || PyObject_TypeCheck((x), &FSSpec_Type))
1087
1088typedef struct FSSpecObject {
1089    PyObject_HEAD
1090    FSSpec ob_itself;
1091} FSSpecObject;
1092
1093static 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
1103static void FSSpec_dealloc(FSSpecObject *self)
1104{
1105    /* Cleanup of self->ob_itself goes here */
1106    self->ob_type->tp_free((PyObject *)self);
1107}
1108
1109static 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
1127static 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
1145static 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
1167static 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
1185static 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
1198static 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
1213static 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
1229static 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
1242static 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
1255static 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
1271static 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
1287static 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
1303static 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
1318static 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
1333static 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
1351static 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
1370static 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
1382static 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
1420static 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
1427static 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
1435static 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
1447static 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
1482static 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
1494static 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
1544static PyTypeObject FSRef_Type;
1545
1546#define FSRef_Check(x) ((x)->ob_type == &FSRef_Type || PyObject_TypeCheck((x), &FSRef_Type))
1547
1548typedef struct FSRefObject {
1549    PyObject_HEAD
1550    FSRef ob_itself;
1551} FSRefObject;
1552
1553static 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
1563static void FSRef_dealloc(FSRefObject *self)
1564{
1565    /* Cleanup of self->ob_itself goes here */
1566    self->ob_type->tp_free((PyObject *)self);
1567}
1568
1569static 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
1593static 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
1609static 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
1652static 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
1699static 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
1712static 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
1730static 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
1746static 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
1770static 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
1812static 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
1831static 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
1850static 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
1869static 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
1893static 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
1912static 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
1927static 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
1945static 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
1965static 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
1976static 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
2016static 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
2023static 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
2034static 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
2069static 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
2081static 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__
2128static 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
2146static 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
2164static 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
2185static 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
2200static 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
2217static 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
2234static 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
2252static 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
2269static 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
2290static 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
2307static 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
2327static 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
2353static 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
2379static 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
2405static 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
2422static 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
2449static 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
2472static 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
2493static 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
2516static 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
2540static 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
2561static 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
2582static 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
2606static 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
2633static 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
2657static 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
2674static 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
2695static 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
2712static 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
2733static 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
2762static 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
2777static 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
2792static 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
2806static 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
2820static 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
2840static 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
2861static 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__
2880static 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
2901static 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
2927static 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
2951static 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
2978static 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
3002static 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
3030static 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
3051static 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
3078static 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
3102static 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
3126static 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
3145static 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__
3251int
3252PyMac_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
3290int
3291PyMac_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__
3331extern PyObject *
3332PyMac_BuildFSSpec(FSSpec *spec)
3333{
3334    return FSSpec_New(spec);
3335}
3336#endif /* !__LP64__ */
3337
3338extern PyObject *
3339PyMac_BuildFSRef(FSRef *spec)
3340{
3341    return FSRef_New(spec);
3342}
3343
3344
3345void 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