#include "Python.h"

#include "pymactoolbox.h"

#ifndef HAVE_OSX105_SDK

typedef SInt16 FSIORefNum;

#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\

PyErr_SetString(PyExc_NotImplementedError, \

"Not available in this shared library/OS version"); \

return NULL; \

}} while(0)

#include <Carbon/Carbon.h>

#ifdef USE_TOOLBOX_OBJECT_GLUE

#ifndef __LP64__

extern int _PyMac_GetFSSpec(PyObject *v, FSSpec *spec);

extern PyObject *_PyMac_BuildFSSpec(FSSpec *spec);

#define PyMac_BuildFSSpec _PyMac_BuildFSSpec

#endif /* __LP64__*/

extern int _PyMac_GetFSRef(PyObject *v, FSRef *fsr);

extern PyObject *_PyMac_BuildFSRef(FSRef *spec);

#define PyMac_BuildFSRef _PyMac_BuildFSRef

#define PyMac_GetFSSpec _PyMac_GetFSSpec

#define PyMac_GetFSRef _PyMac_GetFSRef

#else /* !USE_TOOLBOX_OBJECT_GLUE */

#ifndef __LP64__

extern int PyMac_GetFSSpec(PyObject *v, FSSpec *spec);

extern PyObject *PyMac_BuildFSSpec(FSSpec *spec);

#endif /* !__LP64__*/

extern int PyMac_GetFSRef(PyObject *v, FSRef *fsr);

extern PyObject *PyMac_BuildFSRef(FSRef *spec);

#endif /* !USE_TOOLBOX_OBJECT_GLUE */

static PyObject *FSRef_New(FSRef *itself);

#ifndef __LP64__

static PyObject *FInfo_New(FInfo *itself);

static PyObject *FSSpec_New(FSSpec *itself);

#define FSSpec_Convert PyMac_GetFSSpec

#endif /* !__LP64__ */

static PyObject *Alias_New(AliasHandle itself);

#ifndef __LP64__

static int FInfo_Convert(PyObject *v, FInfo *p_itself);

#endif /* !__LP64__ */

#define FSRef_Convert PyMac_GetFSRef

static int Alias_Convert(PyObject *v, AliasHandle *p_itself);

static int

UTCDateTime_Convert(PyObject *v, UTCDateTime *ptr)

{

return PyArg_Parse(v, "(HlH)", &ptr->highSeconds, &ptr->lowSeconds, &ptr->fraction);

}

static PyObject *

UTCDateTime_New(UTCDateTime *ptr)

{

return Py_BuildValue("(HlH)", ptr->highSeconds, ptr->lowSeconds, ptr->fraction);

}

#ifndef __LP64__

static int

myPyMac_GetOptFSSpecPtr(PyObject *v, FSSpec **spec)

{

if (v == Py_None) {

*spec = NULL;

return 1;

}

return PyMac_GetFSSpec(v, *spec);

}

#endif /* !__LP64__ */

static int

myPyMac_GetOptFSRefPtr(PyObject *v, FSRef **ref)

{

if (v == Py_None) {

*ref = NULL;

return 1;

}

return PyMac_GetFSRef(v, *ref);

}

static PyObject *

PyMac_BuildHFSUniStr255(HFSUniStr255 *itself)

{

return Py_BuildValue("u#", itself->unicode, itself->length);

}

#ifndef __LP64__

static OSErr

_PyMac_GetFullPathname(FSSpec *fss, char *path, int len)

