mirror of https://github.com/python/cpython.git
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.
This commit is contained in:
Jack Jansen
parent
bbfd859521
commit
e3a1c8f875
|
|
@ -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 ======================== */
|
||||
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -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 @@ def destination(self, type, name, arglist):
|
|||
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 @@ def makeblacklistnames(self):
|
|||
"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 @@ def makeblacklisttypes(self):
|
|||
|
||||
"IOCompletionProcPtr", # proc pointer
|
||||
"IOCompletionUPP", # Proc pointer
|
||||
|
||||
"AliasFilterProcPtr",
|
||||
"AliasFilterUPP",
|
||||
|
||||
]
|
||||
|
||||
|
|
@ -144,6 +160,18 @@ def makerepairinstructions(self):
|
|||
('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')]),
|
||||
]
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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 @@ class UniCharCountBuffer(InputOnlyType):
|
|||
#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 @@ class UniCharCountBuffer(InputOnlyType):
|
|||
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 @@ class UniCharCountBuffer(InputOnlyType):
|
|||
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 @@ class UniCharCountBuffer(InputOnlyType):
|
|||
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)
|
||||
|
|
|
|||
Loading…
Reference in New Issue