| |
| /* ========================= 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} |
| }; |
| |
| #define AliasObj_getsetlist NULL |
| |
| |
| #define AliasObj_compare NULL |
| |
| #define AliasObj_repr NULL |
| |
| #define AliasObj_hash NULL |
| #define AliasObj_tp_init 0 |
| |
| #define AliasObj_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *AliasObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) |
| { |
| PyObject *self; |
| AliasHandle itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, AliasObj_Convert, &itself)) return NULL; |
| if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((AliasObject *)self)->ob_itself = itself; |
| return self; |
| } |
| |
| #define AliasObj_tp_free PyObject_Del |
| |
| |
| 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)0, /*tp_getattr*/ |
| (setattrfunc)0, /*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*/ |
| 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*/ |
| AliasObj_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| AliasObj_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| AliasObj_tp_init, /* tp_init */ |
| AliasObj_tp_alloc, /* tp_alloc */ |
| AliasObj_tp_new, /* tp_new */ |
| AliasObj_tp_free, /* tp_free */ |
| }; |
| |
| /* --------------------- 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); |
| PyModule_AddObject(m, "Alias", (PyObject *)&Alias_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&Alias_Type); |
| PyModule_AddObject(m, "AliasType", (PyObject *)&Alias_Type); |
| } |
| |
| /* ======================= End module _Alias ======================== */ |
| |