{

FSRef fsr;

OSErr err;

*path = '\0';

err = FSpMakeFSRef(fss, &fsr);

if (err == fnfErr) {

/* FSSpecs can point to non-existing files, fsrefs can't. */

FSSpec fss2;

int tocopy;

err = FSMakeFSSpec(fss->vRefNum, fss->parID,

(unsigned char*)"", &fss2);

if (err)

return err;

err = FSpMakeFSRef(&fss2, &fsr);

if (err)

return err;

err = (OSErr)FSRefMakePath(&fsr, (unsigned char*)path, len-1);

if (err)

return err;

/* This part is not 100% safe: we append the filename part, but

strcat(path, "/");

tocopy = fss->name[0];

if ((strlen(path) + tocopy) >= len)

tocopy = len - strlen(path) - 1;

if (tocopy > 0)

strncat(path, (char*)fss->name+1, tocopy);

}

else {

if (err)

return err;

err = (OSErr)FSRefMakePath(&fsr, (unsigned char*)path, len);

if (err)

return err;

}

return 0;

}

#endif /* !__LP64__ */

static PyObject *File_Error;

static PyTypeObject FSCatalogInfo_Type;

#define FSCatalogInfo_Check(x) ((x)->ob_type == &FSCatalogInfo_Type || PyObject_TypeCheck((x), &FSCatalogInfo_Type))

typedef struct FSCatalogInfoObject {

PyObject_HEAD

FSCatalogInfo ob_itself;

} FSCatalogInfoObject;

static PyObject *FSCatalogInfo_New(FSCatalogInfo *itself)

{

FSCatalogInfoObject *it;

if (itself == NULL) { Py_INCREF(Py_None); return Py_None; }

it = PyObject_NEW(FSCatalogInfoObject, &FSCatalogInfo_Type);

if (it == NULL) return NULL;

it->ob_itself = *itself;

return (PyObject *)it;

}

static int FSCatalogInfo_Convert(PyObject *v, FSCatalogInfo *p_itself)

{

if (!FSCatalogInfo_Check(v))

{

PyErr_SetString(PyExc_TypeError, "FSCatalogInfo required");

return 0;

}

*p_itself = ((FSCatalogInfoObject *)v)->ob_itself;

return 1;

}

static void FSCatalogInfo_dealloc(FSCatalogInfoObject *self)

{

/* Cleanup of self->ob_itself goes here */

self->ob_type->tp_free((PyObject *)self);

}

static PyMethodDef FSCatalogInfo_methods[] = {

{NULL, NULL, 0}

};

static PyObject *FSCatalogInfo_get_nodeFlags(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("H", self->ob_itself.nodeFlags);

}

static int FSCatalogInfo_set_nodeFlags(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "H", &self->ob_itself.nodeFlags)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_volume(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("h", self->ob_itself.volume);

}

static int FSCatalogInfo_set_volume(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "h", &self->ob_itself.volume)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_parentDirID(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("l", self->ob_itself.parentDirID);

}

static int FSCatalogInfo_set_parentDirID(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "l", &self->ob_itself.parentDirID)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_nodeID(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("l", self->ob_itself.nodeID);

}

static int FSCatalogInfo_set_nodeID(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "l", &self->ob_itself.nodeID)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_createDate(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.createDate);

}

static int FSCatalogInfo_set_createDate(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.createDate)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_contentModDate(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.contentModDate);

}

static int FSCatalogInfo_set_contentModDate(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.contentModDate)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_attributeModDate(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.attributeModDate);

}

static int FSCatalogInfo_set_attributeModDate(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.attributeModDate)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_accessDate(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.accessDate);

}

static int FSCatalogInfo_set_accessDate(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.accessDate)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_backupDate(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.backupDate);

}

static int FSCatalogInfo_set_backupDate(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.backupDate)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_permissions(FSCatalogInfoObject *self, void *closure)

{

FSPermissionInfo* info = (FSPermissionInfo*)&(self->ob_itself.permissions);

return Py_BuildValue("(llll)", info->userID, info->groupID, info->userAccess, info->mode);

}

static int FSCatalogInfo_set_permissions(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

long userID;

long groupID;

long userAccess;

long mode;

int r;

FSPermissionInfo* info = (FSPermissionInfo*)&(self->ob_itself.permissions);

r = PyArg_Parse(v, "(llll)", &userID, &groupID, &userAccess, &mode);

if (!r) {

return -1;

}

info->userID = userID;

info->groupID = groupID;

info->userAccess = userAccess;

info->mode = mode;

return 0;

}

