3411 lines
97 KiB
C
3411 lines
97 KiB
C
|
|
/* ========================== Module _File ========================== */
|
|
|
|
#include "Python.h"
|
|
|
|
|
|
|
|
#include "pymactoolbox.h"
|
|
|
|
#ifndef HAVE_MACOS105_SDK
|
|
typedef SInt16 FSIORefNum;
|
|
#endif
|
|
|
|
/* Macro to test whether a weak-loaded CFM function exists */
|
|
#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 */
|
|
|
|
/* Forward declarations */
|
|
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);
|
|
|
|
/*
|
|
** UTCDateTime records
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
** Optional fsspec and fsref pointers. None will pass NULL
|
|
*/
|
|
#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);
|
|
}
|
|
|
|
/*
|
|
** Parse/generate objsect
|
|
*/
|
|
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
|
|
** I'm not sure that we don't run afoul of the various 8bit
|
|
** encodings here. Will have to look this up at some point...
|
|
*/
|
|
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;
|
|
|
|
/* ------------------- Object type FSCatalogInfo -------------------- */
|
|
|
|
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 */
|
|
};
|
|
|
|
/* ----------------- End object type FSCatalogInfo ------------------ */
|
|
|
|
|
|
/* ----------------------- Object type FInfo ------------------------ */
|
|
|
|
#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__ */
|
|
/* --------------------- End object type FInfo ---------------------- */
|
|
|
|
|
|
/* ----------------------- Object type Alias ------------------------ */
|
|
|
|
static PyTypeObject Alias_Type;
|
|
|
|
#define Alias_Check(x) ((x)->ob_type == &Alias_Type || PyObject_TypeCheck((x), &Alias_Type))
|
|
|
|
typedef struct AliasObject {
|
|
PyObject_HEAD
|
|
AliasHandle ob_itself;
|
|
void (*ob_freeit)(AliasHandle ptr);
|
|
} 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 = PyBytes_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");
|
|
return -1;
|
|
}
|
|
if (rawdata)
|
|
{
|
|
if ((h = NewHandle(rawdatalen)) == NULL)
|
|
{
|
|
PyErr_NoMemory();
|
|
return -1;
|
|
}
|
|
HLock(h);
|
|
memcpy((char *)*h, rawdata, rawdatalen);
|
|
HUnlock(h);
|
|
((AliasObject *)_self)->ob_itself = (AliasHandle)h;
|
|
return 0;
|
|
}
|
|
((AliasObject *)_self)->ob_itself = itself;
|
|
return 0;
|
|
}
|
|
|
|
#define Alias_tp_alloc PyType_GenericAlloc
|
|
|
|
static PyObject *Alias_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
|
|
{
|
|
PyObject *self;
|
|
|
|
if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
|
|
((AliasObject *)self)->ob_itself = NULL;
|
|
return self;
|
|
}
|
|
|
|
#define Alias_tp_free PyObject_Del
|
|
|
|
|
|
static PyTypeObject Alias_Type = {
|
|
PyObject_HEAD_INIT(NULL)
|
|
0, /*ob_size*/
|
|
"Carbon.File.Alias", /*tp_name*/
|
|
sizeof(AliasObject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor) Alias_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
(getattrfunc)0, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc) Alias_compare, /*tp_compare*/
|
|
(reprfunc) Alias_repr, /*tp_repr*/
|
|
(PyNumberMethods *)0, /* tp_as_number */
|
|
(PySequenceMethods *)0, /* tp_as_sequence */
|
|
(PyMappingMethods *)0, /* tp_as_mapping */
|
|
(hashfunc) Alias_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*/
|
|
Alias_methods, /* tp_methods */
|
|
0, /*tp_members*/
|
|
Alias_getsetlist, /*tp_getset*/
|
|
0, /*tp_base*/
|
|
0, /*tp_dict*/
|
|
0, /*tp_descr_get*/
|
|
0, /*tp_descr_set*/
|
|
0, /*tp_dictoffset*/
|
|
Alias_tp_init, /* tp_init */
|
|
Alias_tp_alloc, /* tp_alloc */
|
|
Alias_tp_new, /* tp_new */
|
|
Alias_tp_free, /* tp_free */
|
|
};
|
|
|
|
/* --------------------- End object type Alias ---------------------- */
|
|
|
|
|
|
/* ----------------------- Object type FSSpec ----------------------- */
|
|
#ifndef __LP64__
|
|
|
|
static PyTypeObject FSSpec_Type;
|
|
|
|
#define FSSpec_Check(x) ((x)->ob_type == &FSSpec_Type || PyObject_TypeCheck((x), &FSSpec_Type))
|
|
|
|
typedef struct FSSpecObject {
|
|
PyObject_HEAD
|
|
FSSpec ob_itself;
|
|
} FSSpecObject;
|
|
|
|
static PyObject *FSSpec_New(FSSpec *itself)
|
|
{
|
|
FSSpecObject *it;
|
|
if (itself == NULL) return PyMac_Error(resNotFound);
|
|
it = PyObject_NEW(FSSpecObject, &FSSpec_Type);
|
|
if (it == NULL) return NULL;
|
|
it->ob_itself = *itself;
|
|
return (PyObject *)it;
|
|
}
|
|
|
|
static void FSSpec_dealloc(FSSpecObject *self)
|
|
{
|
|
/* Cleanup of self->ob_itself goes here */
|
|
self->ob_type->tp_free((PyObject *)self);
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpOpenDF(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
SInt8 permission;
|
|
short refNum;
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&permission))
|
|
return NULL;
|
|
_err = FSpOpenDF(&_self->ob_itself,
|
|
permission,
|
|
&refNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("h",
|
|
refNum);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpOpenRF(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
SInt8 permission;
|
|
short refNum;
|
|
if (!PyArg_ParseTuple(_args, "b",
|
|
&permission))
|
|
return NULL;
|
|
_err = FSpOpenRF(&_self->ob_itself,
|
|
permission,
|
|
&refNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("h",
|
|
refNum);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpCreate(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
OSType creator;
|
|
OSType fileType;
|
|
ScriptCode scriptTag;
|
|
if (!PyArg_ParseTuple(_args, "O&O&h",
|
|
PyMac_GetOSType, &creator,
|
|
PyMac_GetOSType, &fileType,
|
|
&scriptTag))
|
|
return NULL;
|
|
_err = FSpCreate(&_self->ob_itself,
|
|
creator,
|
|
fileType,
|
|
scriptTag);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpDirCreate(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
ScriptCode scriptTag;
|
|
long createdDirID;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&scriptTag))
|
|
return NULL;
|
|
_err = FSpDirCreate(&_self->ob_itself,
|
|
scriptTag,
|
|
&createdDirID);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
createdDirID);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpDelete(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = FSpDelete(&_self->ob_itself);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpGetFInfo(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FInfo fndrInfo;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = FSpGetFInfo(&_self->ob_itself,
|
|
&fndrInfo);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
FInfo_New, &fndrInfo);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpSetFInfo(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FInfo fndrInfo;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
FInfo_Convert, &fndrInfo))
|
|
return NULL;
|
|
_err = FSpSetFInfo(&_self->ob_itself,
|
|
&fndrInfo);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpSetFLock(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = FSpSetFLock(&_self->ob_itself);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpRstFLock(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = FSpRstFLock(&_self->ob_itself);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpRename(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
Str255 newName;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetStr255, newName))
|
|
return NULL;
|
|
_err = FSpRename(&_self->ob_itself,
|
|
newName);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpCatMove(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSSpec dest;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
FSSpec_Convert, &dest))
|
|
return NULL;
|
|
_err = FSpCatMove(&_self->ob_itself,
|
|
&dest);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpExchangeFiles(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSSpec dest;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
FSSpec_Convert, &dest))
|
|
return NULL;
|
|
_err = FSpExchangeFiles(&_self->ob_itself,
|
|
&dest);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_FSpMakeFSRef(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSRef newRef;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = FSpMakeFSRef(&_self->ob_itself,
|
|
&newRef);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
FSRef_New, &newRef);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_NewAliasMinimal(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AliasHandle alias;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = NewAliasMinimal(&_self->ob_itself,
|
|
&alias);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
Alias_New, alias);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_IsAliasFile(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
Boolean aliasFileFlag;
|
|
Boolean folderFlag;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = IsAliasFile(&_self->ob_itself,
|
|
&aliasFileFlag,
|
|
&folderFlag);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("bb",
|
|
aliasFileFlag,
|
|
folderFlag);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSSpec_as_pathname(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
|
|
char strbuf[1024];
|
|
OSErr err;
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
err = _PyMac_GetFullPathname(&_self->ob_itself, strbuf, sizeof(strbuf));
|
|
if ( err ) {
|
|
PyMac_Error(err);
|
|
return NULL;
|
|
}
|
|
_res = PyBytes_FromString(strbuf);
|
|
return _res;
|
|
|
|
}
|
|
|
|
static PyObject *FSSpec_as_tuple(FSSpecObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_res = Py_BuildValue("(iis#)", _self->ob_itself.vRefNum, _self->ob_itself.parID,
|
|
&_self->ob_itself.name[1], _self->ob_itself.name[0]);
|
|
return _res;
|
|
|
|
}
|
|
|
|
static PyMethodDef FSSpec_methods[] = {
|
|
{"FSpOpenDF", (PyCFunction)FSSpec_FSpOpenDF, 1,
|
|
PyDoc_STR("(SInt8 permission) -> (short refNum)")},
|
|
{"FSpOpenRF", (PyCFunction)FSSpec_FSpOpenRF, 1,
|
|
PyDoc_STR("(SInt8 permission) -> (short refNum)")},
|
|
{"FSpCreate", (PyCFunction)FSSpec_FSpCreate, 1,
|
|
PyDoc_STR("(OSType creator, OSType fileType, ScriptCode scriptTag) -> None")},
|
|
{"FSpDirCreate", (PyCFunction)FSSpec_FSpDirCreate, 1,
|
|
PyDoc_STR("(ScriptCode scriptTag) -> (long createdDirID)")},
|
|
{"FSpDelete", (PyCFunction)FSSpec_FSpDelete, 1,
|
|
PyDoc_STR("() -> None")},
|
|
{"FSpGetFInfo", (PyCFunction)FSSpec_FSpGetFInfo, 1,
|
|
PyDoc_STR("() -> (FInfo fndrInfo)")},
|
|
{"FSpSetFInfo", (PyCFunction)FSSpec_FSpSetFInfo, 1,
|
|
PyDoc_STR("(FInfo fndrInfo) -> None")},
|
|
{"FSpSetFLock", (PyCFunction)FSSpec_FSpSetFLock, 1,
|
|
PyDoc_STR("() -> None")},
|
|
{"FSpRstFLock", (PyCFunction)FSSpec_FSpRstFLock, 1,
|
|
PyDoc_STR("() -> None")},
|
|
{"FSpRename", (PyCFunction)FSSpec_FSpRename, 1,
|
|
PyDoc_STR("(Str255 newName) -> None")},
|
|
{"FSpCatMove", (PyCFunction)FSSpec_FSpCatMove, 1,
|
|
PyDoc_STR("(FSSpec dest) -> None")},
|
|
{"FSpExchangeFiles", (PyCFunction)FSSpec_FSpExchangeFiles, 1,
|
|
PyDoc_STR("(FSSpec dest) -> None")},
|
|
{"FSpMakeFSRef", (PyCFunction)FSSpec_FSpMakeFSRef, 1,
|
|
PyDoc_STR("() -> (FSRef newRef)")},
|
|
{"NewAliasMinimal", (PyCFunction)FSSpec_NewAliasMinimal, 1,
|
|
PyDoc_STR("() -> (AliasHandle alias)")},
|
|
{"IsAliasFile", (PyCFunction)FSSpec_IsAliasFile, 1,
|
|
PyDoc_STR("() -> (Boolean aliasFileFlag, Boolean folderFlag)")},
|
|
{"as_pathname", (PyCFunction)FSSpec_as_pathname, 1,
|
|
PyDoc_STR("() -> string")},
|
|
{"as_tuple", (PyCFunction)FSSpec_as_tuple, 1,
|
|
PyDoc_STR("() -> (vRefNum, dirID, name)")},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
static PyObject *FSSpec_get_data(FSSpecObject *self, void *closure)
|
|
{
|
|
return PyBytes_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));
|
|
}
|
|
|
|
#define FSSpec_set_data NULL
|
|
|
|
static PyGetSetDef FSSpec_getsetlist[] = {
|
|
{"data", (getter)FSSpec_get_data, (setter)FSSpec_set_data, "Raw data of the FSSpec object"},
|
|
{NULL, NULL, NULL, NULL},
|
|
};
|
|
|
|
|
|
#define FSSpec_compare NULL
|
|
|
|
static PyObject * FSSpec_repr(FSSpecObject *self)
|
|
{
|
|
char buf[512];
|
|
PyOS_snprintf(buf, sizeof(buf), "%s((%d, %ld, '%.*s'))",
|
|
self->ob_type->tp_name,
|
|
self->ob_itself.vRefNum,
|
|
self->ob_itself.parID,
|
|
self->ob_itself.name[0], self->ob_itself.name+1);
|
|
return PyBytes_FromString(buf);
|
|
}
|
|
|
|
#define FSSpec_hash NULL
|
|
static int FSSpec_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
|
|
{
|
|
PyObject *v = NULL;
|
|
char *rawdata = NULL;
|
|
int rawdatalen = 0;
|
|
static char *kw[] = {"itself", "rawdata", 0};
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|Os#", kw, &v, &rawdata, &rawdatalen))
|
|
return -1;
|
|
if (v && rawdata)
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "Only one of itself or rawdata may be specified");
|
|
return -1;
|
|
}
|
|
if (!v && !rawdata)
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "One of itself or rawdata must be specified");
|
|
return -1;
|
|
}
|
|
if (rawdata)
|
|
{
|
|
if (rawdatalen != sizeof(FSSpec))
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "FSSpec rawdata incorrect size");
|
|
return -1;
|
|
}
|
|
memcpy(&((FSSpecObject *)_self)->ob_itself, rawdata, rawdatalen);
|
|
return 0;
|
|
}
|
|
if (PyMac_GetFSSpec(v, &((FSSpecObject *)_self)->ob_itself)) return 0;
|
|
return -1;
|
|
}
|
|
|
|
#define FSSpec_tp_alloc PyType_GenericAlloc
|
|
|
|
static PyObject *FSSpec_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
|
|
{
|
|
PyObject *self;
|
|
|
|
if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
|
|
memset(&((FSSpecObject *)self)->ob_itself, 0, sizeof(FSSpec));
|
|
return self;
|
|
}
|
|
|
|
#define FSSpec_tp_free PyObject_Del
|
|
|
|
|
|
static PyTypeObject FSSpec_Type = {
|
|
PyObject_HEAD_INIT(NULL)
|
|
0, /*ob_size*/
|
|
"Carbon.File.FSSpec", /*tp_name*/
|
|
sizeof(FSSpecObject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor) FSSpec_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
(getattrfunc)0, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc) FSSpec_compare, /*tp_compare*/
|
|
(reprfunc) FSSpec_repr, /*tp_repr*/
|
|
(PyNumberMethods *)0, /* tp_as_number */
|
|
(PySequenceMethods *)0, /* tp_as_sequence */
|
|
(PyMappingMethods *)0, /* tp_as_mapping */
|
|
(hashfunc) FSSpec_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*/
|
|
FSSpec_methods, /* tp_methods */
|
|
0, /*tp_members*/
|
|
FSSpec_getsetlist, /*tp_getset*/
|
|
0, /*tp_base*/
|
|
0, /*tp_dict*/
|
|
0, /*tp_descr_get*/
|
|
0, /*tp_descr_set*/
|
|
0, /*tp_dictoffset*/
|
|
FSSpec_tp_init, /* tp_init */
|
|
FSSpec_tp_alloc, /* tp_alloc */
|
|
FSSpec_tp_new, /* tp_new */
|
|
FSSpec_tp_free, /* tp_free */
|
|
};
|
|
|
|
#endif /* !__LP64__ */
|
|
/* --------------------- End object type FSSpec --------------------- */
|
|
|
|
|
|
/* ----------------------- Object type FSRef ------------------------ */
|
|
|
|
static PyTypeObject FSRef_Type;
|
|
|
|
#define FSRef_Check(x) ((x)->ob_type == &FSRef_Type || PyObject_TypeCheck((x), &FSRef_Type))
|
|
|
|
typedef struct FSRefObject {
|
|
PyObject_HEAD
|
|
FSRef ob_itself;
|
|
} FSRefObject;
|
|
|
|
static PyObject *FSRef_New(FSRef *itself)
|
|
{
|
|
FSRefObject *it;
|
|
if (itself == NULL) return PyMac_Error(resNotFound);
|
|
it = PyObject_NEW(FSRefObject, &FSRef_Type);
|
|
if (it == NULL) return NULL;
|
|
it->ob_itself = *itself;
|
|
return (PyObject *)it;
|
|
}
|
|
|
|
static void FSRef_dealloc(FSRefObject *self)
|
|
{
|
|
/* Cleanup of self->ob_itself goes here */
|
|
self->ob_type->tp_free((PyObject *)self);
|
|
}
|
|
|
|
static PyObject *FSRef_FSMakeFSRefUnicode(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
UniChar *nameLength__in__;
|
|
UniCharCount nameLength__len__;
|
|
int nameLength__in_len__;
|
|
TextEncoding textEncodingHint;
|
|
FSRef newRef;
|
|
if (!PyArg_ParseTuple(_args, "u#l",
|
|
&nameLength__in__, &nameLength__in_len__,
|
|
&textEncodingHint))
|
|
return NULL;
|
|
nameLength__len__ = nameLength__in_len__;
|
|
_err = FSMakeFSRefUnicode(&_self->ob_itself,
|
|
nameLength__len__, nameLength__in__,
|
|
textEncodingHint,
|
|
&newRef);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
FSRef_New, &newRef);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSCompareFSRefs(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSRef ref2;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
FSRef_Convert, &ref2))
|
|
return NULL;
|
|
_err = FSCompareFSRefs(&_self->ob_itself,
|
|
&ref2);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSCreateFileUnicode(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
UniChar *nameLength__in__;
|
|
UniCharCount nameLength__len__;
|
|
int nameLength__in_len__;
|
|
FSCatalogInfoBitmap whichInfo;
|
|
FSCatalogInfo catalogInfo;
|
|
FSRef newRef;
|
|
#ifndef __LP64__
|
|
FSSpec newSpec;
|
|
#endif
|
|
if (!PyArg_ParseTuple(_args, "u#lO&",
|
|
&nameLength__in__, &nameLength__in_len__,
|
|
&whichInfo,
|
|
FSCatalogInfo_Convert, &catalogInfo))
|
|
return NULL;
|
|
nameLength__len__ = nameLength__in_len__;
|
|
_err = FSCreateFileUnicode(&_self->ob_itself,
|
|
nameLength__len__, nameLength__in__,
|
|
whichInfo,
|
|
&catalogInfo,
|
|
&newRef,
|
|
#ifndef __LP64__
|
|
&newSpec
|
|
#else /* __LP64__ */
|
|
NULL
|
|
#endif /* __LP64__*/
|
|
);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
#ifndef __LP64__
|
|
_res = Py_BuildValue("O&O&",
|
|
FSRef_New, &newRef,
|
|
FSSpec_New, &newSpec);
|
|
#else /* __LP64__ */
|
|
_res = Py_BuildValue("O&O", FSRef_New, &newRef, Py_None);
|
|
#endif /* __LP64__ */
|
|
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSCreateDirectoryUnicode(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
UniChar *nameLength__in__;
|
|
UniCharCount nameLength__len__;
|
|
int nameLength__in_len__;
|
|
FSCatalogInfoBitmap whichInfo;
|
|
FSCatalogInfo catalogInfo;
|
|
FSRef newRef;
|
|
#ifndef __LP64__
|
|
FSSpec newSpec;
|
|
#endif /* !__LP64__ */
|
|
UInt32 newDirID;
|
|
if (!PyArg_ParseTuple(_args, "u#lO&",
|
|
&nameLength__in__, &nameLength__in_len__,
|
|
&whichInfo,
|
|
FSCatalogInfo_Convert, &catalogInfo))
|
|
return NULL;
|
|
nameLength__len__ = nameLength__in_len__;
|
|
_err = FSCreateDirectoryUnicode(&_self->ob_itself,
|
|
nameLength__len__, nameLength__in__,
|
|
whichInfo,
|
|
&catalogInfo,
|
|
&newRef,
|
|
#ifndef __LP64__
|
|
&newSpec,
|
|
#else /* !__LP64__ */
|
|
NULL,
|
|
#endif /* !__LP64__ */
|
|
&newDirID);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
#ifndef __LP64__
|
|
_res = Py_BuildValue("O&O&l",
|
|
FSRef_New, &newRef,
|
|
FSSpec_New, &newSpec,
|
|
newDirID);
|
|
#else /* __LP64__ */
|
|
_res = Py_BuildValue("O&Ol",
|
|
FSRef_New, &newRef,
|
|
Py_None,
|
|
newDirID);
|
|
#endif /* __LP64__ */
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSDeleteObject(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = FSDeleteObject(&_self->ob_itself);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSMoveObject(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSRef destDirectory;
|
|
FSRef newRef;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
FSRef_Convert, &destDirectory))
|
|
return NULL;
|
|
_err = FSMoveObject(&_self->ob_itself,
|
|
&destDirectory,
|
|
&newRef);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
FSRef_New, &newRef);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSExchangeObjects(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSRef destRef;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
FSRef_Convert, &destRef))
|
|
return NULL;
|
|
_err = FSExchangeObjects(&_self->ob_itself,
|
|
&destRef);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSRenameUnicode(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
UniChar *nameLength__in__;
|
|
UniCharCount nameLength__len__;
|
|
int nameLength__in_len__;
|
|
TextEncoding textEncodingHint;
|
|
FSRef newRef;
|
|
if (!PyArg_ParseTuple(_args, "u#l",
|
|
&nameLength__in__, &nameLength__in_len__,
|
|
&textEncodingHint))
|
|
return NULL;
|
|
nameLength__len__ = nameLength__in_len__;
|
|
_err = FSRenameUnicode(&_self->ob_itself,
|
|
nameLength__len__, nameLength__in__,
|
|
textEncodingHint,
|
|
&newRef);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
FSRef_New, &newRef);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSGetCatalogInfo(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSCatalogInfoBitmap whichInfo;
|
|
FSCatalogInfo catalogInfo;
|
|
HFSUniStr255 outName;
|
|
#ifndef __LP64__
|
|
FSSpec fsSpec;
|
|
#endif /* !__LP64__ */
|
|
FSRef parentRef;
|
|
if (!PyArg_ParseTuple(_args, "l",
|
|
&whichInfo))
|
|
return NULL;
|
|
_err = FSGetCatalogInfo(&_self->ob_itself,
|
|
whichInfo,
|
|
&catalogInfo,
|
|
&outName,
|
|
#ifndef __LP64__
|
|
&fsSpec,
|
|
#else /* __LP64__ */
|
|
NULL,
|
|
#endif /* __LP64__ */
|
|
&parentRef);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
|
|
#ifndef __LP64__
|
|
_res = Py_BuildValue("O&O&O&O&",
|
|
FSCatalogInfo_New, &catalogInfo,
|
|
PyMac_BuildHFSUniStr255, &outName,
|
|
FSSpec_New, &fsSpec,
|
|
FSRef_New, &parentRef);
|
|
#else /* __LP64__ */
|
|
_res = Py_BuildValue("O&O&OO&",
|
|
FSCatalogInfo_New, &catalogInfo,
|
|
PyMac_BuildHFSUniStr255, &outName,
|
|
Py_None,
|
|
FSRef_New, &parentRef);
|
|
#endif /* __LP64__ */
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSSetCatalogInfo(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSCatalogInfoBitmap whichInfo;
|
|
FSCatalogInfo catalogInfo;
|
|
if (!PyArg_ParseTuple(_args, "lO&",
|
|
&whichInfo,
|
|
FSCatalogInfo_Convert, &catalogInfo))
|
|
return NULL;
|
|
_err = FSSetCatalogInfo(&_self->ob_itself,
|
|
whichInfo,
|
|
&catalogInfo);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSCreateFork(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
UniChar *forkNameLength__in__;
|
|
UniCharCount forkNameLength__len__;
|
|
int forkNameLength__in_len__;
|
|
if (!PyArg_ParseTuple(_args, "u#",
|
|
&forkNameLength__in__, &forkNameLength__in_len__))
|
|
return NULL;
|
|
forkNameLength__len__ = forkNameLength__in_len__;
|
|
_err = FSCreateFork(&_self->ob_itself,
|
|
forkNameLength__len__, forkNameLength__in__);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSDeleteFork(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
UniChar *forkNameLength__in__;
|
|
UniCharCount forkNameLength__len__;
|
|
int forkNameLength__in_len__;
|
|
if (!PyArg_ParseTuple(_args, "u#",
|
|
&forkNameLength__in__, &forkNameLength__in_len__))
|
|
return NULL;
|
|
forkNameLength__len__ = forkNameLength__in_len__;
|
|
_err = FSDeleteFork(&_self->ob_itself,
|
|
forkNameLength__len__, forkNameLength__in__);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSOpenFork(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
UniChar *forkNameLength__in__;
|
|
UniCharCount forkNameLength__len__;
|
|
int forkNameLength__in_len__;
|
|
SInt8 permissions;
|
|
FSIORefNum forkRefNum;
|
|
if (!PyArg_ParseTuple(_args, "u#b",
|
|
&forkNameLength__in__, &forkNameLength__in_len__,
|
|
&permissions))
|
|
return NULL;
|
|
forkNameLength__len__ = forkNameLength__in_len__;
|
|
_err = FSOpenFork(&_self->ob_itself,
|
|
forkNameLength__len__, forkNameLength__in__,
|
|
permissions,
|
|
&forkRefNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("h",
|
|
forkRefNum);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FNNotify(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
FNMessage message;
|
|
OptionBits flags;
|
|
if (!PyArg_ParseTuple(_args, "ll",
|
|
&message,
|
|
&flags))
|
|
return NULL;
|
|
_err = FNNotify(&_self->ob_itself,
|
|
message,
|
|
flags);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSNewAliasMinimal(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
AliasHandle inAlias;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = FSNewAliasMinimal(&_self->ob_itself,
|
|
&inAlias);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
Alias_New, inAlias);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSIsAliasFile(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
Boolean aliasFileFlag;
|
|
Boolean folderFlag;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = FSIsAliasFile(&_self->ob_itself,
|
|
&aliasFileFlag,
|
|
&folderFlag);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("bb",
|
|
aliasFileFlag,
|
|
folderFlag);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *FSRef_FSRefMakePath(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
|
|
OSStatus _err;
|
|
#define MAXPATHNAME 1024
|
|
UInt8 path[MAXPATHNAME];
|
|
UInt32 maxPathSize = MAXPATHNAME;
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = FSRefMakePath(&_self->ob_itself,
|
|
path,
|
|
maxPathSize);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("s", path);
|
|
return _res;
|
|
|
|
}
|
|
|
|
static PyObject *FSRef_as_pathname(FSRefObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_res = FSRef_FSRefMakePath(_self, _args);
|
|
return _res;
|
|
|
|
}
|
|
|
|
static PyMethodDef FSRef_methods[] = {
|
|
{"FSMakeFSRefUnicode", (PyCFunction)FSRef_FSMakeFSRefUnicode, 1,
|
|
PyDoc_STR("(Buffer nameLength, TextEncoding textEncodingHint) -> (FSRef newRef)")},
|
|
{"FSCompareFSRefs", (PyCFunction)FSRef_FSCompareFSRefs, 1,
|
|
PyDoc_STR("(FSRef ref2) -> None")},
|
|
{"FSCreateFileUnicode", (PyCFunction)FSRef_FSCreateFileUnicode, 1,
|
|
PyDoc_STR("(Buffer nameLength, FSCatalogInfoBitmap whichInfo, FSCatalogInfo catalogInfo) -> (FSRef newRef, FSSpec newSpec)")},
|
|
{"FSCreateDirectoryUnicode", (PyCFunction)FSRef_FSCreateDirectoryUnicode, 1,
|
|
PyDoc_STR("(Buffer nameLength, FSCatalogInfoBitmap whichInfo, FSCatalogInfo catalogInfo) -> (FSRef newRef, FSSpec newSpec, UInt32 newDirID)")},
|
|
{"FSDeleteObject", (PyCFunction)FSRef_FSDeleteObject, 1,
|
|
PyDoc_STR("() -> None")},
|
|
{"FSMoveObject", (PyCFunction)FSRef_FSMoveObject, 1,
|
|
PyDoc_STR("(FSRef destDirectory) -> (FSRef newRef)")},
|
|
{"FSExchangeObjects", (PyCFunction)FSRef_FSExchangeObjects, 1,
|
|
PyDoc_STR("(FSRef destRef) -> None")},
|
|
{"FSRenameUnicode", (PyCFunction)FSRef_FSRenameUnicode, 1,
|
|
PyDoc_STR("(Buffer nameLength, TextEncoding textEncodingHint) -> (FSRef newRef)")},
|
|
{"FSGetCatalogInfo", (PyCFunction)FSRef_FSGetCatalogInfo, 1,
|
|
PyDoc_STR("(FSCatalogInfoBitmap whichInfo) -> (FSCatalogInfo catalogInfo, HFSUniStr255 outName, FSSpec fsSpec, FSRef parentRef)")},
|
|
{"FSSetCatalogInfo", (PyCFunction)FSRef_FSSetCatalogInfo, 1,
|
|
PyDoc_STR("(FSCatalogInfoBitmap whichInfo, FSCatalogInfo catalogInfo) -> None")},
|
|
{"FSCreateFork", (PyCFunction)FSRef_FSCreateFork, 1,
|
|
PyDoc_STR("(Buffer forkNameLength) -> None")},
|
|
{"FSDeleteFork", (PyCFunction)FSRef_FSDeleteFork, 1,
|
|
PyDoc_STR("(Buffer forkNameLength) -> None")},
|
|
{"FSOpenFork", (PyCFunction)FSRef_FSOpenFork, 1,
|
|
PyDoc_STR("(Buffer forkNameLength, SInt8 permissions) -> (SInt16 forkRefNum)")},
|
|
{"FNNotify", (PyCFunction)FSRef_FNNotify, 1,
|
|
PyDoc_STR("(FNMessage message, OptionBits flags) -> None")},
|
|
{"FSNewAliasMinimal", (PyCFunction)FSRef_FSNewAliasMinimal, 1,
|
|
PyDoc_STR("() -> (AliasHandle inAlias)")},
|
|
{"FSIsAliasFile", (PyCFunction)FSRef_FSIsAliasFile, 1,
|
|
PyDoc_STR("() -> (Boolean aliasFileFlag, Boolean folderFlag)")},
|
|
{"FSRefMakePath", (PyCFunction)FSRef_FSRefMakePath, 1,
|
|
PyDoc_STR("() -> string")},
|
|
{"as_pathname", (PyCFunction)FSRef_as_pathname, 1,
|
|
PyDoc_STR("() -> string")},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
static PyObject *FSRef_get_data(FSRefObject *self, void *closure)
|
|
{
|
|
return PyBytes_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));
|
|
}
|
|
|
|
#define FSRef_set_data NULL
|
|
|
|
static PyGetSetDef FSRef_getsetlist[] = {
|
|
{"data", (getter)FSRef_get_data, (setter)FSRef_set_data, "Raw data of the FSRef object"},
|
|
{NULL, NULL, NULL, NULL},
|
|
};
|
|
|
|
|
|
#define FSRef_compare NULL
|
|
|
|
#define FSRef_repr NULL
|
|
|
|
#define FSRef_hash NULL
|
|
static int FSRef_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
|
|
{
|
|
PyObject *v = NULL;
|
|
char *rawdata = NULL;
|
|
int rawdatalen = 0;
|
|
static char *kw[] = {"itself", "rawdata", 0};
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|Os#", kw, &v, &rawdata, &rawdatalen))
|
|
return -1;
|
|
if (v && rawdata)
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "Only one of itself or rawdata may be specified");
|
|
return -1;
|
|
}
|
|
if (!v && !rawdata)
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "One of itself or rawdata must be specified");
|
|
return -1;
|
|
}
|
|
if (rawdata)
|
|
{
|
|
if (rawdatalen != sizeof(FSRef))
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "FSRef rawdata incorrect size");
|
|
return -1;
|
|
}
|
|
memcpy(&((FSRefObject *)_self)->ob_itself, rawdata, rawdatalen);
|
|
return 0;
|
|
}
|
|
if (PyMac_GetFSRef(v, &((FSRefObject *)_self)->ob_itself)) return 0;
|
|
return -1;
|
|
}
|
|
|
|
#define FSRef_tp_alloc PyType_GenericAlloc
|
|
|
|
static PyObject *FSRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
|
|
{
|
|
PyObject *self;
|
|
|
|
if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
|
|
memset(&((FSRefObject *)self)->ob_itself, 0, sizeof(FSRef));
|
|
return self;
|
|
}
|
|
|
|
#define FSRef_tp_free PyObject_Del
|
|
|
|
|
|
static PyTypeObject FSRef_Type = {
|
|
PyObject_HEAD_INIT(NULL)
|
|
0, /*ob_size*/
|
|
"Carbon.File.FSRef", /*tp_name*/
|
|
sizeof(FSRefObject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor) FSRef_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
(getattrfunc)0, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc) FSRef_compare, /*tp_compare*/
|
|
(reprfunc) FSRef_repr, /*tp_repr*/
|
|
(PyNumberMethods *)0, /* tp_as_number */
|
|
(PySequenceMethods *)0, /* tp_as_sequence */
|
|
(PyMappingMethods *)0, /* tp_as_mapping */
|
|
(hashfunc) FSRef_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*/
|
|
FSRef_methods, /* tp_methods */
|
|
0, /*tp_members*/
|
|
FSRef_getsetlist, /*tp_getset*/
|
|
0, /*tp_base*/
|
|
0, /*tp_dict*/
|
|
0, /*tp_descr_get*/
|
|
0, /*tp_descr_set*/
|
|
0, /*tp_dictoffset*/
|
|
FSRef_tp_init, /* tp_init */
|
|
FSRef_tp_alloc, /* tp_alloc */
|
|
FSRef_tp_new, /* tp_new */
|
|
FSRef_tp_free, /* tp_free */
|
|
};
|
|
|
|
/* --------------------- End object type FSRef ---------------------- */
|
|
|
|
#ifndef __LP64__
|
|
static PyObject *File_UnmountVol(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
Str63 volName;
|
|
short vRefNum;
|
|
if (!PyArg_ParseTuple(_args, "O&h",
|
|
PyMac_GetStr255, volName,
|
|
&vRefNum))
|
|
return NULL;
|
|
_err = UnmountVol(volName,
|
|
vRefNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FlushVol(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
Str63 volName;
|
|
short vRefNum;
|
|
if (!PyArg_ParseTuple(_args, "O&h",
|
|
PyMac_GetStr255, volName,
|
|
&vRefNum))
|
|
return NULL;
|
|
_err = FlushVol(volName,
|
|
vRefNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HSetVol(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
Str63 volName;
|
|
short vRefNum;
|
|
long dirID;
|
|
if (!PyArg_ParseTuple(_args, "O&hl",
|
|
PyMac_GetStr255, volName,
|
|
&vRefNum,
|
|
&dirID))
|
|
return NULL;
|
|
_err = HSetVol(volName,
|
|
vRefNum,
|
|
dirID);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSClose(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short refNum;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&refNum))
|
|
return NULL;
|
|
_err = FSClose(refNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_Allocate(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short refNum;
|
|
long count;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&refNum))
|
|
return NULL;
|
|
_err = Allocate(refNum,
|
|
&count);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
count);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_GetEOF(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short refNum;
|
|
long logEOF;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&refNum))
|
|
return NULL;
|
|
_err = GetEOF(refNum,
|
|
&logEOF);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
logEOF);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_SetEOF(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short refNum;
|
|
long logEOF;
|
|
if (!PyArg_ParseTuple(_args, "hl",
|
|
&refNum,
|
|
&logEOF))
|
|
return NULL;
|
|
_err = SetEOF(refNum,
|
|
logEOF);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_GetFPos(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short refNum;
|
|
long filePos;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&refNum))
|
|
return NULL;
|
|
_err = GetFPos(refNum,
|
|
&filePos);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
filePos);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_SetFPos(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short refNum;
|
|
short posMode;
|
|
long posOff;
|
|
if (!PyArg_ParseTuple(_args, "hhl",
|
|
&refNum,
|
|
&posMode,
|
|
&posOff))
|
|
return NULL;
|
|
_err = SetFPos(refNum,
|
|
posMode,
|
|
posOff);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_GetVRefNum(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short fileRefNum;
|
|
short vRefNum;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&fileRefNum))
|
|
return NULL;
|
|
_err = GetVRefNum(fileRefNum,
|
|
&vRefNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("h",
|
|
vRefNum);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HGetVol(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
StringPtr volName;
|
|
short vRefNum;
|
|
long dirID;
|
|
if (!PyArg_ParseTuple(_args, "O&",
|
|
PyMac_GetStr255, &volName))
|
|
return NULL;
|
|
_err = HGetVol(volName,
|
|
&vRefNum,
|
|
&dirID);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("hl",
|
|
vRefNum,
|
|
dirID);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HOpen(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
SInt8 permission;
|
|
short refNum;
|
|
if (!PyArg_ParseTuple(_args, "hlO&b",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName,
|
|
&permission))
|
|
return NULL;
|
|
_err = HOpen(vRefNum,
|
|
dirID,
|
|
fileName,
|
|
permission,
|
|
&refNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("h",
|
|
refNum);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HOpenDF(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
SInt8 permission;
|
|
short refNum;
|
|
if (!PyArg_ParseTuple(_args, "hlO&b",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName,
|
|
&permission))
|
|
return NULL;
|
|
_err = HOpenDF(vRefNum,
|
|
dirID,
|
|
fileName,
|
|
permission,
|
|
&refNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("h",
|
|
refNum);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HOpenRF(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
SInt8 permission;
|
|
short refNum;
|
|
if (!PyArg_ParseTuple(_args, "hlO&b",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName,
|
|
&permission))
|
|
return NULL;
|
|
_err = HOpenRF(vRefNum,
|
|
dirID,
|
|
fileName,
|
|
permission,
|
|
&refNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("h",
|
|
refNum);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_AllocContig(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short refNum;
|
|
long count;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&refNum))
|
|
return NULL;
|
|
_err = AllocContig(refNum,
|
|
&count);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
count);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HCreate(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
OSType creator;
|
|
OSType fileType;
|
|
if (!PyArg_ParseTuple(_args, "hlO&O&O&",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName,
|
|
PyMac_GetOSType, &creator,
|
|
PyMac_GetOSType, &fileType))
|
|
return NULL;
|
|
_err = HCreate(vRefNum,
|
|
dirID,
|
|
fileName,
|
|
creator,
|
|
fileType);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_DirCreate(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long parentDirID;
|
|
Str255 directoryName;
|
|
long createdDirID;
|
|
if (!PyArg_ParseTuple(_args, "hlO&",
|
|
&vRefNum,
|
|
&parentDirID,
|
|
PyMac_GetStr255, directoryName))
|
|
return NULL;
|
|
_err = DirCreate(vRefNum,
|
|
parentDirID,
|
|
directoryName,
|
|
&createdDirID);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("l",
|
|
createdDirID);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HDelete(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
if (!PyArg_ParseTuple(_args, "hlO&",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName))
|
|
return NULL;
|
|
_err = HDelete(vRefNum,
|
|
dirID,
|
|
fileName);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HGetFInfo(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
FInfo fndrInfo;
|
|
if (!PyArg_ParseTuple(_args, "hlO&",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName))
|
|
return NULL;
|
|
_err = HGetFInfo(vRefNum,
|
|
dirID,
|
|
fileName,
|
|
&fndrInfo);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
FInfo_New, &fndrInfo);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HSetFInfo(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
FInfo fndrInfo;
|
|
if (!PyArg_ParseTuple(_args, "hlO&O&",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName,
|
|
FInfo_Convert, &fndrInfo))
|
|
return NULL;
|
|
_err = HSetFInfo(vRefNum,
|
|
dirID,
|
|
fileName,
|
|
&fndrInfo);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HSetFLock(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
if (!PyArg_ParseTuple(_args, "hlO&",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName))
|
|
return NULL;
|
|
_err = HSetFLock(vRefNum,
|
|
dirID,
|
|
fileName);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HRstFLock(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
if (!PyArg_ParseTuple(_args, "hlO&",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName))
|
|
return NULL;
|
|
_err = HRstFLock(vRefNum,
|
|
dirID,
|
|
fileName);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_HRename(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 oldName;
|
|
Str255 newName;
|
|
if (!PyArg_ParseTuple(_args, "hlO&O&",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, oldName,
|
|
PyMac_GetStr255, newName))
|
|
return NULL;
|
|
_err = HRename(vRefNum,
|
|
dirID,
|
|
oldName,
|
|
newName);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_CatMove(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 oldName;
|
|
long newDirID;
|
|
Str255 newName;
|
|
if (!PyArg_ParseTuple(_args, "hlO&lO&",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, oldName,
|
|
&newDirID,
|
|
PyMac_GetStr255, newName))
|
|
return NULL;
|
|
_err = CatMove(vRefNum,
|
|
dirID,
|
|
oldName,
|
|
newDirID,
|
|
newName);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSMakeFSSpec(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
short vRefNum;
|
|
long dirID;
|
|
Str255 fileName;
|
|
FSSpec spec;
|
|
if (!PyArg_ParseTuple(_args, "hlO&",
|
|
&vRefNum,
|
|
&dirID,
|
|
PyMac_GetStr255, fileName))
|
|
return NULL;
|
|
_err = FSMakeFSSpec(vRefNum,
|
|
dirID,
|
|
fileName,
|
|
&spec);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
FSSpec_New, &spec);
|
|
return _res;
|
|
}
|
|
#endif /* !__LP64__ */
|
|
|
|
static PyObject *File_FSGetForkPosition(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
SInt16 forkRefNum;
|
|
SInt64 position;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&forkRefNum))
|
|
return NULL;
|
|
_err = FSGetForkPosition(forkRefNum,
|
|
&position);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("L",
|
|
position);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSSetForkPosition(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
SInt16 forkRefNum;
|
|
UInt16 positionMode;
|
|
SInt64 positionOffset;
|
|
if (!PyArg_ParseTuple(_args, "hHL",
|
|
&forkRefNum,
|
|
&positionMode,
|
|
&positionOffset))
|
|
return NULL;
|
|
_err = FSSetForkPosition(forkRefNum,
|
|
positionMode,
|
|
positionOffset);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSGetForkSize(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
SInt16 forkRefNum;
|
|
SInt64 forkSize;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&forkRefNum))
|
|
return NULL;
|
|
_err = FSGetForkSize(forkRefNum,
|
|
&forkSize);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("L",
|
|
forkSize);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSSetForkSize(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
SInt16 forkRefNum;
|
|
UInt16 positionMode;
|
|
SInt64 positionOffset;
|
|
if (!PyArg_ParseTuple(_args, "hHL",
|
|
&forkRefNum,
|
|
&positionMode,
|
|
&positionOffset))
|
|
return NULL;
|
|
_err = FSSetForkSize(forkRefNum,
|
|
positionMode,
|
|
positionOffset);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSAllocateFork(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
SInt16 forkRefNum;
|
|
FSAllocationFlags flags;
|
|
UInt16 positionMode;
|
|
SInt64 positionOffset;
|
|
UInt64 requestCount;
|
|
UInt64 actualCount;
|
|
if (!PyArg_ParseTuple(_args, "hHHLL",
|
|
&forkRefNum,
|
|
&flags,
|
|
&positionMode,
|
|
&positionOffset,
|
|
&requestCount))
|
|
return NULL;
|
|
_err = FSAllocateFork(forkRefNum,
|
|
flags,
|
|
positionMode,
|
|
positionOffset,
|
|
requestCount,
|
|
&actualCount);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("L",
|
|
actualCount);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSFlushFork(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
SInt16 forkRefNum;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&forkRefNum))
|
|
return NULL;
|
|
_err = FSFlushFork(forkRefNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSCloseFork(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
SInt16 forkRefNum;
|
|
if (!PyArg_ParseTuple(_args, "h",
|
|
&forkRefNum))
|
|
return NULL;
|
|
_err = FSCloseFork(forkRefNum);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSGetDataForkName(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
HFSUniStr255 dataForkName;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = FSGetDataForkName(&dataForkName);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildHFSUniStr255, &dataForkName);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSGetResourceForkName(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
HFSUniStr255 resourceForkName;
|
|
if (!PyArg_ParseTuple(_args, ""))
|
|
return NULL;
|
|
_err = FSGetResourceForkName(&resourceForkName);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
PyMac_BuildHFSUniStr255, &resourceForkName);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSPathMakeRef(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
UInt8 * path;
|
|
FSRef ref;
|
|
Boolean isDirectory;
|
|
if (!PyArg_ParseTuple(_args, "s",
|
|
&path))
|
|
return NULL;
|
|
_err = FSPathMakeRef(path,
|
|
&ref,
|
|
&isDirectory);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&b",
|
|
FSRef_New, &ref,
|
|
isDirectory);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FNNotifyByPath(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
UInt8 * path;
|
|
FNMessage message;
|
|
OptionBits flags;
|
|
if (!PyArg_ParseTuple(_args, "sll",
|
|
&path,
|
|
&message,
|
|
&flags))
|
|
return NULL;
|
|
_err = FNNotifyByPath(path,
|
|
message,
|
|
flags);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FNNotifyAll(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSStatus _err;
|
|
FNMessage message;
|
|
OptionBits flags;
|
|
if (!PyArg_ParseTuple(_args, "ll",
|
|
&message,
|
|
&flags))
|
|
return NULL;
|
|
_err = FNNotifyAll(message,
|
|
flags);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
Py_INCREF(Py_None);
|
|
_res = Py_None;
|
|
return _res;
|
|
}
|
|
|
|
#ifndef __LP64__
|
|
static PyObject *File_NewAlias(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSSpec fromFile__buf__;
|
|
FSSpec *fromFile = &fromFile__buf__;
|
|
FSSpec target;
|
|
AliasHandle alias;
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
myPyMac_GetOptFSSpecPtr, &fromFile,
|
|
FSSpec_Convert, &target))
|
|
return NULL;
|
|
_err = NewAlias(fromFile,
|
|
&target,
|
|
&alias);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
Alias_New, alias);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_NewAliasMinimalFromFullPath(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
char *fullPath__in__;
|
|
int fullPath__len__;
|
|
int fullPath__in_len__;
|
|
Str32 zoneName;
|
|
Str31 serverName;
|
|
AliasHandle alias;
|
|
if (!PyArg_ParseTuple(_args, "s#O&O&",
|
|
&fullPath__in__, &fullPath__in_len__,
|
|
PyMac_GetStr255, zoneName,
|
|
PyMac_GetStr255, serverName))
|
|
return NULL;
|
|
fullPath__len__ = fullPath__in_len__;
|
|
_err = NewAliasMinimalFromFullPath(fullPath__len__, fullPath__in__,
|
|
zoneName,
|
|
serverName,
|
|
&alias);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
Alias_New, alias);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_ResolveAliasFile(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSSpec theSpec;
|
|
Boolean resolveAliasChains;
|
|
Boolean targetIsFolder;
|
|
Boolean wasAliased;
|
|
if (!PyArg_ParseTuple(_args, "O&b",
|
|
FSSpec_Convert, &theSpec,
|
|
&resolveAliasChains))
|
|
return NULL;
|
|
_err = ResolveAliasFile(&theSpec,
|
|
resolveAliasChains,
|
|
&targetIsFolder,
|
|
&wasAliased);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&bb",
|
|
FSSpec_New, &theSpec,
|
|
targetIsFolder,
|
|
wasAliased);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_ResolveAliasFileWithMountFlags(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSSpec theSpec;
|
|
Boolean resolveAliasChains;
|
|
Boolean targetIsFolder;
|
|
Boolean wasAliased;
|
|
unsigned long mountFlags;
|
|
if (!PyArg_ParseTuple(_args, "O&bl",
|
|
FSSpec_Convert, &theSpec,
|
|
&resolveAliasChains,
|
|
&mountFlags))
|
|
return NULL;
|
|
_err = ResolveAliasFileWithMountFlags(&theSpec,
|
|
resolveAliasChains,
|
|
&targetIsFolder,
|
|
&wasAliased,
|
|
mountFlags);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&bb",
|
|
FSSpec_New, &theSpec,
|
|
targetIsFolder,
|
|
wasAliased);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_UpdateAlias(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSSpec fromFile__buf__;
|
|
FSSpec *fromFile = &fromFile__buf__;
|
|
FSSpec target;
|
|
AliasHandle alias;
|
|
Boolean wasChanged;
|
|
if (!PyArg_ParseTuple(_args, "O&O&O&",
|
|
myPyMac_GetOptFSSpecPtr, &fromFile,
|
|
FSSpec_Convert, &target,
|
|
Alias_Convert, &alias))
|
|
return NULL;
|
|
_err = UpdateAlias(fromFile,
|
|
&target,
|
|
alias,
|
|
&wasChanged);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("b",
|
|
wasChanged);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_ResolveAliasFileWithMountFlagsNoUI(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSSpec theSpec;
|
|
Boolean resolveAliasChains;
|
|
Boolean targetIsFolder;
|
|
Boolean wasAliased;
|
|
unsigned long mountFlags;
|
|
if (!PyArg_ParseTuple(_args, "O&bl",
|
|
FSSpec_Convert, &theSpec,
|
|
&resolveAliasChains,
|
|
&mountFlags))
|
|
return NULL;
|
|
_err = ResolveAliasFileWithMountFlagsNoUI(&theSpec,
|
|
resolveAliasChains,
|
|
&targetIsFolder,
|
|
&wasAliased,
|
|
mountFlags);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&bb",
|
|
FSSpec_New, &theSpec,
|
|
targetIsFolder,
|
|
wasAliased);
|
|
return _res;
|
|
}
|
|
#endif /* !__LP64__ */
|
|
|
|
static PyObject *File_FSNewAlias(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSRef fromFile__buf__;
|
|
FSRef *fromFile = &fromFile__buf__;
|
|
FSRef target;
|
|
AliasHandle inAlias;
|
|
if (!PyArg_ParseTuple(_args, "O&O&",
|
|
myPyMac_GetOptFSRefPtr, &fromFile,
|
|
FSRef_Convert, &target))
|
|
return NULL;
|
|
_err = FSNewAlias(fromFile,
|
|
&target,
|
|
&inAlias);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&",
|
|
Alias_New, inAlias);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSResolveAliasFileWithMountFlags(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSRef theRef;
|
|
Boolean resolveAliasChains;
|
|
Boolean targetIsFolder;
|
|
Boolean wasAliased;
|
|
unsigned long mountFlags;
|
|
if (!PyArg_ParseTuple(_args, "O&bl",
|
|
FSRef_Convert, &theRef,
|
|
&resolveAliasChains,
|
|
&mountFlags))
|
|
return NULL;
|
|
_err = FSResolveAliasFileWithMountFlags(&theRef,
|
|
resolveAliasChains,
|
|
&targetIsFolder,
|
|
&wasAliased,
|
|
mountFlags);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&bb",
|
|
FSRef_New, &theRef,
|
|
targetIsFolder,
|
|
wasAliased);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSResolveAliasFile(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSRef theRef;
|
|
Boolean resolveAliasChains;
|
|
Boolean targetIsFolder;
|
|
Boolean wasAliased;
|
|
if (!PyArg_ParseTuple(_args, "O&b",
|
|
FSRef_Convert, &theRef,
|
|
&resolveAliasChains))
|
|
return NULL;
|
|
_err = FSResolveAliasFile(&theRef,
|
|
resolveAliasChains,
|
|
&targetIsFolder,
|
|
&wasAliased);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("O&bb",
|
|
FSRef_New, &theRef,
|
|
targetIsFolder,
|
|
wasAliased);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_FSUpdateAlias(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
OSErr _err;
|
|
FSRef fromFile__buf__;
|
|
FSRef *fromFile = &fromFile__buf__;
|
|
FSRef target;
|
|
AliasHandle alias;
|
|
Boolean wasChanged;
|
|
if (!PyArg_ParseTuple(_args, "O&O&O&",
|
|
myPyMac_GetOptFSRefPtr, &fromFile,
|
|
FSRef_Convert, &target,
|
|
Alias_Convert, &alias))
|
|
return NULL;
|
|
_err = FSUpdateAlias(fromFile,
|
|
&target,
|
|
alias,
|
|
&wasChanged);
|
|
if (_err != noErr) return PyMac_Error(_err);
|
|
_res = Py_BuildValue("b",
|
|
wasChanged);
|
|
return _res;
|
|
}
|
|
|
|
static PyObject *File_pathname(PyObject *_self, PyObject *_args)
|
|
{
|
|
PyObject *_res = NULL;
|
|
|
|
PyObject *obj;
|
|
|
|
if (!PyArg_ParseTuple(_args, "O", &obj))
|
|
return NULL;
|
|
if (PyBytes_Check(obj)) {
|
|
Py_INCREF(obj);
|
|
return obj;
|
|
}
|
|
if (PyUnicode_Check(obj))
|
|
return PyUnicode_AsEncodedString(obj, "utf8", "strict");
|
|
_res = PyObject_CallMethod(obj, "as_pathname", NULL);
|
|
return _res;
|
|
|
|
}
|
|
|
|
static PyMethodDef File_methods[] = {
|
|
#ifndef __LP64__
|
|
{"UnmountVol", (PyCFunction)File_UnmountVol, 1,
|
|
PyDoc_STR("(Str63 volName, short vRefNum) -> None")},
|
|
{"FlushVol", (PyCFunction)File_FlushVol, 1,
|
|
PyDoc_STR("(Str63 volName, short vRefNum) -> None")},
|
|
{"HSetVol", (PyCFunction)File_HSetVol, 1,
|
|
PyDoc_STR("(Str63 volName, short vRefNum, long dirID) -> None")},
|
|
{"FSClose", (PyCFunction)File_FSClose, 1,
|
|
PyDoc_STR("(short refNum) -> None")},
|
|
{"Allocate", (PyCFunction)File_Allocate, 1,
|
|
PyDoc_STR("(short refNum) -> (long count)")},
|
|
{"GetEOF", (PyCFunction)File_GetEOF, 1,
|
|
PyDoc_STR("(short refNum) -> (long logEOF)")},
|
|
{"SetEOF", (PyCFunction)File_SetEOF, 1,
|
|
PyDoc_STR("(short refNum, long logEOF) -> None")},
|
|
{"GetFPos", (PyCFunction)File_GetFPos, 1,
|
|
PyDoc_STR("(short refNum) -> (long filePos)")},
|
|
{"SetFPos", (PyCFunction)File_SetFPos, 1,
|
|
PyDoc_STR("(short refNum, short posMode, long posOff) -> None")},
|
|
{"GetVRefNum", (PyCFunction)File_GetVRefNum, 1,
|
|
PyDoc_STR("(short fileRefNum) -> (short vRefNum)")},
|
|
{"HGetVol", (PyCFunction)File_HGetVol, 1,
|
|
PyDoc_STR("(StringPtr volName) -> (short vRefNum, long dirID)")},
|
|
{"HOpen", (PyCFunction)File_HOpen, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")},
|
|
{"HOpenDF", (PyCFunction)File_HOpenDF, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")},
|
|
{"HOpenRF", (PyCFunction)File_HOpenRF, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")},
|
|
{"AllocContig", (PyCFunction)File_AllocContig, 1,
|
|
PyDoc_STR("(short refNum) -> (long count)")},
|
|
{"HCreate", (PyCFunction)File_HCreate, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, OSType creator, OSType fileType) -> None")},
|
|
{"DirCreate", (PyCFunction)File_DirCreate, 1,
|
|
PyDoc_STR("(short vRefNum, long parentDirID, Str255 directoryName) -> (long createdDirID)")},
|
|
{"HDelete", (PyCFunction)File_HDelete, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")},
|
|
{"HGetFInfo", (PyCFunction)File_HGetFInfo, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> (FInfo fndrInfo)")},
|
|
{"HSetFInfo", (PyCFunction)File_HSetFInfo, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, FInfo fndrInfo) -> None")},
|
|
{"HSetFLock", (PyCFunction)File_HSetFLock, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")},
|
|
{"HRstFLock", (PyCFunction)File_HRstFLock, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")},
|
|
{"HRename", (PyCFunction)File_HRename, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 oldName, Str255 newName) -> None")},
|
|
{"CatMove", (PyCFunction)File_CatMove, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 oldName, long newDirID, Str255 newName) -> None")},
|
|
{"FSMakeFSSpec", (PyCFunction)File_FSMakeFSSpec, 1,
|
|
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> (FSSpec spec)")},
|
|
#endif /* !__LP64__*/
|
|
{"FSGetForkPosition", (PyCFunction)File_FSGetForkPosition, 1,
|
|
PyDoc_STR("(SInt16 forkRefNum) -> (SInt64 position)")},
|
|
{"FSSetForkPosition", (PyCFunction)File_FSSetForkPosition, 1,
|
|
PyDoc_STR("(SInt16 forkRefNum, UInt16 positionMode, SInt64 positionOffset) -> None")},
|
|
{"FSGetForkSize", (PyCFunction)File_FSGetForkSize, 1,
|
|
PyDoc_STR("(SInt16 forkRefNum) -> (SInt64 forkSize)")},
|
|
{"FSSetForkSize", (PyCFunction)File_FSSetForkSize, 1,
|
|
PyDoc_STR("(SInt16 forkRefNum, UInt16 positionMode, SInt64 positionOffset) -> None")},
|
|
{"FSAllocateFork", (PyCFunction)File_FSAllocateFork, 1,
|
|
PyDoc_STR("(SInt16 forkRefNum, FSAllocationFlags flags, UInt16 positionMode, SInt64 positionOffset, UInt64 requestCount) -> (UInt64 actualCount)")},
|
|
{"FSFlushFork", (PyCFunction)File_FSFlushFork, 1,
|
|
PyDoc_STR("(SInt16 forkRefNum) -> None")},
|
|
{"FSCloseFork", (PyCFunction)File_FSCloseFork, 1,
|
|
PyDoc_STR("(SInt16 forkRefNum) -> None")},
|
|
{"FSGetDataForkName", (PyCFunction)File_FSGetDataForkName, 1,
|
|
PyDoc_STR("() -> (HFSUniStr255 dataForkName)")},
|
|
{"FSGetResourceForkName", (PyCFunction)File_FSGetResourceForkName, 1,
|
|
PyDoc_STR("() -> (HFSUniStr255 resourceForkName)")},
|
|
{"FSPathMakeRef", (PyCFunction)File_FSPathMakeRef, 1,
|
|
PyDoc_STR("(UInt8 * path) -> (FSRef ref, Boolean isDirectory)")},
|
|
{"FNNotifyByPath", (PyCFunction)File_FNNotifyByPath, 1,
|
|
PyDoc_STR("(UInt8 * path, FNMessage message, OptionBits flags) -> None")},
|
|
{"FNNotifyAll", (PyCFunction)File_FNNotifyAll, 1,
|
|
PyDoc_STR("(FNMessage message, OptionBits flags) -> None")},
|
|
#ifndef __LP64__
|
|
{"NewAlias", (PyCFunction)File_NewAlias, 1,
|
|
PyDoc_STR("(FSSpec fromFile, FSSpec target) -> (AliasHandle alias)")},
|
|
{"NewAliasMinimalFromFullPath", (PyCFunction)File_NewAliasMinimalFromFullPath, 1,
|
|
PyDoc_STR("(Buffer fullPath, Str32 zoneName, Str31 serverName) -> (AliasHandle alias)")},
|
|
{"ResolveAliasFile", (PyCFunction)File_ResolveAliasFile, 1,
|
|
PyDoc_STR("(FSSpec theSpec, Boolean resolveAliasChains) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")},
|
|
{"ResolveAliasFileWithMountFlags", (PyCFunction)File_ResolveAliasFileWithMountFlags, 1,
|
|
PyDoc_STR("(FSSpec theSpec, Boolean resolveAliasChains, unsigned long mountFlags) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")},
|
|
{"UpdateAlias", (PyCFunction)File_UpdateAlias, 1,
|
|
PyDoc_STR("(FSSpec fromFile, FSSpec target, AliasHandle alias) -> (Boolean wasChanged)")},
|
|
{"ResolveAliasFileWithMountFlagsNoUI", (PyCFunction)File_ResolveAliasFileWithMountFlagsNoUI, 1,
|
|
PyDoc_STR("(FSSpec theSpec, Boolean resolveAliasChains, unsigned long mountFlags) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")},
|
|
#endif /* !__LP64__ */
|
|
{"FSNewAlias", (PyCFunction)File_FSNewAlias, 1,
|
|
PyDoc_STR("(FSRef fromFile, FSRef target) -> (AliasHandle inAlias)")},
|
|
{"FSResolveAliasFileWithMountFlags", (PyCFunction)File_FSResolveAliasFileWithMountFlags, 1,
|
|
PyDoc_STR("(FSRef theRef, Boolean resolveAliasChains, unsigned long mountFlags) -> (FSRef theRef, Boolean targetIsFolder, Boolean wasAliased)")},
|
|
{"FSResolveAliasFile", (PyCFunction)File_FSResolveAliasFile, 1,
|
|
PyDoc_STR("(FSRef theRef, Boolean resolveAliasChains) -> (FSRef theRef, Boolean targetIsFolder, Boolean wasAliased)")},
|
|
{"FSUpdateAlias", (PyCFunction)File_FSUpdateAlias, 1,
|
|
PyDoc_STR("(FSRef fromFile, FSRef target, AliasHandle alias) -> (Boolean wasChanged)")},
|
|
{"pathname", (PyCFunction)File_pathname, 1,
|
|
PyDoc_STR("(str|unicode|FSSpec|FSref) -> pathname")},
|
|
{NULL, NULL, 0}
|
|
};
|
|
|
|
|
|
#ifndef __LP64__
|
|
int
|
|
PyMac_GetFSSpec(PyObject *v, FSSpec *spec)
|
|
{
|
|
Str255 path;
|
|
short refnum;
|
|
long parid;
|
|
OSErr err;
|
|
FSRef fsr;
|
|
|
|
if (FSSpec_Check(v)) {
|
|
*spec = ((FSSpecObject *)v)->ob_itself;
|
|
return 1;
|
|
}
|
|
|
|
if (PyArg_Parse(v, "(hlO&)",
|
|
&refnum, &parid, PyMac_GetStr255, &path)) {
|
|
err = FSMakeFSSpec(refnum, parid, path, spec);
|
|
if ( err && err != fnfErr ) {
|
|
PyMac_Error(err);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
PyErr_Clear();
|
|
/* Otherwise we try to go via an FSRef. On OSX we go all the way,
|
|
** on OS9 we accept only a real FSRef object
|
|
*/
|
|
if ( PyMac_GetFSRef(v, &fsr) ) {
|
|
err = FSGetCatalogInfo(&fsr, kFSCatInfoNone, NULL, NULL, spec, NULL);
|
|
if (err != noErr) {
|
|
PyMac_Error(err);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif /* !__LP64__ */
|
|
|
|
int
|
|
PyMac_GetFSRef(PyObject *v, FSRef *fsr)
|
|
{
|
|
OSStatus err;
|
|
#ifndef __LP64__
|
|
FSSpec fss;
|
|
#endif /* !__LP64__ */
|
|
|
|
if (FSRef_Check(v)) {
|
|
*fsr = ((FSRefObject *)v)->ob_itself;
|
|
return 1;
|
|
}
|
|
|
|
/* On OSX we now try a pathname */
|
|
if ( PyBytes_Check(v) || PyUnicode_Check(v)) {
|
|
char *path = NULL;
|
|
if (!PyArg_Parse(v, "et", Py_FileSystemDefaultEncoding, &path))
|
|
return 0;
|
|
if ( (err=FSPathMakeRef((unsigned char*)path, fsr, NULL)) )
|
|
PyMac_Error(err);
|
|
PyMem_Free(path);
|
|
return !err;
|
|
}
|
|
/* XXXX Should try unicode here too */
|
|
|
|
#ifndef __LP64__
|
|
/* Otherwise we try to go via an FSSpec */
|
|
if (FSSpec_Check(v)) {
|
|
fss = ((FSSpecObject *)v)->ob_itself;
|
|
if ((err=FSpMakeFSRef(&fss, fsr)) == 0)
|
|
return 1;
|
|
PyMac_Error(err);
|
|
return 0;
|
|
}
|
|
#endif /* !__LP64__ */
|
|
|
|
PyErr_SetString(PyExc_TypeError, "FSRef, FSSpec or pathname required");
|
|
return 0;
|
|
}
|
|
|
|
#ifndef __LP64__
|
|
extern PyObject *
|
|
PyMac_BuildFSSpec(FSSpec *spec)
|
|
{
|
|
return FSSpec_New(spec);
|
|
}
|
|
#endif /* !__LP64__ */
|
|
|
|
extern PyObject *
|
|
PyMac_BuildFSRef(FSRef *spec)
|
|
{
|
|
return FSRef_New(spec);
|
|
}
|
|
|
|
|
|
void init_File(void)
|
|
{
|
|
PyObject *m;
|
|
PyObject *d;
|
|
|
|
|
|
#ifndef __LP64__
|
|
PyMac_INIT_TOOLBOX_OBJECT_NEW(FSSpec *, PyMac_BuildFSSpec);
|
|
PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSSpec, PyMac_GetFSSpec);
|
|
#endif /* !__LP64__ */
|
|
|
|
PyMac_INIT_TOOLBOX_OBJECT_NEW(FSRef *, PyMac_BuildFSRef);
|
|
PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSRef, PyMac_GetFSRef);
|
|
|
|
|
|
m = Py_InitModule("_File", File_methods);
|
|
d = PyModule_GetDict(m);
|
|
File_Error = PyMac_GetOSErrException();
|
|
if (File_Error == NULL ||
|
|
PyDict_SetItemString(d, "Error", File_Error) != 0)
|
|
return;
|
|
FSCatalogInfo_Type.ob_type = &PyType_Type;
|
|
if (PyType_Ready(&FSCatalogInfo_Type) < 0) return;
|
|
Py_INCREF(&FSCatalogInfo_Type);
|
|
PyModule_AddObject(m, "FSCatalogInfo", (PyObject *)&FSCatalogInfo_Type);
|
|
/* Backward-compatible name */
|
|
Py_INCREF(&FSCatalogInfo_Type);
|
|
PyModule_AddObject(m, "FSCatalogInfoType", (PyObject *)&FSCatalogInfo_Type);
|
|
|
|
#ifndef __LP64__
|
|
FInfo_Type.ob_type = &PyType_Type;
|
|
if (PyType_Ready(&FInfo_Type) < 0) return;
|
|
Py_INCREF(&FInfo_Type);
|
|
PyModule_AddObject(m, "FInfo", (PyObject *)&FInfo_Type);
|
|
/* Backward-compatible name */
|
|
Py_INCREF(&FInfo_Type);
|
|
PyModule_AddObject(m, "FInfoType", (PyObject *)&FInfo_Type);
|
|
#endif /* !__LP64__ */
|
|
Alias_Type.ob_type = &PyType_Type;
|
|
if (PyType_Ready(&Alias_Type) < 0) return;
|
|
Py_INCREF(&Alias_Type);
|
|
PyModule_AddObject(m, "Alias", (PyObject *)&Alias_Type);
|
|
/* Backward-compatible name */
|
|
Py_INCREF(&Alias_Type);
|
|
PyModule_AddObject(m, "AliasType", (PyObject *)&Alias_Type);
|
|
|
|
#ifndef __LP64__
|
|
FSSpec_Type.ob_type = &PyType_Type;
|
|
if (PyType_Ready(&FSSpec_Type) < 0) return;
|
|
Py_INCREF(&FSSpec_Type);
|
|
PyModule_AddObject(m, "FSSpec", (PyObject *)&FSSpec_Type);
|
|
/* Backward-compatible name */
|
|
Py_INCREF(&FSSpec_Type);
|
|
PyModule_AddObject(m, "FSSpecType", (PyObject *)&FSSpec_Type);
|
|
#endif /* !__LP64__ */
|
|
FSRef_Type.ob_type = &PyType_Type;
|
|
if (PyType_Ready(&FSRef_Type) < 0) return;
|
|
Py_INCREF(&FSRef_Type);
|
|
PyModule_AddObject(m, "FSRef", (PyObject *)&FSRef_Type);
|
|
/* Backward-compatible name */
|
|
Py_INCREF(&FSRef_Type);
|
|
PyModule_AddObject(m, "FSRefType", (PyObject *)&FSRef_Type);
|
|
}
|
|
|
|
/* ======================== End module _File ======================== */
|
|
|