source: python/trunk/Mac/Modules/file/_Filemodule.c

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 104.1 KB
Line 
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
Note: See TracBrowser for help on using the repository browser.