diff options
Diffstat (limited to 'Mac/Modules/alias/_Aliasmodule.c')
| -rw-r--r-- | Mac/Modules/alias/_Aliasmodule.c | 663 |
1 files changed, 663 insertions, 0 deletions
diff --git a/Mac/Modules/alias/_Aliasmodule.c b/Mac/Modules/alias/_Aliasmodule.c new file mode 100644 index 0000000..7b30d05 --- /dev/null +++ b/Mac/Modules/alias/_Aliasmodule.c @@ -0,0 +1,663 @@ + +/* ========================= Module _Alias ========================== */ + +#include "Python.h" + + + +#ifdef _WIN32 +#include "pywintoolbox.h" +#else +#include "macglue.h" +#include "pymactoolbox.h" +#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) + + +#ifdef WITHOUT_FRAMEWORKS +#include <Files.h> +#else +#include <Carbon/Carbon.h> +#endif + +static PyObject *Alias_Error; + +/* ----------------------- Object type Alias ------------------------ */ + +PyTypeObject Alias_Type; + +#define AliasObj_Check(x) ((x)->ob_type == &Alias_Type) + +typedef struct AliasObject { + PyObject_HEAD + AliasHandle ob_itself; + void (*ob_freeit)(AliasHandle ptr); +} AliasObject; + +PyObject *AliasObj_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; +} +int AliasObj_Convert(PyObject *v, AliasHandle *p_itself) +{ + if (!AliasObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "Alias required"); + return 0; + } + *p_itself = ((AliasObject *)v)->ob_itself; + return 1; +} + +static void AliasObj_dealloc(AliasObject *self) +{ + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit(self->ob_itself); + } + self->ob_itself = NULL; + PyObject_Del(self); +} + +static PyObject *AliasObj_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 PyMethodDef AliasObj_methods[] = { + {"GetAliasInfo", (PyCFunction)AliasObj_GetAliasInfo, 1, + PyDoc_STR("(AliasInfoType index) -> (Str63 theString)")}, + {NULL, NULL, 0} +}; + +PyMethodChain AliasObj_chain = { AliasObj_methods, NULL }; + +static PyObject *AliasObj_getattr(AliasObject *self, char *name) +{ + return Py_FindMethodInChain(&AliasObj_chain, (PyObject *)self, name); +} + +#define AliasObj_setattr NULL + +#define AliasObj_compare NULL + +#define AliasObj_repr NULL + +#define AliasObj_hash NULL + +PyTypeObject Alias_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_Alias.Alias", /*tp_name*/ + sizeof(AliasObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) AliasObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) AliasObj_getattr, /*tp_getattr*/ + (setattrfunc) AliasObj_setattr, /*tp_setattr*/ + (cmpfunc) AliasObj_compare, /*tp_compare*/ + (reprfunc) AliasObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) AliasObj_hash, /*tp_hash*/ +}; + +/* --------------------- End object type Alias ---------------------- */ + + +static PyObject *Alias_NewAlias(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec fromFile; + FSSpec target; + AliasHandle alias; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSSpec, &fromFile, + PyMac_GetFSSpec, &target)) + return NULL; + _err = NewAlias(&fromFile, + &target, + &alias); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + AliasObj_New, alias); + return _res; +} + +static PyObject *Alias_NewAliasMinimal(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec target; + AliasHandle alias; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &target)) + return NULL; + _err = NewAliasMinimal(&target, + &alias); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + AliasObj_New, alias); + return _res; +} + +static PyObject *Alias_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&", + AliasObj_New, alias); + return _res; +} + +static PyObject *Alias_ResolveAlias(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec fromFile; + AliasHandle alias; + FSSpec target; + Boolean wasChanged; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSSpec, &fromFile, + AliasObj_Convert, &alias)) + return NULL; + _err = ResolveAlias(&fromFile, + alias, + &target, + &wasChanged); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&b", + PyMac_BuildFSSpec, &target, + wasChanged); + return _res; +} + +static PyObject *Alias_IsAliasFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec fileFSSpec; + Boolean aliasFileFlag; + Boolean folderFlag; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &fileFSSpec)) + return NULL; + _err = IsAliasFile(&fileFSSpec, + &aliasFileFlag, + &folderFlag); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("bb", + aliasFileFlag, + folderFlag); + return _res; +} + +static PyObject *Alias_ResolveAliasWithMountFlags(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec fromFile; + AliasHandle alias; + FSSpec target; + Boolean wasChanged; + unsigned long mountFlags; + if (!PyArg_ParseTuple(_args, "O&O&l", + PyMac_GetFSSpec, &fromFile, + AliasObj_Convert, &alias, + &mountFlags)) + return NULL; + _err = ResolveAliasWithMountFlags(&fromFile, + alias, + &target, + &wasChanged, + mountFlags); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&b", + PyMac_BuildFSSpec, &target, + wasChanged); + return _res; +} + +static PyObject *Alias_ResolveAliasFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec theSpec; + Boolean resolveAliasChains; + Boolean targetIsFolder; + Boolean wasAliased; + if (!PyArg_ParseTuple(_args, "b", + &resolveAliasChains)) + return NULL; + _err = ResolveAliasFile(&theSpec, + resolveAliasChains, + &targetIsFolder, + &wasAliased); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&bb", + PyMac_BuildFSSpec, &theSpec, + targetIsFolder, + wasAliased); + return _res; +} + +static PyObject *Alias_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, "bl", + &resolveAliasChains, + &mountFlags)) + return NULL; + _err = ResolveAliasFileWithMountFlags(&theSpec, + resolveAliasChains, + &targetIsFolder, + &wasAliased, + mountFlags); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&bb", + PyMac_BuildFSSpec, &theSpec, + targetIsFolder, + wasAliased); + return _res; +} + +static PyObject *Alias_FollowFinderAlias(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec fromFile; + AliasHandle alias; + Boolean logon; + FSSpec target; + Boolean wasChanged; + if (!PyArg_ParseTuple(_args, "O&O&b", + PyMac_GetFSSpec, &fromFile, + AliasObj_Convert, &alias, + &logon)) + return NULL; + _err = FollowFinderAlias(&fromFile, + alias, + logon, + &target, + &wasChanged); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&b", + PyMac_BuildFSSpec, &target, + wasChanged); + return _res; +} + +static PyObject *Alias_UpdateAlias(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec fromFile; + FSSpec target; + AliasHandle alias; + Boolean wasChanged; + if (!PyArg_ParseTuple(_args, "O&O&O&", + PyMac_GetFSSpec, &fromFile, + PyMac_GetFSSpec, &target, + AliasObj_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 *Alias_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, "bl", + &resolveAliasChains, + &mountFlags)) + return NULL; + _err = ResolveAliasFileWithMountFlagsNoUI(&theSpec, + resolveAliasChains, + &targetIsFolder, + &wasAliased, + mountFlags); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&bb", + PyMac_BuildFSSpec, &theSpec, + targetIsFolder, + wasAliased); + return _res; +} + +static PyObject *Alias_FSNewAlias(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef fromFile; + FSRef target; + AliasHandle inAlias; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSRef, &fromFile, + PyMac_GetFSRef, &target)) + return NULL; + _err = FSNewAlias(&fromFile, + &target, + &inAlias); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + AliasObj_New, inAlias); + return _res; +} + +static PyObject *Alias_FSNewAliasMinimal(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef target; + AliasHandle inAlias; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSRef, &target)) + return NULL; + _err = FSNewAliasMinimal(&target, + &inAlias); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + AliasObj_New, inAlias); + return _res; +} + +static PyObject *Alias_FSIsAliasFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef fileRef; + Boolean aliasFileFlag; + Boolean folderFlag; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSRef, &fileRef)) + return NULL; + _err = FSIsAliasFile(&fileRef, + &aliasFileFlag, + &folderFlag); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("bb", + aliasFileFlag, + folderFlag); + return _res; +} + +static PyObject *Alias_FSResolveAliasWithMountFlags(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef fromFile; + AliasHandle inAlias; + FSRef target; + Boolean wasChanged; + unsigned long mountFlags; + if (!PyArg_ParseTuple(_args, "O&O&l", + PyMac_GetFSRef, &fromFile, + AliasObj_Convert, &inAlias, + &mountFlags)) + return NULL; + _err = FSResolveAliasWithMountFlags(&fromFile, + inAlias, + &target, + &wasChanged, + mountFlags); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&b", + PyMac_BuildFSRef, &target, + wasChanged); + return _res; +} + +static PyObject *Alias_FSResolveAlias(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef fromFile; + AliasHandle alias; + FSRef target; + Boolean wasChanged; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSRef, &fromFile, + AliasObj_Convert, &alias)) + return NULL; + _err = FSResolveAlias(&fromFile, + alias, + &target, + &wasChanged); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&b", + PyMac_BuildFSRef, &target, + wasChanged); + return _res; +} + +static PyObject *Alias_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, "bl", + &resolveAliasChains, + &mountFlags)) + return NULL; + _err = FSResolveAliasFileWithMountFlags(&theRef, + resolveAliasChains, + &targetIsFolder, + &wasAliased, + mountFlags); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&bb", + PyMac_BuildFSRef, &theRef, + targetIsFolder, + wasAliased); + return _res; +} + +static PyObject *Alias_FSResolveAliasFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef theRef; + Boolean resolveAliasChains; + Boolean targetIsFolder; + Boolean wasAliased; + if (!PyArg_ParseTuple(_args, "b", + &resolveAliasChains)) + return NULL; + _err = FSResolveAliasFile(&theRef, + resolveAliasChains, + &targetIsFolder, + &wasAliased); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&bb", + PyMac_BuildFSRef, &theRef, + targetIsFolder, + wasAliased); + return _res; +} + +static PyObject *Alias_FSFollowFinderAlias(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef fromFile; + AliasHandle alias; + Boolean logon; + FSRef target; + Boolean wasChanged; + if (!PyArg_ParseTuple(_args, "O&b", + AliasObj_Convert, &alias, + &logon)) + return NULL; + _err = FSFollowFinderAlias(&fromFile, + alias, + logon, + &target, + &wasChanged); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&O&b", + PyMac_BuildFSRef, &fromFile, + PyMac_BuildFSRef, &target, + wasChanged); + return _res; +} + +static PyObject *Alias_FSUpdateAlias(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef fromFile; + FSRef target; + AliasHandle alias; + Boolean wasChanged; + if (!PyArg_ParseTuple(_args, "O&O&O&", + PyMac_GetFSRef, &fromFile, + PyMac_GetFSRef, &target, + AliasObj_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 PyMethodDef Alias_methods[] = { + {"NewAlias", (PyCFunction)Alias_NewAlias, 1, + PyDoc_STR("(FSSpec fromFile, FSSpec target) -> (AliasHandle alias)")}, + {"NewAliasMinimal", (PyCFunction)Alias_NewAliasMinimal, 1, + PyDoc_STR("(FSSpec target) -> (AliasHandle alias)")}, + {"NewAliasMinimalFromFullPath", (PyCFunction)Alias_NewAliasMinimalFromFullPath, 1, + PyDoc_STR("(Buffer fullPath, Str32 zoneName, Str31 serverName) -> (AliasHandle alias)")}, + {"ResolveAlias", (PyCFunction)Alias_ResolveAlias, 1, + PyDoc_STR("(FSSpec fromFile, AliasHandle alias) -> (FSSpec target, Boolean wasChanged)")}, + {"IsAliasFile", (PyCFunction)Alias_IsAliasFile, 1, + PyDoc_STR("(FSSpec fileFSSpec) -> (Boolean aliasFileFlag, Boolean folderFlag)")}, + {"ResolveAliasWithMountFlags", (PyCFunction)Alias_ResolveAliasWithMountFlags, 1, + PyDoc_STR("(FSSpec fromFile, AliasHandle alias, unsigned long mountFlags) -> (FSSpec target, Boolean wasChanged)")}, + {"ResolveAliasFile", (PyCFunction)Alias_ResolveAliasFile, 1, + PyDoc_STR("(Boolean resolveAliasChains) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")}, + {"ResolveAliasFileWithMountFlags", (PyCFunction)Alias_ResolveAliasFileWithMountFlags, 1, + PyDoc_STR("(Boolean resolveAliasChains, unsigned long mountFlags) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")}, + {"FollowFinderAlias", (PyCFunction)Alias_FollowFinderAlias, 1, + PyDoc_STR("(FSSpec fromFile, AliasHandle alias, Boolean logon) -> (FSSpec target, Boolean wasChanged)")}, + {"UpdateAlias", (PyCFunction)Alias_UpdateAlias, 1, + PyDoc_STR("(FSSpec fromFile, FSSpec target, AliasHandle alias) -> (Boolean wasChanged)")}, + {"ResolveAliasFileWithMountFlagsNoUI", (PyCFunction)Alias_ResolveAliasFileWithMountFlagsNoUI, 1, + PyDoc_STR("(Boolean resolveAliasChains, unsigned long mountFlags) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")}, + {"FSNewAlias", (PyCFunction)Alias_FSNewAlias, 1, + PyDoc_STR("(FSRef fromFile, FSRef target) -> (AliasHandle inAlias)")}, + {"FSNewAliasMinimal", (PyCFunction)Alias_FSNewAliasMinimal, 1, + PyDoc_STR("(FSRef target) -> (AliasHandle inAlias)")}, + {"FSIsAliasFile", (PyCFunction)Alias_FSIsAliasFile, 1, + PyDoc_STR("(FSRef fileRef) -> (Boolean aliasFileFlag, Boolean folderFlag)")}, + {"FSResolveAliasWithMountFlags", (PyCFunction)Alias_FSResolveAliasWithMountFlags, 1, + PyDoc_STR("(FSRef fromFile, AliasHandle inAlias, unsigned long mountFlags) -> (FSRef target, Boolean wasChanged)")}, + {"FSResolveAlias", (PyCFunction)Alias_FSResolveAlias, 1, + PyDoc_STR("(FSRef fromFile, AliasHandle alias) -> (FSRef target, Boolean wasChanged)")}, + {"FSResolveAliasFileWithMountFlags", (PyCFunction)Alias_FSResolveAliasFileWithMountFlags, 1, + PyDoc_STR("(Boolean resolveAliasChains, unsigned long mountFlags) -> (FSRef theRef, Boolean targetIsFolder, Boolean wasAliased)")}, + {"FSResolveAliasFile", (PyCFunction)Alias_FSResolveAliasFile, 1, + PyDoc_STR("(Boolean resolveAliasChains) -> (FSRef theRef, Boolean targetIsFolder, Boolean wasAliased)")}, + {"FSFollowFinderAlias", (PyCFunction)Alias_FSFollowFinderAlias, 1, + PyDoc_STR("(AliasHandle alias, Boolean logon) -> (FSRef fromFile, FSRef target, Boolean wasChanged)")}, + {"FSUpdateAlias", (PyCFunction)Alias_FSUpdateAlias, 1, + PyDoc_STR("(FSRef fromFile, FSRef target, AliasHandle alias) -> (Boolean wasChanged)")}, + {NULL, NULL, 0} +}; + + + + +void init_Alias(void) +{ + PyObject *m; + PyObject *d; + + + + + m = Py_InitModule("_Alias", Alias_methods); + d = PyModule_GetDict(m); + Alias_Error = PyMac_GetOSErrException(); + if (Alias_Error == NULL || + PyDict_SetItemString(d, "Error", Alias_Error) != 0) + return; + Alias_Type.ob_type = &PyType_Type; + Py_INCREF(&Alias_Type); + if (PyDict_SetItemString(d, "AliasType", (PyObject *)&Alias_Type) != 0) + Py_FatalError("can't initialize AliasType"); +} + +/* ======================= End module _Alias ======================== */ + |