static PyObject *FSCatalogInfo_get_valence(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("l", self->ob_itself.valence);

}

static int FSCatalogInfo_set_valence(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "l", &self->ob_itself.valence)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_dataLogicalSize(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("l", self->ob_itself.dataLogicalSize);

}

static int FSCatalogInfo_set_dataLogicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "l", &self->ob_itself.dataLogicalSize)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_dataPhysicalSize(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("l", self->ob_itself.dataPhysicalSize);

}

static int FSCatalogInfo_set_dataPhysicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "l", &self->ob_itself.dataPhysicalSize)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_rsrcLogicalSize(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("l", self->ob_itself.rsrcLogicalSize);

}

static int FSCatalogInfo_set_rsrcLogicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "l", &self->ob_itself.rsrcLogicalSize)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_rsrcPhysicalSize(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("l", self->ob_itself.rsrcPhysicalSize);

}

static int FSCatalogInfo_set_rsrcPhysicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "l", &self->ob_itself.rsrcPhysicalSize)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_sharingFlags(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("l", self->ob_itself.sharingFlags);

}

static int FSCatalogInfo_set_sharingFlags(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "l", &self->ob_itself.sharingFlags)-1;

return 0;

}

static PyObject *FSCatalogInfo_get_userPrivileges(FSCatalogInfoObject *self, void *closure)

{

return Py_BuildValue("b", self->ob_itself.userPrivileges);

}

static int FSCatalogInfo_set_userPrivileges(FSCatalogInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "b", &self->ob_itself.userPrivileges)-1;

return 0;

}

static PyGetSetDef FSCatalogInfo_getsetlist[] = {

{"nodeFlags", (getter)FSCatalogInfo_get_nodeFlags, (setter)FSCatalogInfo_set_nodeFlags, NULL},

{"volume", (getter)FSCatalogInfo_get_volume, (setter)FSCatalogInfo_set_volume, NULL},

{"parentDirID", (getter)FSCatalogInfo_get_parentDirID, (setter)FSCatalogInfo_set_parentDirID, NULL},

{"nodeID", (getter)FSCatalogInfo_get_nodeID, (setter)FSCatalogInfo_set_nodeID, NULL},

{"createDate", (getter)FSCatalogInfo_get_createDate, (setter)FSCatalogInfo_set_createDate, NULL},

{"contentModDate", (getter)FSCatalogInfo_get_contentModDate, (setter)FSCatalogInfo_set_contentModDate, NULL},

{"attributeModDate", (getter)FSCatalogInfo_get_attributeModDate, (setter)FSCatalogInfo_set_attributeModDate, NULL},

{"accessDate", (getter)FSCatalogInfo_get_accessDate, (setter)FSCatalogInfo_set_accessDate, NULL},

{"backupDate", (getter)FSCatalogInfo_get_backupDate, (setter)FSCatalogInfo_set_backupDate, NULL},

{"permissions", (getter)FSCatalogInfo_get_permissions, (setter)FSCatalogInfo_set_permissions, NULL},

{"valence", (getter)FSCatalogInfo_get_valence, (setter)FSCatalogInfo_set_valence, NULL},

{"dataLogicalSize", (getter)FSCatalogInfo_get_dataLogicalSize, (setter)FSCatalogInfo_set_dataLogicalSize, NULL},

{"dataPhysicalSize", (getter)FSCatalogInfo_get_dataPhysicalSize, (setter)FSCatalogInfo_set_dataPhysicalSize, NULL},

{"rsrcLogicalSize", (getter)FSCatalogInfo_get_rsrcLogicalSize, (setter)FSCatalogInfo_set_rsrcLogicalSize, NULL},

{"rsrcPhysicalSize", (getter)FSCatalogInfo_get_rsrcPhysicalSize, (setter)FSCatalogInfo_set_rsrcPhysicalSize, NULL},

{"sharingFlags", (getter)FSCatalogInfo_get_sharingFlags, (setter)FSCatalogInfo_set_sharingFlags, NULL},

{"userPrivileges", (getter)FSCatalogInfo_get_userPrivileges, (setter)FSCatalogInfo_set_userPrivileges, NULL},

{NULL, NULL, NULL, NULL},

};

