Combined alias and file into a single module. This is the only reasonable
way to get various alias creation routines as methods of FSSpec or FSRef
objects (which is the logical thing, from a Python POV). Also started on
the code that will contain all the macfs functionality, so macfs can
becode a Python module, to be used mainly for backward compatibility.
diff --git a/Mac/Modules/alias/_Aliasmodule.c b/Mac/Modules/alias/_Aliasmodule.c
deleted file mode 100644
index a35d5d0..0000000
--- a/Mac/Modules/alias/_Aliasmodule.c
+++ /dev/null
@@ -1,702 +0,0 @@
-
-/* ========================= 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 ======================== */
-
diff --git a/Mac/Modules/alias/aliasscan.py b/Mac/Modules/alias/aliasscan.py
deleted file mode 100644
index a21d3f2..0000000
--- a/Mac/Modules/alias/aliasscan.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# Scan an Apple header file, generating a Python file of generator calls.
-
-import sys
-import os
-from bgenlocations import TOOLBOXDIR, BGENDIR
-sys.path.append(BGENDIR)
-from scantools import Scanner_OSX
-
-LONG = "Aliases"
-SHORT = "alias"
-OBJECT = "AliasHandle"
-
-def main():
- input = LONG + ".h"
- output = SHORT + "gen.py"
- defsoutput = TOOLBOXDIR + LONG + ".py"
- scanner = MyScanner(input, output, defsoutput)
- scanner.scan()
- scanner.close()
- scanner.gentypetest(SHORT+"typetest.py")
- print "=== Testing definitions output code ==="
- execfile(defsoutput, {}, {})
- print "=== Done scanning and generating, now importing the generated code... ==="
- exec "import " + SHORT + "support"
- print "=== Done. It's up to you to compile it now! ==="
-
-class MyScanner(Scanner_OSX):
-
- def destination(self, type, name, arglist):
- classname = "Function"
- listname = "functions"
- if arglist:
- t, n, m = arglist[0]
- # This is non-functional today
- if t == OBJECT and m == "InMode":
- classname = "Method"
- listname = "methods"
- return classname, listname
-
- def makeblacklistnames(self):
- return [
- # Constants with incompatible definitions
-
- ]
-
- def makeblacklisttypes(self):
- return [
- "AliasFilterProcPtr",
- "AliasFilterUPP",
- "CInfoPBPtr",
- ]
-
- def makerepairinstructions(self):
- return [
- ([('Str63', 'theString', 'InMode')],
- [('Str63', 'theString', 'OutMode')]),
-
- ([('short', 'fullPathLength', 'InMode'),
- ('void_ptr', 'fullPath', 'InMode')],
- [('FullPathName', 'fullPath', 'InMode')]),
-
- ]
-
-
- def writeinitialdefs(self):
- self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
- self.defsfile.write("true = True\n")
- self.defsfile.write("false = False\n")
-
-if __name__ == "__main__":
- main()
diff --git a/Mac/Modules/alias/aliassupport.py b/Mac/Modules/alias/aliassupport.py
deleted file mode 100644
index d019c36..0000000
--- a/Mac/Modules/alias/aliassupport.py
+++ /dev/null
@@ -1,118 +0,0 @@
-# This script generates a Python interface for an Apple Macintosh Manager.
-# It uses the "bgen" package to generate C code.
-# The function specifications are generated by scanning the mamager's header file,
-# using the "scantools" package (customized for this particular manager).
-
-import string
-
-# Declarations that change for each manager
-MACHEADERFILE = 'Aliases.h' # The Apple header file
-MODNAME = '_Alias' # The name of the module
-
-# The following is *usually* unchanged but may still require tuning
-MODPREFIX = 'Alias' # The prefix for module-wide routines
-INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
-OUTPUTFILE = MODNAME + "module.c" # The file generated by this program
-
-from macsupport import *
-
-
-# Create the type objects
-
-class VarReverseInputBufferType(ReverseInputBufferMixin, VarInputBufferType):
- pass
-
-FullPathName = VarReverseInputBufferType()
-
-AliasHandle = OpaqueByValueType("AliasHandle", "AliasObj")
-AliasInfoType = Type("AliasInfoType", "h")
-ConstStr31Param = OpaqueArrayType("Str31", "PyMac_BuildStr255", "PyMac_GetStr255")
-ConstStr32Param = OpaqueArrayType("Str32", "PyMac_BuildStr255", "PyMac_GetStr255")
-#FSSpecArrayPtr
-#Ptr
-Str63 = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255")
-#void_ptr
-# class UniCharCountBuffer(InputOnlyType):
-# pass
-#
-# #CatPositionRec
-# ConstStr63Param = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255")
-# FInfo = OpaqueByValueStructType("FInfo", "PyMac_BuildFInfo", "PyMac_GetFInfo")
-# FInfo_ptr = OpaqueType("FInfo", "PyMac_BuildFInfo", "PyMac_GetFInfo")
-# FNMessage = Type("FNMessage", "l")
-# FSAllocationFlags = Type("FSAllocationFlags", "H")
-# #FSCatalogInfo
-# FSCatalogInfoBitmap = Type("FSCatalogInfoBitmap", "l")
-# #FSForkInfo
-# #FSIterator
-# FSIteratorFlags = Type("FSIteratorFlags", "l")
-# #FSVolumeInfo
-# FSVolumeRefNum = Type("FSVolumeRefNum", "h")
-# HFSUniStr255 = OpaqueType("HFSUniStr255", "PyMac_BuildHFSUniStr255", "PyMac_GetHFSUniStr255")
-# SInt64 = Type("SInt64", "L")
-# UInt64 = Type("UInt64", "L")
-# #UInt8_ptr
-# #UniCharCount
-# #char_ptr
-# #void_ptr
-
-
-includestuff = includestuff + """
-#ifdef WITHOUT_FRAMEWORKS
-#include <Files.h>
-#else
-#include <Carbon/Carbon.h>
-#endif
-"""
-
-execfile(string.lower(MODPREFIX) + 'typetest.py')
-
-# From here on it's basically all boiler plate...
-
-# Create the generator groups and link them
-module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff)
-
-class AliasDefinition(PEP253Mixin, GlobalObjectDefinition):
- # XXXX Should inherit from resource?
-
- def outputCheckNewArg(self):
- Output("if (itself == NULL) return PyMac_Error(resNotFound);")
-
- def outputStructMembers(self):
- GlobalObjectDefinition.outputStructMembers(self)
- Output("void (*ob_freeit)(%s ptr);", self.itselftype)
-
- def outputInitStructMembers(self):
- GlobalObjectDefinition.outputInitStructMembers(self)
- Output("it->ob_freeit = NULL;")
-
- def outputCleanupStructMembers(self):
- Output("if (self->ob_freeit && self->ob_itself)")
- OutLbrace()
- Output("self->ob_freeit(self->ob_itself);")
- OutRbrace()
- Output("self->ob_itself = NULL;")
-
-
-aliasobject = AliasDefinition('Alias', 'AliasObj', 'AliasHandle')
-module.addobject(aliasobject)
-# Create the generator classes used to populate the lists
-Function = OSErrFunctionGenerator
-Method = OSErrMethodGenerator
-
-# Create and populate the lists
-functions = []
-methods = []
-execfile(INPUTFILE)
-
-# Manual generators:
-
-# add the populated lists to the generator groups
-# (in a different wordl the scan program would generate this)
-for f in methods: aliasobject.add(f)
-for f in functions: module.add(f)
-
-# generate output (open the output file as late as possible)
-SetOutputFileName(OUTPUTFILE)
-module.generate()
-
diff --git a/Mac/Modules/file/_Filemodule.c b/Mac/Modules/file/_Filemodule.c
index 0029d6c..e76939f 100644
--- a/Mac/Modules/file/_Filemodule.c
+++ b/Mac/Modules/file/_Filemodule.c
@@ -26,6 +26,16 @@
#include <Carbon/Carbon.h>
#endif
+/* Forward declarations */
+extern PyObject *FSRef_New(FSRef *itself);
+extern PyObject *FSSpec_New(FSSpec *itself);
+extern PyObject *Alias_New(AliasHandle itself);
+extern int FSRef_Convert(PyObject *v, FSRef *p_itself);
+extern int FSSpec_Convert(PyObject *v, FSSpec *p_itself);
+extern int Alias_Convert(PyObject *v, AliasHandle *p_itself);
+static int myPyMac_GetFSSpec(PyObject *v, FSSpec *spec);
+static int myPyMac_GetFSRef(PyObject *v, FSRef *fsr);
+
/*
** Parse/generate objsect
*/
@@ -36,19 +46,6 @@
return Py_BuildValue("u#", itself->unicode, itself->length);
}
-#if 0
-static int
-PyMac_GetHFSUniStr255(PyObject *v, HFSUniStr255 *itself)
-{
- return PyArg_ParseTuple(v, "O&O&O&O&O&",
- PyMac_GetFixed, &itself->ascent,
- PyMac_GetFixed, &itself->descent,
- PyMac_GetFixed, &itself->leading,
- PyMac_GetFixed, &itself->widMax,
- ResObj_Convert, &itself->wTabHandle);
-}
-#endif
-
/*
** Parse/generate objsect
*/
@@ -75,9 +72,1182 @@
&itself->fdFldr);
}
-
static PyObject *File_Error;
+/* ----------------------- Object type Alias ------------------------ */
+
+PyTypeObject Alias_Type;
+
+#define Alias_Check(x) ((x)->ob_type == &Alias_Type)
+
+typedef struct AliasObject {
+ PyObject_HEAD
+ AliasHandle ob_itself;
+ void (*ob_freeit)(AliasHandle ptr);
+} AliasObject;
+
+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;
+}
+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;
+ PyObject_Del(self);
+}
+
+static PyObject *Alias_ResolveAlias(AliasObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ FSSpec fromFile;
+ FSSpec target;
+ Boolean wasChanged;
+ if (!PyArg_ParseTuple(_args, "O&",
+ FSSpec_Convert, &fromFile))
+ return NULL;
+ _rv = ResolveAlias(&fromFile,
+ _self->ob_itself,
+ &target,
+ &wasChanged);
+ _res = Py_BuildValue("hO&b",
+ _rv,
+ 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 _rv;
+ FSSpec fromFile;
+ FSSpec target;
+ Boolean wasChanged;
+ unsigned long mountFlags;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ FSSpec_Convert, &fromFile,
+ &mountFlags))
+ return NULL;
+ _rv = ResolveAliasWithMountFlags(&fromFile,
+ _self->ob_itself,
+ &target,
+ &wasChanged,
+ mountFlags);
+ _res = Py_BuildValue("hO&b",
+ _rv,
+ FSSpec_New, &target,
+ wasChanged);
+ return _res;
+}
+
+static PyObject *Alias_FollowFinderAlias(AliasObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ FSSpec fromFile;
+ Boolean logon;
+ FSSpec target;
+ Boolean wasChanged;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ FSSpec_Convert, &fromFile,
+ &logon))
+ return NULL;
+ _rv = FollowFinderAlias(&fromFile,
+ _self->ob_itself,
+ logon,
+ &target,
+ &wasChanged);
+ _res = Py_BuildValue("hO&b",
+ _rv,
+ FSSpec_New, &target,
+ wasChanged);
+ return _res;
+}
+
+static PyObject *Alias_FSResolveAliasWithMountFlags(AliasObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ FSRef fromFile;
+ FSRef target;
+ Boolean wasChanged;
+ unsigned long mountFlags;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ FSRef_Convert, &fromFile,
+ &mountFlags))
+ return NULL;
+ _rv = FSResolveAliasWithMountFlags(&fromFile,
+ _self->ob_itself,
+ &target,
+ &wasChanged,
+ mountFlags);
+ _res = Py_BuildValue("hO&b",
+ _rv,
+ FSRef_New, &target,
+ wasChanged);
+ return _res;
+}
+
+static PyObject *Alias_FSResolveAlias(AliasObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ FSRef fromFile;
+ FSRef target;
+ Boolean wasChanged;
+ if (!PyArg_ParseTuple(_args, "O&",
+ FSRef_Convert, &fromFile))
+ return NULL;
+ _rv = FSResolveAlias(&fromFile,
+ _self->ob_itself,
+ &target,
+ &wasChanged);
+ _res = Py_BuildValue("hO&b",
+ _rv,
+ FSRef_New, &target,
+ wasChanged);
+ return _res;
+}
+
+static PyObject *Alias_FSFollowFinderAlias(AliasObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _rv;
+ FSRef fromFile;
+ Boolean logon;
+ FSRef target;
+ Boolean wasChanged;
+ if (!PyArg_ParseTuple(_args, "b",
+ &logon))
+ return NULL;
+ _rv = FSFollowFinderAlias(&fromFile,
+ _self->ob_itself,
+ logon,
+ &target,
+ &wasChanged);
+ _res = Py_BuildValue("hO&O&b",
+ _rv,
+ FSRef_New, &fromFile,
+ FSRef_New, &target,
+ wasChanged);
+ return _res;
+}
+
+static PyMethodDef Alias_methods[] = {
+ {"ResolveAlias", (PyCFunction)Alias_ResolveAlias, 1,
+ PyDoc_STR("(FSSpec fromFile) -> (OSErr _rv, 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) -> (OSErr _rv, FSSpec target, Boolean wasChanged)")},
+ {"FollowFinderAlias", (PyCFunction)Alias_FollowFinderAlias, 1,
+ PyDoc_STR("(FSSpec fromFile, Boolean logon) -> (OSErr _rv, FSSpec target, Boolean wasChanged)")},
+ {"FSResolveAliasWithMountFlags", (PyCFunction)Alias_FSResolveAliasWithMountFlags, 1,
+ PyDoc_STR("(FSRef fromFile, unsigned long mountFlags) -> (OSErr _rv, FSRef target, Boolean wasChanged)")},
+ {"FSResolveAlias", (PyCFunction)Alias_FSResolveAlias, 1,
+ PyDoc_STR("(FSRef fromFile) -> (OSErr _rv, FSRef target, Boolean wasChanged)")},
+ {"FSFollowFinderAlias", (PyCFunction)Alias_FSFollowFinderAlias, 1,
+ PyDoc_STR("(Boolean logon) -> (OSErr _rv, FSRef fromFile, FSRef target, Boolean wasChanged)")},
+ {NULL, NULL, 0}
+};
+
+#define Alias_getsetlist 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;
+ char *kw[] = {"itself", 0};
+
+ if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, Alias_Convert, &itself))
+ {
+ ((AliasObject *)self)->ob_itself = itself;
+ return 0;
+ }
+ return -1;
+}
+
+#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
+
+
+PyTypeObject Alias_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0, /*ob_size*/
+ "_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 ----------------------- */
+
+PyTypeObject FSSpec_Type;
+
+#define FSSpec_Check(x) ((x)->ob_type == &FSSpec_Type)
+
+typedef struct FSSpecObject {
+ PyObject_HEAD
+ FSSpec ob_itself;
+} FSSpecObject;
+
+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;
+}
+int FSSpec_Convert(PyObject *v, FSSpec *p_itself)
+{
+ if (!FSSpec_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "FSSpec required");
+ return 0;
+ }
+ *p_itself = ((FSSpecObject *)v)->ob_itself;
+ return 1;
+}
+
+static void FSSpec_dealloc(FSSpecObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyObject_Del(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&",
+ PyMac_BuildFInfo, &fndrInfo);
+ return _res;
+}
+
+static PyObject *FSSpec_FSpSetFInfo(FSSpecObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FInfo fndrInfo;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFInfo, &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_NewAlias(FSSpecObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSSpec target;
+ AliasHandle alias;
+ if (!PyArg_ParseTuple(_args, "O&",
+ FSSpec_Convert, &target))
+ return NULL;
+ _err = NewAlias(&_self->ob_itself,
+ &target,
+ &alias);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ Alias_New, alias);
+ 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_UpdateAlias(FSSpecObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSSpec target;
+ AliasHandle alias;
+ Boolean wasChanged;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ FSSpec_Convert, &target,
+ Alias_Convert, &alias))
+ return NULL;
+ _err = UpdateAlias(&_self->ob_itself,
+ &target,
+ alias,
+ &wasChanged);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ wasChanged);
+ 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)")},
+ {"NewAlias", (PyCFunction)FSSpec_NewAlias, 1,
+ PyDoc_STR("(FSSpec target) -> (AliasHandle alias)")},
+ {"NewAliasMinimal", (PyCFunction)FSSpec_NewAliasMinimal, 1,
+ PyDoc_STR("() -> (AliasHandle alias)")},
+ {"IsAliasFile", (PyCFunction)FSSpec_IsAliasFile, 1,
+ PyDoc_STR("() -> (Boolean aliasFileFlag, Boolean folderFlag)")},
+ {"UpdateAlias", (PyCFunction)FSSpec_UpdateAlias, 1,
+ PyDoc_STR("(FSSpec target, AliasHandle alias) -> (Boolean wasChanged)")},
+ {NULL, NULL, 0}
+};
+
+#define FSSpec_getsetlist NULL
+
+
+#define FSSpec_compare NULL
+
+#define FSSpec_repr NULL
+
+#define FSSpec_hash NULL
+static int FSSpec_tp_init(PyObject *self, PyObject *args, PyObject *kwds)
+{
+ PyObject *v;
+ char *kw[] = {"itself", 0};
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kw, &v))
+ return -1;
+ if (myPyMac_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(FSSpecObject));
+ return self;
+}
+
+#define FSSpec_tp_free PyObject_Del
+
+
+PyTypeObject FSSpec_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0, /*ob_size*/
+ "_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 */
+};
+
+/* --------------------- End object type FSSpec --------------------- */
+
+
+/* ----------------------- Object type FSRef ------------------------ */
+
+PyTypeObject FSRef_Type;
+
+#define FSRef_Check(x) ((x)->ob_type == &FSRef_Type)
+
+typedef struct FSRefObject {
+ PyObject_HEAD
+ FSRef ob_itself;
+} FSRefObject;
+
+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;
+}
+int FSRef_Convert(PyObject *v, FSRef *p_itself)
+{
+ if (!FSRef_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "FSRef required");
+ return 0;
+ }
+ *p_itself = ((FSRefObject *)v)->ob_itself;
+ return 1;
+}
+
+static void FSRef_dealloc(FSRefObject *self)
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyObject_Del(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_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_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;
+ SInt16 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;
+}
+
+#if TARGET_API_MAC_OSX
+
+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;
+}
+#endif
+
+static PyObject *FSRef_FSNewAlias(FSRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSRef target;
+ AliasHandle inAlias;
+ if (!PyArg_ParseTuple(_args, "O&",
+ FSRef_Convert, &target))
+ return NULL;
+ _err = FSNewAlias(&_self->ob_itself,
+ &target,
+ &inAlias);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ Alias_New, inAlias);
+ 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_FSUpdateAlias(FSRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ FSRef target;
+ AliasHandle alias;
+ Boolean wasChanged;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ FSRef_Convert, &target,
+ Alias_Convert, &alias))
+ return NULL;
+ _err = FSUpdateAlias(&_self->ob_itself,
+ &target,
+ alias,
+ &wasChanged);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ wasChanged);
+ return _res;
+}
+
+static PyObject *FSRef_FSRefMakePath(FSRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+
+ OSStatus _err;
+#define MAXPATHNAME 1024
+ UInt8 path[MAXPATHNAME];
+ UInt32 maxPathSize = MAXPATHNAME;
+
+ _err = FSRefMakePath(&_self->ob_itself,
+ path,
+ maxPathSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("s", path);
+ 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")},
+ {"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)")},
+ {"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)")},
+
+#if TARGET_API_MAC_OSX
+ {"FNNotify", (PyCFunction)FSRef_FNNotify, 1,
+ PyDoc_STR("(FNMessage message, OptionBits flags) -> None")},
+#endif
+ {"FSNewAlias", (PyCFunction)FSRef_FSNewAlias, 1,
+ PyDoc_STR("(FSRef target) -> (AliasHandle inAlias)")},
+ {"FSNewAliasMinimal", (PyCFunction)FSRef_FSNewAliasMinimal, 1,
+ PyDoc_STR("() -> (AliasHandle inAlias)")},
+ {"FSIsAliasFile", (PyCFunction)FSRef_FSIsAliasFile, 1,
+ PyDoc_STR("() -> (Boolean aliasFileFlag, Boolean folderFlag)")},
+ {"FSUpdateAlias", (PyCFunction)FSRef_FSUpdateAlias, 1,
+ PyDoc_STR("(FSRef target, AliasHandle alias) -> (Boolean wasChanged)")},
+ {"FSRefMakePath", (PyCFunction)FSRef_FSRefMakePath, 1,
+ PyDoc_STR("() -> string")},
+ {NULL, NULL, 0}
+};
+
+#define FSRef_getsetlist 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;
+ char *kw[] = {"itself", 0};
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kw, &v))
+ return -1;
+ if (myPyMac_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(FSRefObject));
+ return self;
+}
+
+#define FSRef_tp_free PyObject_Del
+
+
+PyTypeObject FSRef_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0, /*ob_size*/
+ "_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 ---------------------- */
+
+
static PyObject *File_UnmountVol(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -602,433 +1772,7 @@
&spec);
if (_err != noErr) return PyMac_Error(_err);
_res = Py_BuildValue("O&",
- PyMac_BuildFSSpec, &spec);
- return _res;
-}
-
-static PyObject *File_FSpOpenDF(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec spec;
- SInt8 permission;
- short refNum;
- if (!PyArg_ParseTuple(_args, "O&b",
- PyMac_GetFSSpec, &spec,
- &permission))
- return NULL;
- _err = FSpOpenDF(&spec,
- permission,
- &refNum);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("h",
- refNum);
- return _res;
-}
-
-static PyObject *File_FSpOpenRF(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec spec;
- SInt8 permission;
- short refNum;
- if (!PyArg_ParseTuple(_args, "O&b",
- PyMac_GetFSSpec, &spec,
- &permission))
- return NULL;
- _err = FSpOpenRF(&spec,
- permission,
- &refNum);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("h",
- refNum);
- return _res;
-}
-
-static PyObject *File_FSpCreate(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec spec;
- OSType creator;
- OSType fileType;
- ScriptCode scriptTag;
- if (!PyArg_ParseTuple(_args, "O&O&O&h",
- PyMac_GetFSSpec, &spec,
- PyMac_GetOSType, &creator,
- PyMac_GetOSType, &fileType,
- &scriptTag))
- return NULL;
- _err = FSpCreate(&spec,
- creator,
- fileType,
- scriptTag);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSpDirCreate(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec spec;
- ScriptCode scriptTag;
- long createdDirID;
- if (!PyArg_ParseTuple(_args, "O&h",
- PyMac_GetFSSpec, &spec,
- &scriptTag))
- return NULL;
- _err = FSpDirCreate(&spec,
- scriptTag,
- &createdDirID);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("l",
- createdDirID);
- return _res;
-}
-
-static PyObject *File_FSpDelete(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec spec;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetFSSpec, &spec))
- return NULL;
- _err = FSpDelete(&spec);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSpGetFInfo(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec spec;
- FInfo fndrInfo;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetFSSpec, &spec))
- return NULL;
- _err = FSpGetFInfo(&spec,
- &fndrInfo);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&",
- PyMac_BuildFInfo, &fndrInfo);
- return _res;
-}
-
-static PyObject *File_FSpSetFInfo(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec spec;
- FInfo fndrInfo;
- if (!PyArg_ParseTuple(_args, "O&O&",
- PyMac_GetFSSpec, &spec,
- PyMac_GetFInfo, &fndrInfo))
- return NULL;
- _err = FSpSetFInfo(&spec,
- &fndrInfo);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSpSetFLock(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec spec;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetFSSpec, &spec))
- return NULL;
- _err = FSpSetFLock(&spec);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSpRstFLock(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec spec;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetFSSpec, &spec))
- return NULL;
- _err = FSpRstFLock(&spec);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSpRename(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec spec;
- Str255 newName;
- if (!PyArg_ParseTuple(_args, "O&O&",
- PyMac_GetFSSpec, &spec,
- PyMac_GetStr255, newName))
- return NULL;
- _err = FSpRename(&spec,
- newName);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSpCatMove(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec source;
- FSSpec dest;
- if (!PyArg_ParseTuple(_args, "O&O&",
- PyMac_GetFSSpec, &source,
- PyMac_GetFSSpec, &dest))
- return NULL;
- _err = FSpCatMove(&source,
- &dest);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSpExchangeFiles(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec source;
- FSSpec dest;
- if (!PyArg_ParseTuple(_args, "O&O&",
- PyMac_GetFSSpec, &source,
- PyMac_GetFSSpec, &dest))
- return NULL;
- _err = FSpExchangeFiles(&source,
- &dest);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSpMakeFSRef(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSSpec source;
- FSRef newRef;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetFSSpec, &source))
- return NULL;
- _err = FSpMakeFSRef(&source,
- &newRef);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&",
- PyMac_BuildFSRef, &newRef);
- return _res;
-}
-
-static PyObject *File_FSMakeFSRefUnicode(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSRef parentRef;
- UniChar *nameLength__in__;
- UniCharCount nameLength__len__;
- int nameLength__in_len__;
- TextEncoding textEncodingHint;
- FSRef newRef;
- if (!PyArg_ParseTuple(_args, "O&u#l",
- PyMac_GetFSRef, &parentRef,
- &nameLength__in__, &nameLength__in_len__,
- &textEncodingHint))
- return NULL;
- nameLength__len__ = nameLength__in_len__;
- _err = FSMakeFSRefUnicode(&parentRef,
- nameLength__len__, nameLength__in__,
- textEncodingHint,
- &newRef);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&",
- PyMac_BuildFSRef, &newRef);
- return _res;
-}
-
-static PyObject *File_FSCompareFSRefs(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSRef ref1;
- FSRef ref2;
- if (!PyArg_ParseTuple(_args, "O&O&",
- PyMac_GetFSRef, &ref1,
- PyMac_GetFSRef, &ref2))
- return NULL;
- _err = FSCompareFSRefs(&ref1,
- &ref2);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSDeleteObject(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSRef ref;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetFSRef, &ref))
- return NULL;
- _err = FSDeleteObject(&ref);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSMoveObject(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSRef ref;
- FSRef destDirectory;
- FSRef newRef;
- if (!PyArg_ParseTuple(_args, "O&O&",
- PyMac_GetFSRef, &ref,
- PyMac_GetFSRef, &destDirectory))
- return NULL;
- _err = FSMoveObject(&ref,
- &destDirectory,
- &newRef);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&",
- PyMac_BuildFSRef, &newRef);
- return _res;
-}
-
-static PyObject *File_FSExchangeObjects(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSRef ref;
- FSRef destRef;
- if (!PyArg_ParseTuple(_args, "O&O&",
- PyMac_GetFSRef, &ref,
- PyMac_GetFSRef, &destRef))
- return NULL;
- _err = FSExchangeObjects(&ref,
- &destRef);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSRenameUnicode(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSRef ref;
- UniChar *nameLength__in__;
- UniCharCount nameLength__len__;
- int nameLength__in_len__;
- TextEncoding textEncodingHint;
- FSRef newRef;
- if (!PyArg_ParseTuple(_args, "O&u#l",
- PyMac_GetFSRef, &ref,
- &nameLength__in__, &nameLength__in_len__,
- &textEncodingHint))
- return NULL;
- nameLength__len__ = nameLength__in_len__;
- _err = FSRenameUnicode(&ref,
- nameLength__len__, nameLength__in__,
- textEncodingHint,
- &newRef);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&",
- PyMac_BuildFSRef, &newRef);
- return _res;
-}
-
-static PyObject *File_FSCreateFork(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSRef ref;
- UniChar *forkNameLength__in__;
- UniCharCount forkNameLength__len__;
- int forkNameLength__in_len__;
- if (!PyArg_ParseTuple(_args, "O&u#",
- PyMac_GetFSRef, &ref,
- &forkNameLength__in__, &forkNameLength__in_len__))
- return NULL;
- forkNameLength__len__ = forkNameLength__in_len__;
- _err = FSCreateFork(&ref,
- forkNameLength__len__, forkNameLength__in__);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSDeleteFork(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSRef ref;
- UniChar *forkNameLength__in__;
- UniCharCount forkNameLength__len__;
- int forkNameLength__in_len__;
- if (!PyArg_ParseTuple(_args, "O&u#",
- PyMac_GetFSRef, &ref,
- &forkNameLength__in__, &forkNameLength__in_len__))
- return NULL;
- forkNameLength__len__ = forkNameLength__in_len__;
- _err = FSDeleteFork(&ref,
- forkNameLength__len__, forkNameLength__in__);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *File_FSOpenFork(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- FSRef ref;
- UniChar *forkNameLength__in__;
- UniCharCount forkNameLength__len__;
- int forkNameLength__in_len__;
- SInt8 permissions;
- SInt16 forkRefNum;
- if (!PyArg_ParseTuple(_args, "O&u#b",
- PyMac_GetFSRef, &ref,
- &forkNameLength__in__, &forkNameLength__in_len__,
- &permissions))
- return NULL;
- forkNameLength__len__ = forkNameLength__in_len__;
- _err = FSOpenFork(&ref,
- forkNameLength__len__, forkNameLength__in__,
- permissions,
- &forkRefNum);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("h",
- forkRefNum);
+ FSSpec_New, &spec);
return _res;
}
@@ -1210,37 +1954,13 @@
&isDirectory);
if (_err != noErr) return PyMac_Error(_err);
_res = Py_BuildValue("O&b",
- PyMac_BuildFSRef, &ref,
+ FSRef_New, &ref,
isDirectory);
return _res;
}
#if TARGET_API_MAC_OSX
-static PyObject *File_FNNotify(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSStatus _err;
- FSRef ref;
- FNMessage message;
- OptionBits flags;
- if (!PyArg_ParseTuple(_args, "O&ll",
- PyMac_GetFSRef, &ref,
- &message,
- &flags))
- return NULL;
- _err = FNNotify(&ref,
- message,
- flags);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-#endif
-
-#if TARGET_API_MAC_OSX
-
static PyObject *File_FNNotifyByPath(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -1284,26 +2004,157 @@
}
#endif
-static PyObject *File_FSRefMakePath(PyObject *_self, PyObject *_args)
+static PyObject *File_NewAliasMinimalFromFullPath(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
-
- OSStatus _err;
- FSRef ref;
-#define MAXPATHNAME 1024
- UInt8 path[MAXPATHNAME];
- UInt32 maxPathSize = MAXPATHNAME;
-
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetFSRef, &ref))
+ 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;
- _err = FSRefMakePath(&ref,
- path,
- maxPathSize);
+ fullPath__len__ = fullPath__in_len__;
+ _err = NewAliasMinimalFromFullPath(fullPath__len__, fullPath__in__,
+ zoneName,
+ serverName,
+ &alias);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("s", path);
+ _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_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;
+}
+
+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, "bl",
+ &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, "b",
+ &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 PyMethodDef File_methods[] = {
@@ -1357,50 +2208,6 @@
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)")},
- {"FSpOpenDF", (PyCFunction)File_FSpOpenDF, 1,
- PyDoc_STR("(FSSpec spec, SInt8 permission) -> (short refNum)")},
- {"FSpOpenRF", (PyCFunction)File_FSpOpenRF, 1,
- PyDoc_STR("(FSSpec spec, SInt8 permission) -> (short refNum)")},
- {"FSpCreate", (PyCFunction)File_FSpCreate, 1,
- PyDoc_STR("(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None")},
- {"FSpDirCreate", (PyCFunction)File_FSpDirCreate, 1,
- PyDoc_STR("(FSSpec spec, ScriptCode scriptTag) -> (long createdDirID)")},
- {"FSpDelete", (PyCFunction)File_FSpDelete, 1,
- PyDoc_STR("(FSSpec spec) -> None")},
- {"FSpGetFInfo", (PyCFunction)File_FSpGetFInfo, 1,
- PyDoc_STR("(FSSpec spec) -> (FInfo fndrInfo)")},
- {"FSpSetFInfo", (PyCFunction)File_FSpSetFInfo, 1,
- PyDoc_STR("(FSSpec spec, FInfo fndrInfo) -> None")},
- {"FSpSetFLock", (PyCFunction)File_FSpSetFLock, 1,
- PyDoc_STR("(FSSpec spec) -> None")},
- {"FSpRstFLock", (PyCFunction)File_FSpRstFLock, 1,
- PyDoc_STR("(FSSpec spec) -> None")},
- {"FSpRename", (PyCFunction)File_FSpRename, 1,
- PyDoc_STR("(FSSpec spec, Str255 newName) -> None")},
- {"FSpCatMove", (PyCFunction)File_FSpCatMove, 1,
- PyDoc_STR("(FSSpec source, FSSpec dest) -> None")},
- {"FSpExchangeFiles", (PyCFunction)File_FSpExchangeFiles, 1,
- PyDoc_STR("(FSSpec source, FSSpec dest) -> None")},
- {"FSpMakeFSRef", (PyCFunction)File_FSpMakeFSRef, 1,
- PyDoc_STR("(FSSpec source) -> (FSRef newRef)")},
- {"FSMakeFSRefUnicode", (PyCFunction)File_FSMakeFSRefUnicode, 1,
- PyDoc_STR("(FSRef parentRef, Buffer nameLength, TextEncoding textEncodingHint) -> (FSRef newRef)")},
- {"FSCompareFSRefs", (PyCFunction)File_FSCompareFSRefs, 1,
- PyDoc_STR("(FSRef ref1, FSRef ref2) -> None")},
- {"FSDeleteObject", (PyCFunction)File_FSDeleteObject, 1,
- PyDoc_STR("(FSRef ref) -> None")},
- {"FSMoveObject", (PyCFunction)File_FSMoveObject, 1,
- PyDoc_STR("(FSRef ref, FSRef destDirectory) -> (FSRef newRef)")},
- {"FSExchangeObjects", (PyCFunction)File_FSExchangeObjects, 1,
- PyDoc_STR("(FSRef ref, FSRef destRef) -> None")},
- {"FSRenameUnicode", (PyCFunction)File_FSRenameUnicode, 1,
- PyDoc_STR("(FSRef ref, Buffer nameLength, TextEncoding textEncodingHint) -> (FSRef newRef)")},
- {"FSCreateFork", (PyCFunction)File_FSCreateFork, 1,
- PyDoc_STR("(FSRef ref, Buffer forkNameLength) -> None")},
- {"FSDeleteFork", (PyCFunction)File_FSDeleteFork, 1,
- PyDoc_STR("(FSRef ref, Buffer forkNameLength) -> None")},
- {"FSOpenFork", (PyCFunction)File_FSOpenFork, 1,
- PyDoc_STR("(FSRef ref, Buffer forkNameLength, SInt8 permissions) -> (SInt16 forkRefNum)")},
{"FSGetForkPosition", (PyCFunction)File_FSGetForkPosition, 1,
PyDoc_STR("(SInt16 forkRefNum) -> (SInt64 position)")},
{"FSSetForkPosition", (PyCFunction)File_FSSetForkPosition, 1,
@@ -1423,11 +2230,6 @@
PyDoc_STR("(UInt8 * path) -> (FSRef ref, Boolean isDirectory)")},
#if TARGET_API_MAC_OSX
- {"FNNotify", (PyCFunction)File_FNNotify, 1,
- PyDoc_STR("(FSRef ref, FNMessage message, OptionBits flags) -> None")},
-#endif
-
-#if TARGET_API_MAC_OSX
{"FNNotifyByPath", (PyCFunction)File_FNNotifyByPath, 1,
PyDoc_STR("(UInt8 * path, FNMessage message, OptionBits flags) -> None")},
#endif
@@ -1436,13 +2238,113 @@
{"FNNotifyAll", (PyCFunction)File_FNNotifyAll, 1,
PyDoc_STR("(FNMessage message, OptionBits flags) -> None")},
#endif
- {"FSRefMakePath", (PyCFunction)File_FSRefMakePath, 1,
- PyDoc_STR("(FSRef) -> string")},
+ {"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)")},
+ {"ResolveAliasFileWithMountFlagsNoUI", (PyCFunction)File_ResolveAliasFileWithMountFlagsNoUI, 1,
+ PyDoc_STR("(FSSpec theSpec, Boolean resolveAliasChains, unsigned long mountFlags) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")},
+ {"FSResolveAliasFileWithMountFlags", (PyCFunction)File_FSResolveAliasFileWithMountFlags, 1,
+ PyDoc_STR("(Boolean resolveAliasChains, unsigned long mountFlags) -> (FSRef theRef, Boolean targetIsFolder, Boolean wasAliased)")},
+ {"FSResolveAliasFile", (PyCFunction)File_FSResolveAliasFile, 1,
+ PyDoc_STR("(Boolean resolveAliasChains) -> (FSRef theRef, Boolean targetIsFolder, Boolean wasAliased)")},
{NULL, NULL, 0}
};
+static int
+myPyMac_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();
+#if !TARGET_API_MAC_OSX
+ /* On OS9 we now try a pathname */
+ if ( PyString_Check(v) ) {
+ /* It's a pathname */
+ if( !PyArg_Parse(v, "O&", PyMac_GetStr255, &path) )
+ return 0;
+ refnum = 0; /* XXXX Should get CurWD here?? */
+ parid = 0;
+ err = FSMakeFSSpec(refnum, parid, path, spec);
+ if ( err && err != fnfErr ) {
+ PyMac_Error(err);
+ return 0;
+ }
+ return 1;
+ }
+ PyErr_Clear();
+#endif
+ /* 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 TARGET_API_MAX_OSX
+ if ( myPyMac_GetFSRef(v, &fsr) >= 0 ) {
+#else
+ if ( PyArg_Parse(v, "O&", FSRef_Convert, &fsr) ) {
+#endif
+ err = FSGetCatalogInfo(&fsr, kFSCatInfoNone, NULL, NULL, spec, NULL);
+ if (err != noErr) {
+ PyMac_Error(err);
+ return 0;
+ }
+ return 1;
+ }
+ PyErr_SetString(PyExc_TypeError, "FSSpec, FSRef, pathname or (refnum, parid, path) required");
+ return 0;
+}
+
+static int
+myPyMac_GetFSRef(PyObject *v, FSRef *fsr)
+{
+ if (FSRef_Check(v)) {
+ *fsr = ((FSRefObject *)v)->ob_itself;
+ return 1;
+ }
+
+#if !TARGET_API_MAC_OSX
+ /* On OSX we now try a pathname */
+ if ( PyString_Check(args) ) {
+ OSStatus err;
+ if ( (err=FSPathMakeRef(PyString_AsString(v), fsr, NULL)) ) {
+ PyErr_Mac(ErrorObject, err);
+ return 0;
+ }
+ return 1;
+ }
+ /* XXXX Should try unicode here too */
+#endif
+ /* Otherwise we try to go via an FSSpec */
+ if (FSSpec_Check(v)) {
+ if (FSpMakeFSRef(&((FSSpecObject *)v)->ob_itself, fsr))
+ return 1;
+ return 0;
+ }
+ PyErr_SetString(PyExc_TypeError, "FSRef, FSSpec or pathname required");
+ return 0;
+}
+
void init_File(void)
{
@@ -1458,6 +2360,24 @@
if (File_Error == NULL ||
PyDict_SetItemString(d, "Error", File_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);
+ FSSpec_Type.ob_type = &PyType_Type;
+ 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);
+ FSRef_Type.ob_type = &PyType_Type;
+ 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 ======================== */
diff --git a/Mac/Modules/file/filescan.py b/Mac/Modules/file/filescan.py
index 454fefc7..0195fea 100644
--- a/Mac/Modules/file/filescan.py
+++ b/Mac/Modules/file/filescan.py
@@ -8,10 +8,9 @@
LONG = "Files"
SHORT = "file"
-OBJECT = "NOTUSED"
def main():
- input = LONG + ".h"
+ input = ["Files.h", "Aliases.h"]
output = SHORT + "gen.py"
defsoutput = TOOLBOXDIR + LONG + ".py"
scanner = MyScanner(input, output, defsoutput)
@@ -30,11 +29,24 @@
classname = "Function"
listname = "functions"
if arglist:
+ # Funny special case
+ if len(arglist) > 2:
+ t, n, m = arglist[1]
+ if t == "AliasHandle" and m == "InMode":
+ classname = "Arg2MethodGenerator"
+ listname = "alias_methods"
+ return classname, listname
+ # Normal cases
t, n, m = arglist[0]
- # This is non-functional today
- if t == OBJECT and m == "InMode":
+ if t == "AliasHandle" and m == "InMode":
classname = "Method"
- listname = "methods"
+ listname = "alias_methods"
+ if t == "FSSpec_ptr" and m == "InMode":
+ classname = "Method"
+ listname = "fsspec_methods"
+ if t == "FSRef_ptr" and m == "InMode":
+ classname = "Method"
+ listname = "fsref_methods"
return classname, listname
def makeblacklistnames(self):
@@ -45,6 +57,9 @@
"kFSIterateReserved",
"FSRefMakePath", # Do this manually
+# "ResolveAlias", # Do this manually
+# "ResolveAliasWithMountFlags", # Do this manually
+# "FollowFinderAlias", # Do this manually
"FSRead", # Couldn't be bothered
"FSWrite", # ditto
@@ -128,7 +143,8 @@
"IOCompletionProcPtr", # proc pointer
"IOCompletionUPP", # Proc pointer
-
+ "AliasFilterProcPtr",
+ "AliasFilterUPP",
]
@@ -144,6 +160,18 @@
('UniChar_ptr', '*', 'InMode')],
[('UnicodeReverseInBuffer', '*', 'InMode')]
),
+ # Wrong guess
+ ([('Str63', 'theString', 'InMode')],
+ [('Str63', 'theString', 'OutMode')]),
+
+ # Yet another way to give a pathname:-)
+ ([('short', 'fullPathLength', 'InMode'),
+ ('void_ptr', 'fullPath', 'InMode')],
+ [('FullPathName', 'fullPath', 'InMode')]),
+
+ # Various ResolveAliasFileXXXX functions
+ ([('FSSpec', 'theSpec', 'OutMode')],
+ [('FSSpec_ptr', 'theSpec', 'InOutMode')]),
]
diff --git a/Mac/Modules/file/filesupport.py b/Mac/Modules/file/filesupport.py
index f916c34..c431d42 100644
--- a/Mac/Modules/file/filesupport.py
+++ b/Mac/Modules/file/filesupport.py
@@ -6,7 +6,7 @@
import string
# Declarations that change for each manager
-MACHEADERFILE = 'Files.h' # The Apple header file
+#MACHEADERFILE = 'Files.h' # The Apple header file
MODNAME = '_File' # The name of the module
# The following is *usually* unchanged but may still require tuning
@@ -16,38 +16,47 @@
from macsupport import *
-# Create the type objects
-#ConstStrFileNameParam = ConstStr255Param
-#StrFileName = Str255
-#FolderClass = OSTypeType("FolderClass")
-# FolderDesc
-#FolderDescFlags = Type("FolderDescFlags", "l")
-#FolderLocation = OSTypeType("FolderLocation")
-# FolderRouting
-#FolderType = OSTypeType("FolderType")
-#RoutingFlags = Type("RoutingFlags", "l")
-
-class UniCharCountBuffer(InputOnlyType):
- pass
-
-#CatPositionRec
-ConstStr63Param = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255")
-FInfo = OpaqueByValueStructType("FInfo", "PyMac_BuildFInfo", "PyMac_GetFInfo")
-FInfo_ptr = OpaqueType("FInfo", "PyMac_BuildFInfo", "PyMac_GetFInfo")
-FNMessage = Type("FNMessage", "l")
-FSAllocationFlags = Type("FSAllocationFlags", "H")
-#FSCatalogInfo
-FSCatalogInfoBitmap = Type("FSCatalogInfoBitmap", "l")
-#FSForkInfo
-#FSIterator
-FSIteratorFlags = Type("FSIteratorFlags", "l")
-#FSVolumeInfo
-FSVolumeRefNum = Type("FSVolumeRefNum", "h")
-HFSUniStr255 = OpaqueType("HFSUniStr255", "PyMac_BuildHFSUniStr255", "PyMac_GetHFSUniStr255")
+# Various integers:
SInt64 = Type("SInt64", "L")
UInt64 = Type("UInt64", "L")
+FNMessage = Type("FNMessage", "l")
+FSAllocationFlags = Type("FSAllocationFlags", "H")
+FSCatalogInfoBitmap = Type("FSCatalogInfoBitmap", "l")
+FSIteratorFlags = Type("FSIteratorFlags", "l")
+FSVolumeRefNum = Type("FSVolumeRefNum", "h")
+AliasInfoType = Type("AliasInfoType", "h")
+
+# Various types of strings:
+#class UniCharCountBuffer(InputOnlyType):
+# pass
+class VarReverseInputBufferType(ReverseInputBufferMixin, VarInputBufferType):
+ pass
+FullPathName = VarReverseInputBufferType()
+ConstStr31Param = OpaqueArrayType("Str31", "PyMac_BuildStr255", "PyMac_GetStr255")
+ConstStr32Param = OpaqueArrayType("Str32", "PyMac_BuildStr255", "PyMac_GetStr255")
+ConstStr63Param = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255")
+Str63 = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255")
+
+HFSUniStr255 = OpaqueType("HFSUniStr255", "PyMac_BuildHFSUniStr255", "PyMac_GetHFSUniStr255")
UInt8_ptr = InputOnlyType("UInt8 *", "s")
+# Other types:
+FInfo = OpaqueByValueStructType("FInfo", "PyMac_BuildFInfo", "PyMac_GetFInfo")
+FInfo_ptr = OpaqueType("FInfo", "PyMac_BuildFInfo", "PyMac_GetFInfo")
+AliasHandle = OpaqueByValueType("AliasHandle", "Alias")
+FSSpec = OpaqueType("FSSpec", "FSSpec")
+FSSpec_ptr = OpaqueType("FSSpec", "FSSpec")
+FSRef = OpaqueType("FSRef", "FSRef")
+FSRef_ptr = OpaqueType("FSRef", "FSRef")
+
+# To be done:
+#CatPositionRec
+#FSCatalogInfo
+#FSForkInfo
+#FSIterator
+#FSVolumeInfo
+#FSSpecArrayPtr
+
includestuff = includestuff + """
#ifdef WITHOUT_FRAMEWORKS
#include <Files.h>
@@ -55,6 +64,16 @@
#include <Carbon/Carbon.h>
#endif
+/* Forward declarations */
+extern PyObject *FSRef_New(FSRef *itself);
+extern PyObject *FSSpec_New(FSSpec *itself);
+extern PyObject *Alias_New(AliasHandle itself);
+extern int FSRef_Convert(PyObject *v, FSRef *p_itself);
+extern int FSSpec_Convert(PyObject *v, FSSpec *p_itself);
+extern int Alias_Convert(PyObject *v, AliasHandle *p_itself);
+static int myPyMac_GetFSSpec(PyObject *v, FSSpec *spec);
+static int myPyMac_GetFSRef(PyObject *v, FSRef *fsr);
+
/*
** Parse/generate objsect
*/
@@ -65,19 +84,6 @@
return Py_BuildValue("u#", itself->unicode, itself->length);
}
-#if 0
-static int
-PyMac_GetHFSUniStr255(PyObject *v, HFSUniStr255 *itself)
-{
- return PyArg_ParseTuple(v, "O&O&O&O&O&",
- PyMac_GetFixed, &itself->ascent,
- PyMac_GetFixed, &itself->descent,
- PyMac_GetFixed, &itself->leading,
- PyMac_GetFixed, &itself->widMax,
- ResObj_Convert, &itself->wTabHandle);
-}
-#endif
-
/*
** Parse/generate objsect
*/
@@ -103,35 +109,240 @@
PyMac_GetPoint, &itself->fdLocation,
&itself->fdFldr);
}
+"""
+finalstuff = finalstuff + """
+static int
+myPyMac_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();
+#if !TARGET_API_MAC_OSX
+ /* On OS9 we now try a pathname */
+ if ( PyString_Check(v) ) {
+ /* It's a pathname */
+ if( !PyArg_Parse(v, "O&", PyMac_GetStr255, &path) )
+ return 0;
+ refnum = 0; /* XXXX Should get CurWD here?? */
+ parid = 0;
+ err = FSMakeFSSpec(refnum, parid, path, spec);
+ if ( err && err != fnfErr ) {
+ PyMac_Error(err);
+ return 0;
+ }
+ return 1;
+ }
+ PyErr_Clear();
+#endif
+ /* 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 TARGET_API_MAX_OSX
+ if ( myPyMac_GetFSRef(v, &fsr) >= 0 ) {
+#else
+ if ( PyArg_Parse(v, "O&", FSRef_Convert, &fsr) ) {
+#endif
+ err = FSGetCatalogInfo(&fsr, kFSCatInfoNone, NULL, NULL, spec, NULL);
+ if (err != noErr) {
+ PyMac_Error(err);
+ return 0;
+ }
+ return 1;
+ }
+ PyErr_SetString(PyExc_TypeError, "FSSpec, FSRef, pathname or (refnum, parid, path) required");
+ return 0;
+}
+
+static int
+myPyMac_GetFSRef(PyObject *v, FSRef *fsr)
+{
+ if (FSRef_Check(v)) {
+ *fsr = ((FSRefObject *)v)->ob_itself;
+ return 1;
+ }
+
+#if !TARGET_API_MAC_OSX
+ /* On OSX we now try a pathname */
+ if ( PyString_Check(args) ) {
+ OSStatus err;
+ if ( (err=FSPathMakeRef(PyString_AsString(v), fsr, NULL)) ) {
+ PyErr_Mac(ErrorObject, err);
+ return 0;
+ }
+ return 1;
+ }
+ /* XXXX Should try unicode here too */
+#endif
+ /* Otherwise we try to go via an FSSpec */
+ if (FSSpec_Check(v)) {
+ if (FSpMakeFSRef(&((FSSpecObject *)v)->ob_itself, fsr))
+ return 1;
+ return 0;
+ }
+ PyErr_SetString(PyExc_TypeError, "FSRef, FSSpec or pathname required");
+ return 0;
+}
"""
execfile(string.lower(MODPREFIX) + 'typetest.py')
+# Our object types:
+class FSSpecDefinition(PEP253Mixin, GlobalObjectDefinition):
+ def __init__(self, name, prefix, itselftype):
+ GlobalObjectDefinition.__init__(self, name, prefix, itselftype)
+ self.argref = "*" # Store FSSpecs, but pass them by address
+
+ def outputCheckNewArg(self):
+ Output("if (itself == NULL) return PyMac_Error(resNotFound);")
+
+ def output_tp_newBody(self):
+ Output("PyObject *self;");
+ Output()
+ Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
+ Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",
+ self.objecttype, self.objecttype)
+ Output("return self;")
+
+ def output_tp_initBody(self):
+ Output("PyObject *v;")
+ Output("char *kw[] = {\"itself\", 0};")
+ Output()
+ Output("if (!PyArg_ParseTupleAndKeywords(args, kwds, \"O\", kw, &v))")
+ Output("return -1;")
+ Output("if (myPyMac_GetFSSpec(v, &((%s *)self)->ob_itself)) return 0;", self.objecttype)
+ Output("return -1;")
+
+class FSRefDefinition(PEP253Mixin, GlobalObjectDefinition):
+ def __init__(self, name, prefix, itselftype):
+ GlobalObjectDefinition.__init__(self, name, prefix, itselftype)
+ self.argref = "*" # Store FSRefs, but pass them by address
+
+ def outputCheckNewArg(self):
+ Output("if (itself == NULL) return PyMac_Error(resNotFound);")
+
+ def output_tp_newBody(self):
+ Output("PyObject *self;");
+ Output()
+ Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
+ Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",
+ self.objecttype, self.objecttype)
+ Output("return self;")
+
+ def output_tp_initBody(self):
+ Output("PyObject *v;")
+ Output("char *kw[] = {\"itself\", 0};")
+ Output()
+ Output("if (!PyArg_ParseTupleAndKeywords(args, kwds, \"O\", kw, &v))")
+ Output("return -1;")
+ Output("if (myPyMac_GetFSRef(v, &((%s *)self)->ob_itself)) return 0;", self.objecttype)
+ Output("return -1;")
+
+class AliasDefinition(PEP253Mixin, GlobalObjectDefinition):
+ # XXXX Should inherit from resource?
+
+ def outputCheckNewArg(self):
+ Output("if (itself == NULL) return PyMac_Error(resNotFound);")
+
+ def outputStructMembers(self):
+ GlobalObjectDefinition.outputStructMembers(self)
+ Output("void (*ob_freeit)(%s ptr);", self.itselftype)
+
+ def outputInitStructMembers(self):
+ GlobalObjectDefinition.outputInitStructMembers(self)
+ Output("it->ob_freeit = NULL;")
+
+ def outputCleanupStructMembers(self):
+ Output("if (self->ob_freeit && self->ob_itself)")
+ OutLbrace()
+ Output("self->ob_freeit(self->ob_itself);")
+ OutRbrace()
+ Output("self->ob_itself = NULL;")
+
+ def output_tp_newBody(self):
+ Output("PyObject *self;");
+ Output()
+ Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
+ Output("((%s *)self)->ob_itself = NULL;", self.objecttype)
+ Output("return self;")
+
+ def output_tp_initBody(self):
+ Output("%s itself;", self.itselftype);
+ Output("char *kw[] = {\"itself\", 0};")
+ Output()
+ Output("if (PyArg_ParseTupleAndKeywords(args, kwds, \"O&\", kw, %s_Convert, &itself))",
+ self.prefix)
+ OutLbrace()
+ Output("((%s *)self)->ob_itself = itself;", self.objecttype)
+ Output("return 0;")
+ OutRbrace()
+ Output("return -1;")
+
+# Alias methods come in two flavors: those with the alias as arg1 and
+# those with the alias as arg 2.
+class Arg2MethodGenerator(MethodGenerator):
+ """Similar to MethodGenerator, but has self as second argument"""
+
+ def parseArgumentList(self, args):
+ args0, arg1, argsrest = args[:1], args[1], args[2:]
+ t0, n0, m0 = arg1
+ args = args0 + argsrest
+ if m0 != InMode:
+ raise ValueError, "method's 'self' must be 'InMode'"
+ self.itself = Variable(t0, "_self->ob_itself", SelfMode)
+ FunctionGenerator.parseArgumentList(self, args)
+ self.argumentList.insert(2, self.itself)
+
# From here on it's basically all boiler plate...
# Create the generator groups and link them
module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff)
+aliasobject = AliasDefinition('Alias', 'Alias', 'AliasHandle')
+fsspecobject = FSSpecDefinition('FSSpec', 'FSSpec', 'FSSpec')
+fsrefobject = FSRefDefinition('FSRef', 'FSRef', 'FSRef')
+
+module.addobject(aliasobject)
+module.addobject(fsspecobject)
+module.addobject(fsrefobject)
+
# Create the generator classes used to populate the lists
Function = OSErrFunctionGenerator
+Method = OSErrMethodGenerator
# Create and populate the lists
functions = []
+alias_methods = []
+fsref_methods = []
+fsspec_methods = []
execfile(INPUTFILE)
# Manual generators:
FSRefMakePath_body = """
OSStatus _err;
-FSRef ref;
#define MAXPATHNAME 1024
UInt8 path[MAXPATHNAME];
UInt32 maxPathSize = MAXPATHNAME;
-if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetFSRef, &ref))
- return NULL;
-_err = FSRefMakePath(&ref,
+_err = FSRefMakePath(&_self->ob_itself,
path,
maxPathSize);
if (_err != noErr) return PyMac_Error(_err);
@@ -139,12 +350,16 @@
return _res;
"""
f = ManualGenerator("FSRefMakePath", FSRefMakePath_body)
-f.docstring = lambda: "(FSRef) -> string"
-functions.append(f)
+f.docstring = lambda: "() -> string"
+fsref_methods.append(f)
+
# add the populated lists to the generator groups
# (in a different wordl the scan program would generate this)
for f in functions: module.add(f)
+for f in alias_methods: aliasobject.add(f)
+for f in fsspec_methods: fsspecobject.add(f)
+for f in fsref_methods: fsrefobject.add(f)
# generate output (open the output file as late as possible)
SetOutputFileName(OUTPUTFILE)