← Back to branch summary

~malept/ubuntu/lucid/python2.6/dev-dependency-fix

« back to all changes in this revision

Viewing changes to Mac/Modules/file/_Filemodule.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-02-13 12:51:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090213125100-uufgcb9yeqzujpqw
Tags: upstream-2.6.1
Import upstream version 2.6.1

Show diffs side-by-side

added added

removed removed

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