#define FSCatalogInfo_compare NULL

#define FSCatalogInfo_repr NULL

#define FSCatalogInfo_hash NULL

static int FSCatalogInfo_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)

{

static char *kw[] = {

"nodeFlags",

"volume",

"parentDirID",

"nodeID",

"createDate",

"contentModDate",

"atributeModDate",

"accessDate",

"backupDate",

"valence",

"dataLogicalSize",

"dataPhysicalSize",

"rsrcLogicalSize",

"rsrcPhysicalSize",

"sharingFlags",

"userPrivileges"

, 0};

if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|HhllO&O&O&O&O&llllllb", kw, &((FSCatalogInfoObject *)_self)->ob_itself.nodeFlags,

&((FSCatalogInfoObject *)_self)->ob_itself.volume,

&((FSCatalogInfoObject *)_self)->ob_itself.parentDirID,

&((FSCatalogInfoObject *)_self)->ob_itself.nodeID,

UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.createDate,

UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.contentModDate,

UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.attributeModDate,

UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.accessDate,

UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.backupDate,

&((FSCatalogInfoObject *)_self)->ob_itself.valence,

&((FSCatalogInfoObject *)_self)->ob_itself.dataLogicalSize,

&((FSCatalogInfoObject *)_self)->ob_itself.dataPhysicalSize,

&((FSCatalogInfoObject *)_self)->ob_itself.rsrcLogicalSize,

&((FSCatalogInfoObject *)_self)->ob_itself.rsrcPhysicalSize,

&((FSCatalogInfoObject *)_self)->ob_itself.sharingFlags,

&((FSCatalogInfoObject *)_self)->ob_itself.userPrivileges))

{

return -1;

}

return 0;

}

#define FSCatalogInfo_tp_alloc PyType_GenericAlloc

static PyObject *FSCatalogInfo_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

{

PyObject *self;

if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;

memset(&((FSCatalogInfoObject *)self)->ob_itself, 0, sizeof(FSCatalogInfo));

return self;

}

#define FSCatalogInfo_tp_free PyObject_Del

static PyTypeObject FSCatalogInfo_Type = {

PyObject_HEAD_INIT(NULL)

0, /*ob_size*/

"Carbon.File.FSCatalogInfo", /*tp_name*/

sizeof(FSCatalogInfoObject), /*tp_basicsize*/

0, /*tp_itemsize*/

/* methods */

(destructor) FSCatalogInfo_dealloc, /*tp_dealloc*/

0, /*tp_print*/

(getattrfunc)0, /*tp_getattr*/

(setattrfunc)0, /*tp_setattr*/

(cmpfunc) FSCatalogInfo_compare, /*tp_compare*/

(reprfunc) FSCatalogInfo_repr, /*tp_repr*/

(PyNumberMethods *)0, /* tp_as_number */

(PySequenceMethods *)0, /* tp_as_sequence */

(PyMappingMethods *)0, /* tp_as_mapping */

(hashfunc) FSCatalogInfo_hash, /*tp_hash*/

0, /*tp_call*/

0, /*tp_str*/

PyObject_GenericGetAttr, /*tp_getattro*/

PyObject_GenericSetAttr, /*tp_setattro */

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

0, /*tp_doc*/

0, /*tp_traverse*/

0, /*tp_clear*/

0, /*tp_richcompare*/

0, /*tp_weaklistoffset*/

0, /*tp_iter*/

0, /*tp_iternext*/

FSCatalogInfo_methods, /* tp_methods */

0, /*tp_members*/

FSCatalogInfo_getsetlist, /*tp_getset*/

0, /*tp_base*/

0, /*tp_dict*/

0, /*tp_descr_get*/

0, /*tp_descr_set*/

0, /*tp_dictoffset*/

FSCatalogInfo_tp_init, /* tp_init */

FSCatalogInfo_tp_alloc, /* tp_alloc */

FSCatalogInfo_tp_new, /* tp_new */

FSCatalogInfo_tp_free, /* tp_free */

};

