PageRenderTime 175ms CodeModel.GetById 3ms app.highlight 154ms RepoModel.GetById 1ms app.codeStats 0ms

/Mac/Modules/file/_Filemodule.c

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