#ifndef __LP64__

static PyTypeObject FInfo_Type;

#define FInfo_Check(x) ((x)->ob_type == &FInfo_Type || PyObject_TypeCheck((x), &FInfo_Type))

typedef struct FInfoObject {

PyObject_HEAD

FInfo ob_itself;

} FInfoObject;

static PyObject *FInfo_New(FInfo *itself)

{

FInfoObject *it;

if (itself == NULL) return PyMac_Error(resNotFound);

it = PyObject_NEW(FInfoObject, &FInfo_Type);

if (it == NULL) return NULL;

it->ob_itself = *itself;

return (PyObject *)it;

}

static int FInfo_Convert(PyObject *v, FInfo *p_itself)

{

if (!FInfo_Check(v))

{

PyErr_SetString(PyExc_TypeError, "FInfo required");

return 0;

}

*p_itself = ((FInfoObject *)v)->ob_itself;

return 1;

}

static void FInfo_dealloc(FInfoObject *self)

{

/* Cleanup of self->ob_itself goes here */

self->ob_type->tp_free((PyObject *)self);

}

static PyMethodDef FInfo_methods[] = {

{NULL, NULL, 0}

};

static PyObject *FInfo_get_Type(FInfoObject *self, void *closure)

{

return Py_BuildValue("O&", PyMac_BuildOSType, self->ob_itself.fdType);

}

static int FInfo_set_Type(FInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "O&", PyMac_GetOSType, &self->ob_itself.fdType)-1;

return 0;

}

static PyObject *FInfo_get_Creator(FInfoObject *self, void *closure)

{

return Py_BuildValue("O&", PyMac_BuildOSType, self->ob_itself.fdCreator);

}

static int FInfo_set_Creator(FInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "O&", PyMac_GetOSType, &self->ob_itself.fdCreator)-1;

return 0;

}

static PyObject *FInfo_get_Flags(FInfoObject *self, void *closure)

{

return Py_BuildValue("H", self->ob_itself.fdFlags);

}

static int FInfo_set_Flags(FInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "H", &self->ob_itself.fdFlags)-1;

return 0;

}

static PyObject *FInfo_get_Location(FInfoObject *self, void *closure)

{

return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself.fdLocation);

}

static int FInfo_set_Location(FInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "O&", PyMac_GetPoint, &self->ob_itself.fdLocation)-1;

return 0;

}

static PyObject *FInfo_get_Fldr(FInfoObject *self, void *closure)

{

return Py_BuildValue("h", self->ob_itself.fdFldr);

}

static int FInfo_set_Fldr(FInfoObject *self, PyObject *v, void *closure)

{

return PyArg_Parse(v, "h", &self->ob_itself.fdFldr)-1;

return 0;

}

static PyGetSetDef FInfo_getsetlist[] = {

{"Type", (getter)FInfo_get_Type, (setter)FInfo_set_Type, "4-char file type"},

{"Creator", (getter)FInfo_get_Creator, (setter)FInfo_set_Creator, "4-char file creator"},

{"Flags", (getter)FInfo_get_Flags, (setter)FInfo_set_Flags, "Finder flag bits"},

{"Location", (getter)FInfo_get_Location, (setter)FInfo_set_Location, "(x, y) location of the file's icon in its parent finder window"},

{"Fldr", (getter)FInfo_get_Fldr, (setter)FInfo_set_Fldr, "Original folder, for 'put away'"},

{NULL, NULL, NULL, NULL},

};

#define FInfo_compare NULL

#define FInfo_repr NULL

#define FInfo_hash NULL

static int FInfo_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)

{

FInfo *itself = NULL;

static char *kw[] = {"itself", 0};

if (PyArg_ParseTupleAndKeywords(_args, _kwds, "|O&", kw, FInfo_Convert, &itself))

{

if (itself) memcpy(&((FInfoObject *)_self)->ob_itself, itself, sizeof(FInfo));

return 0;

}

return -1;

}

#define FInfo_tp_alloc PyType_GenericAlloc

static PyObject *FInfo_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

{

PyObject *self;

if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;

memset(&((FInfoObject *)self)->ob_itself, 0, sizeof(FInfo));

return self;

}

#define FInfo_tp_free PyObject_Del

static PyTypeObject FInfo_Type = {

PyObject_HEAD_INIT(NULL)

0, /*ob_size*/

"Carbon.File.FInfo", /*tp_name*/

sizeof(FInfoObject), /*tp_basicsize*/

0, /*tp_itemsize*/

/* methods */

(destructor) FInfo_dealloc, /*tp_dealloc*/

0, /*tp_print*/

(getattrfunc)0, /*tp_getattr*/

(setattrfunc)0, /*tp_setattr*/

(cmpfunc) FInfo_compare, /*tp_compare*/

(reprfunc) FInfo_repr, /*tp_repr*/

(PyNumberMethods *)0, /* tp_as_number */

(PySequenceMethods *)0, /* tp_as_sequence */

(PyMappingMethods *)0, /* tp_as_mapping */

(hashfunc) FInfo_hash, /*tp_hash*/

0, /*tp_call*/

0, /*tp_str*/

PyObject_GenericGetAttr, /*tp_getattro*/

PyObject_GenericSetAttr, /*tp_setattro */

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

0, /*tp_doc*/

0, /*tp_traverse*/

0, /*tp_clear*/

0, /*tp_richcompare*/

0, /*tp_weaklistoffset*/

0, /*tp_iter*/

0, /*tp_iternext*/

FInfo_methods, /* tp_methods */

0, /*tp_members*/

FInfo_getsetlist, /*tp_getset*/

0, /*tp_base*/

0, /*tp_dict*/

0, /*tp_descr_get*/

0, /*tp_descr_set*/

0, /*tp_dictoffset*/

FInfo_tp_init, /* tp_init */

FInfo_tp_alloc, /* tp_alloc */

FInfo_tp_new, /* tp_new */

FInfo_tp_free, /* tp_free */

};

#endif /* !__LP64__ */

static PyTypeObject Alias_Type;

#define Alias_Check(x) ((x)->ob_type == &Alias_Type || PyObject_TypeCheck((x), &Alias_Type))

typedef struct AliasObject {

} AliasObject;

static PyObject *Alias_New(AliasHandle itself)

{

AliasObject *it;

if (itself == NULL) return PyMac_Error(resNotFound);

it = PyObject_NEW(AliasObject, &Alias_Type);

if (it == NULL) return NULL;

it->ob_itself = itself;

it->ob_freeit = NULL;

return (PyObject *)it;

}

static int Alias_Convert(PyObject *v, AliasHandle *p_itself)

{

if (!Alias_Check(v))

{

PyErr_SetString(PyExc_TypeError, "Alias required");

return 0;

}

*p_itself = ((AliasObject *)v)->ob_itself;

return 1;

}

static void Alias_dealloc(AliasObject *self)

{

if (self->ob_freeit && self->ob_itself)

{

self->ob_freeit(self->ob_itself);

}

self->ob_itself = NULL;

self->ob_type->tp_free((PyObject *)self);

}

#ifndef __LP64__

static PyObject *Alias_ResolveAlias(AliasObject *_self, PyObject *_args)

{

PyObject *_res = NULL;

OSErr _err;

FSSpec fromFile__buf__;

FSSpec *fromFile = &fromFile__buf__;

FSSpec target;

Boolean wasChanged;

if (!PyArg_ParseTuple(_args, "O&",

myPyMac_GetOptFSSpecPtr, &fromFile))

return NULL;

_err = ResolveAlias(fromFile,

_self->ob_itself,

&target,

&wasChanged);

if (_err != noErr) return PyMac_Error(_err);

_res = Py_BuildValue("O&b",

FSSpec_New, &target,

wasChanged);

return _res;

}

static PyObject *Alias_GetAliasInfo(AliasObject *_self, PyObject *_args)

{

PyObject *_res = NULL;

OSErr _err;

AliasInfoType index;

Str63 theString;

if (!PyArg_ParseTuple(_args, "h",

&index))

return NULL;

_err = GetAliasInfo(_self->ob_itself,

index,

theString);

if (_err != noErr) return PyMac_Error(_err);

_res = Py_BuildValue("O&",

PyMac_BuildStr255, theString);

return _res;

}

static PyObject *Alias_ResolveAliasWithMountFlags(AliasObject *_self, PyObject *_args)

{

PyObject *_res = NULL;

OSErr _err;

FSSpec fromFile__buf__;

FSSpec *fromFile = &fromFile__buf__;

FSSpec target;

Boolean wasChanged;

unsigned long mountFlags;

if (!PyArg_ParseTuple(_args, "O&l",

myPyMac_GetOptFSSpecPtr, &fromFile,

&mountFlags))

return NULL;

_err = ResolveAliasWithMountFlags(fromFile,

_self->ob_itself,

&target,

&wasChanged,

mountFlags);

if (_err != noErr) return PyMac_Error(_err);

_res = Py_BuildValue("O&b",

FSSpec_New, &target,

wasChanged);

return _res;

}

static PyObject *Alias_FollowFinderAlias(AliasObject *_self, PyObject *_args)

{

PyObject *_res = NULL;

OSErr _err;

FSSpec fromFile__buf__;

FSSpec *fromFile = &fromFile__buf__;

Boolean logon;

FSSpec target;

Boolean wasChanged;

if (!PyArg_ParseTuple(_args, "O&b",

myPyMac_GetOptFSSpecPtr, &fromFile,

&logon))

return NULL;

_err = FollowFinderAlias(fromFile,

_self->ob_itself,

logon,

&target,

&wasChanged);

if (_err != noErr) return PyMac_Error(_err);

_res = Py_BuildValue("O&b",

FSSpec_New, &target,

wasChanged);

return _res;

}

#endif /* !__LP64__ */

static PyObject *Alias_FSResolveAliasWithMountFlags(AliasObject *_self, PyObject *_args)

{

PyObject *_res = NULL;

OSErr _err;

FSRef fromFile__buf__;

FSRef *fromFile = &fromFile__buf__;

FSRef target;

Boolean wasChanged;

unsigned long mountFlags;

if (!PyArg_ParseTuple(_args, "O&l",

myPyMac_GetOptFSRefPtr, &fromFile,

&mountFlags))

return NULL;

_err = FSResolveAliasWithMountFlags(fromFile,

_self->ob_itself,

&target,

&wasChanged,

mountFlags);

if (_err != noErr) return PyMac_Error(_err);

_res = Py_BuildValue("O&b",

FSRef_New, &target,

wasChanged);

return _res;

}

static PyObject *Alias_FSResolveAlias(AliasObject *_self, PyObject *_args)

{

PyObject *_res = NULL;

OSErr _err;

FSRef fromFile__buf__;

FSRef *fromFile = &fromFile__buf__;

FSRef target;

Boolean wasChanged;

if (!PyArg_ParseTuple(_args, "O&",

myPyMac_GetOptFSRefPtr, &fromFile))

return NULL;

_err = FSResolveAlias(fromFile,

_self->ob_itself,

&target,

&wasChanged);

if (_err != noErr) return PyMac_Error(_err);

_res = Py_BuildValue("O&b",

FSRef_New, &target,

wasChanged);

return _res;

}

static PyObject *Alias_FSFollowFinderAlias(AliasObject *_self, PyObject *_args)

{

PyObject *_res = NULL;

OSErr _err;

FSRef fromFile;

Boolean logon;

FSRef target;

Boolean wasChanged;

if (!PyArg_ParseTuple(_args, "b",

&logon))

return NULL;

_err = FSFollowFinderAlias(&fromFile,

_self->ob_itself,

logon,

&target,

&wasChanged);

if (_err != noErr) return PyMac_Error(_err);

_res = Py_BuildValue("O&O&b",

FSRef_New, &fromFile,

FSRef_New, &target,

wasChanged);

return _res;

}

static PyMethodDef Alias_methods[] = {

#ifndef __LP64__

{"ResolveAlias", (PyCFunction)Alias_ResolveAlias, 1,

PyDoc_STR("(FSSpec fromFile) -> (FSSpec target, Boolean wasChanged)")},

{"GetAliasInfo", (PyCFunction)Alias_GetAliasInfo, 1,

PyDoc_STR("(AliasInfoType index) -> (Str63 theString)")},

{"ResolveAliasWithMountFlags", (PyCFunction)Alias_ResolveAliasWithMountFlags, 1,

PyDoc_STR("(FSSpec fromFile, unsigned long mountFlags) -> (FSSpec target, Boolean wasChanged)")},

{"FollowFinderAlias", (PyCFunction)Alias_FollowFinderAlias, 1,

PyDoc_STR("(FSSpec fromFile, Boolean logon) -> (FSSpec target, Boolean wasChanged)")},

#endif /* !__LP64__ */

{"FSResolveAliasWithMountFlags", (PyCFunction)Alias_FSResolveAliasWithMountFlags, 1,

PyDoc_STR("(FSRef fromFile, unsigned long mountFlags) -> (FSRef target, Boolean wasChanged)")},

{"FSResolveAlias", (PyCFunction)Alias_FSResolveAlias, 1,

PyDoc_STR("(FSRef fromFile) -> (FSRef target, Boolean wasChanged)")},

{"FSFollowFinderAlias", (PyCFunction)Alias_FSFollowFinderAlias, 1,

PyDoc_STR("(Boolean logon) -> (FSRef fromFile, FSRef target, Boolean wasChanged)")},

{NULL, NULL, 0}

};

static PyObject *Alias_get_data(AliasObject *self, void *closure)

{

int size;

PyObject *rv;

size = GetHandleSize((Handle)self->ob_itself);

HLock((Handle)self->ob_itself);

rv = PyString_FromStringAndSize(*(Handle)self->ob_itself, size);

HUnlock((Handle)self->ob_itself);

return rv;

}

#define Alias_set_data NULL

static PyGetSetDef Alias_getsetlist[] = {

{"data", (getter)Alias_get_data, (setter)Alias_set_data, "Raw data of the alias object"},

{NULL, NULL, NULL, NULL},

};

#define Alias_compare NULL

#define Alias_repr NULL

#define Alias_hash NULL

static int Alias_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)

{

AliasHandle itself = NULL;

char *rawdata = NULL;

int rawdatalen = 0;

Handle h;

static char *kw[] = {"itself", "rawdata", 0};

if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|O&s#", kw, Alias_Convert, &itself, &rawdata, &rawdatalen))

return -1;

if (itself && rawdata)

{

PyErr_SetString(PyExc_TypeError, "Only one of itself or rawdata may be specified");

return -1;

}

if (!itself && !rawdata)

{

PyErr_SetString(PyExc_TypeError, "One of itself or rawdata must be specified");