| |
| /* ========================== Module _File ========================== */ |
| |
| #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 |
| |
| /* |
| ** Parse/generate objsect |
| */ |
| static PyObject * |
| PyMac_BuildHFSUniStr255(HFSUniStr255 *itself) |
| { |
| |
| 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 |
| */ |
| static PyObject * |
| PyMac_BuildFInfo(FInfo *itself) |
| { |
| |
| return Py_BuildValue("O&O&HO&h", |
| PyMac_BuildOSType, itself->fdType, |
| PyMac_BuildOSType, itself->fdCreator, |
| itself->fdFlags, |
| PyMac_BuildPoint, &itself->fdLocation, |
| itself->fdFldr); |
| } |
| |
| static int |
| PyMac_GetFInfo(PyObject *v, FInfo *itself) |
| { |
| return PyArg_ParseTuple(v, "O&O&HO&h", |
| PyMac_GetOSType, &itself->fdType, |
| PyMac_GetOSType, &itself->fdCreator, |
| &itself->fdFlags, |
| PyMac_GetPoint, &itself->fdLocation, |
| &itself->fdFldr); |
| } |
| |
| |
| static PyObject *File_Error; |
| |
| static PyObject *File_UnmountVol(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Str63 volName; |
| short vRefNum; |
| if (!PyArg_ParseTuple(_args, "O&h", |
| PyMac_GetStr255, volName, |
| &vRefNum)) |
| return NULL; |
| _err = UnmountVol(volName, |
| vRefNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_FlushVol(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Str63 volName; |
| short vRefNum; |
| if (!PyArg_ParseTuple(_args, "O&h", |
| PyMac_GetStr255, volName, |
| &vRefNum)) |
| return NULL; |
| _err = FlushVol(volName, |
| vRefNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_HSetVol(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| Str63 volName; |
| short vRefNum; |
| long dirID; |
| if (!PyArg_ParseTuple(_args, "O&hl", |
| PyMac_GetStr255, volName, |
| &vRefNum, |
| &dirID)) |
| return NULL; |
| _err = HSetVol(volName, |
| vRefNum, |
| dirID); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_FSClose(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short refNum; |
| if (!PyArg_ParseTuple(_args, "h", |
| &refNum)) |
| return NULL; |
| _err = FSClose(refNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_Allocate(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short refNum; |
| long count; |
| if (!PyArg_ParseTuple(_args, "h", |
| &refNum)) |
| return NULL; |
| _err = Allocate(refNum, |
| &count); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| count); |
| return _res; |
| } |
| |
| static PyObject *File_GetEOF(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short refNum; |
| long logEOF; |
| if (!PyArg_ParseTuple(_args, "h", |
| &refNum)) |
| return NULL; |
| _err = GetEOF(refNum, |
| &logEOF); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| logEOF); |
| return _res; |
| } |
| |
| static PyObject *File_SetEOF(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short refNum; |
| long logEOF; |
| if (!PyArg_ParseTuple(_args, "hl", |
| &refNum, |
| &logEOF)) |
| return NULL; |
| _err = SetEOF(refNum, |
| logEOF); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_GetFPos(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short refNum; |
| long filePos; |
| if (!PyArg_ParseTuple(_args, "h", |
| &refNum)) |
| return NULL; |
| _err = GetFPos(refNum, |
| &filePos); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| filePos); |
| return _res; |
| } |
| |
| static PyObject *File_SetFPos(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short refNum; |
| short posMode; |
| long posOff; |
| if (!PyArg_ParseTuple(_args, "hhl", |
| &refNum, |
| &posMode, |
| &posOff)) |
| return NULL; |
| _err = SetFPos(refNum, |
| posMode, |
| posOff); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_GetVRefNum(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short fileRefNum; |
| short vRefNum; |
| if (!PyArg_ParseTuple(_args, "h", |
| &fileRefNum)) |
| return NULL; |
| _err = GetVRefNum(fileRefNum, |
| &vRefNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| vRefNum); |
| return _res; |
| } |
| |
| static PyObject *File_HGetVol(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| StringPtr volName; |
| short vRefNum; |
| long dirID; |
| if (!PyArg_ParseTuple(_args, "O&", |
| PyMac_GetStr255, &volName)) |
| return NULL; |
| _err = HGetVol(volName, |
| &vRefNum, |
| &dirID); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("hl", |
| vRefNum, |
| dirID); |
| return _res; |
| } |
| |
| static PyObject *File_HOpen(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 fileName; |
| SInt8 permission; |
| short refNum; |
| if (!PyArg_ParseTuple(_args, "hlO&b", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, fileName, |
| &permission)) |
| return NULL; |
| _err = HOpen(vRefNum, |
| dirID, |
| fileName, |
| permission, |
| &refNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| refNum); |
| return _res; |
| } |
| |
| static PyObject *File_HOpenDF(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 fileName; |
| SInt8 permission; |
| short refNum; |
| if (!PyArg_ParseTuple(_args, "hlO&b", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, fileName, |
| &permission)) |
| return NULL; |
| _err = HOpenDF(vRefNum, |
| dirID, |
| fileName, |
| permission, |
| &refNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| refNum); |
| return _res; |
| } |
| |
| static PyObject *File_HOpenRF(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 fileName; |
| SInt8 permission; |
| short refNum; |
| if (!PyArg_ParseTuple(_args, "hlO&b", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, fileName, |
| &permission)) |
| return NULL; |
| _err = HOpenRF(vRefNum, |
| dirID, |
| fileName, |
| permission, |
| &refNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("h", |
| refNum); |
| return _res; |
| } |
| |
| static PyObject *File_AllocContig(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short refNum; |
| long count; |
| if (!PyArg_ParseTuple(_args, "h", |
| &refNum)) |
| return NULL; |
| _err = AllocContig(refNum, |
| &count); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| count); |
| return _res; |
| } |
| |
| static PyObject *File_HCreate(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 fileName; |
| OSType creator; |
| OSType fileType; |
| if (!PyArg_ParseTuple(_args, "hlO&O&O&", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, fileName, |
| PyMac_GetOSType, &creator, |
| PyMac_GetOSType, &fileType)) |
| return NULL; |
| _err = HCreate(vRefNum, |
| dirID, |
| fileName, |
| creator, |
| fileType); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_DirCreate(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long parentDirID; |
| Str255 directoryName; |
| long createdDirID; |
| if (!PyArg_ParseTuple(_args, "hlO&", |
| &vRefNum, |
| &parentDirID, |
| PyMac_GetStr255, directoryName)) |
| return NULL; |
| _err = DirCreate(vRefNum, |
| parentDirID, |
| directoryName, |
| &createdDirID); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("l", |
| createdDirID); |
| return _res; |
| } |
| |
| static PyObject *File_HDelete(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 fileName; |
| if (!PyArg_ParseTuple(_args, "hlO&", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, fileName)) |
| return NULL; |
| _err = HDelete(vRefNum, |
| dirID, |
| fileName); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_HGetFInfo(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 fileName; |
| FInfo fndrInfo; |
| if (!PyArg_ParseTuple(_args, "hlO&", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, fileName)) |
| return NULL; |
| _err = HGetFInfo(vRefNum, |
| dirID, |
| fileName, |
| &fndrInfo); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildFInfo, &fndrInfo); |
| return _res; |
| } |
| |
| static PyObject *File_HSetFInfo(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 fileName; |
| FInfo fndrInfo; |
| if (!PyArg_ParseTuple(_args, "hlO&O&", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, fileName, |
| PyMac_GetFInfo, &fndrInfo)) |
| return NULL; |
| _err = HSetFInfo(vRefNum, |
| dirID, |
| fileName, |
| &fndrInfo); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_HSetFLock(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 fileName; |
| if (!PyArg_ParseTuple(_args, "hlO&", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, fileName)) |
| return NULL; |
| _err = HSetFLock(vRefNum, |
| dirID, |
| fileName); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_HRstFLock(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 fileName; |
| if (!PyArg_ParseTuple(_args, "hlO&", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, fileName)) |
| return NULL; |
| _err = HRstFLock(vRefNum, |
| dirID, |
| fileName); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_HRename(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 oldName; |
| Str255 newName; |
| if (!PyArg_ParseTuple(_args, "hlO&O&", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, oldName, |
| PyMac_GetStr255, newName)) |
| return NULL; |
| _err = HRename(vRefNum, |
| dirID, |
| oldName, |
| newName); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_CatMove(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 oldName; |
| long newDirID; |
| Str255 newName; |
| if (!PyArg_ParseTuple(_args, "hlO&lO&", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, oldName, |
| &newDirID, |
| PyMac_GetStr255, newName)) |
| return NULL; |
| _err = CatMove(vRefNum, |
| dirID, |
| oldName, |
| newDirID, |
| newName); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_FSMakeFSSpec(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| short vRefNum; |
| long dirID; |
| Str255 fileName; |
| FSSpec spec; |
| if (!PyArg_ParseTuple(_args, "hlO&", |
| &vRefNum, |
| &dirID, |
| PyMac_GetStr255, fileName)) |
| return NULL; |
| _err = FSMakeFSSpec(vRefNum, |
| dirID, |
| fileName, |
| &spec); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| 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); |
| return _res; |
| } |
| |
| static PyObject *File_FSGetForkPosition(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 forkRefNum; |
| SInt64 position; |
| if (!PyArg_ParseTuple(_args, "h", |
| &forkRefNum)) |
| return NULL; |
| _err = FSGetForkPosition(forkRefNum, |
| &position); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("L", |
| position); |
| return _res; |
| } |
| |
| static PyObject *File_FSSetForkPosition(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 forkRefNum; |
| UInt16 positionMode; |
| SInt64 positionOffset; |
| if (!PyArg_ParseTuple(_args, "hHL", |
| &forkRefNum, |
| &positionMode, |
| &positionOffset)) |
| return NULL; |
| _err = FSSetForkPosition(forkRefNum, |
| positionMode, |
| positionOffset); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_FSGetForkSize(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 forkRefNum; |
| SInt64 forkSize; |
| if (!PyArg_ParseTuple(_args, "h", |
| &forkRefNum)) |
| return NULL; |
| _err = FSGetForkSize(forkRefNum, |
| &forkSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("L", |
| forkSize); |
| return _res; |
| } |
| |
| static PyObject *File_FSSetForkSize(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 forkRefNum; |
| UInt16 positionMode; |
| SInt64 positionOffset; |
| if (!PyArg_ParseTuple(_args, "hHL", |
| &forkRefNum, |
| &positionMode, |
| &positionOffset)) |
| return NULL; |
| _err = FSSetForkSize(forkRefNum, |
| positionMode, |
| positionOffset); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_FSAllocateFork(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 forkRefNum; |
| FSAllocationFlags flags; |
| UInt16 positionMode; |
| SInt64 positionOffset; |
| UInt64 requestCount; |
| UInt64 actualCount; |
| if (!PyArg_ParseTuple(_args, "hHHLL", |
| &forkRefNum, |
| &flags, |
| &positionMode, |
| &positionOffset, |
| &requestCount)) |
| return NULL; |
| _err = FSAllocateFork(forkRefNum, |
| flags, |
| positionMode, |
| positionOffset, |
| requestCount, |
| &actualCount); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("L", |
| actualCount); |
| return _res; |
| } |
| |
| static PyObject *File_FSFlushFork(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 forkRefNum; |
| if (!PyArg_ParseTuple(_args, "h", |
| &forkRefNum)) |
| return NULL; |
| _err = FSFlushFork(forkRefNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_FSCloseFork(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| SInt16 forkRefNum; |
| if (!PyArg_ParseTuple(_args, "h", |
| &forkRefNum)) |
| return NULL; |
| _err = FSCloseFork(forkRefNum); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_FSGetDataForkName(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| HFSUniStr255 dataForkName; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = FSGetDataForkName(&dataForkName); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildHFSUniStr255, &dataForkName); |
| return _res; |
| } |
| |
| static PyObject *File_FSGetResourceForkName(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSErr _err; |
| HFSUniStr255 resourceForkName; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = FSGetResourceForkName(&resourceForkName); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| PyMac_BuildHFSUniStr255, &resourceForkName); |
| return _res; |
| } |
| |
| static PyObject *File_FSPathMakeRef(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| char* path; |
| FSRef ref; |
| Boolean isDirectory; |
| if (!PyArg_ParseTuple(_args, "s", |
| &path)) |
| return NULL; |
| _err = FSPathMakeRef(path, |
| &ref, |
| &isDirectory); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&b", |
| PyMac_BuildFSRef, &ref, |
| isDirectory); |
| return _res; |
| } |
| |
| 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; |
| } |
| |
| static PyObject *File_FNNotifyByPath(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| char* path; |
| FNMessage message; |
| OptionBits flags; |
| if (!PyArg_ParseTuple(_args, "sll", |
| &path, |
| &message, |
| &flags)) |
| return NULL; |
| _err = FNNotifyByPath(path, |
| message, |
| flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_FNNotifyAll(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| FNMessage message; |
| OptionBits flags; |
| if (!PyArg_ParseTuple(_args, "ll", |
| &message, |
| &flags)) |
| return NULL; |
| _err = FNNotifyAll(message, |
| flags); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *File_FSRefMakePath(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)) |
| return NULL; |
| _err = FSRefMakePath(&ref, |
| path, |
| maxPathSize); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("s", path); |
| return _res; |
| |
| } |
| |
| static PyMethodDef File_methods[] = { |
| {"UnmountVol", (PyCFunction)File_UnmountVol, 1, |
| PyDoc_STR("(Str63 volName, short vRefNum) -> None")}, |
| {"FlushVol", (PyCFunction)File_FlushVol, 1, |
| PyDoc_STR("(Str63 volName, short vRefNum) -> None")}, |
| {"HSetVol", (PyCFunction)File_HSetVol, 1, |
| PyDoc_STR("(Str63 volName, short vRefNum, long dirID) -> None")}, |
| {"FSClose", (PyCFunction)File_FSClose, 1, |
| PyDoc_STR("(short refNum) -> None")}, |
| {"Allocate", (PyCFunction)File_Allocate, 1, |
| PyDoc_STR("(short refNum) -> (long count)")}, |
| {"GetEOF", (PyCFunction)File_GetEOF, 1, |
| PyDoc_STR("(short refNum) -> (long logEOF)")}, |
| {"SetEOF", (PyCFunction)File_SetEOF, 1, |
| PyDoc_STR("(short refNum, long logEOF) -> None")}, |
| {"GetFPos", (PyCFunction)File_GetFPos, 1, |
| PyDoc_STR("(short refNum) -> (long filePos)")}, |
| {"SetFPos", (PyCFunction)File_SetFPos, 1, |
| PyDoc_STR("(short refNum, short posMode, long posOff) -> None")}, |
| {"GetVRefNum", (PyCFunction)File_GetVRefNum, 1, |
| PyDoc_STR("(short fileRefNum) -> (short vRefNum)")}, |
| {"HGetVol", (PyCFunction)File_HGetVol, 1, |
| PyDoc_STR("(StringPtr volName) -> (short vRefNum, long dirID)")}, |
| {"HOpen", (PyCFunction)File_HOpen, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")}, |
| {"HOpenDF", (PyCFunction)File_HOpenDF, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")}, |
| {"HOpenRF", (PyCFunction)File_HOpenRF, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")}, |
| {"AllocContig", (PyCFunction)File_AllocContig, 1, |
| PyDoc_STR("(short refNum) -> (long count)")}, |
| {"HCreate", (PyCFunction)File_HCreate, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, OSType creator, OSType fileType) -> None")}, |
| {"DirCreate", (PyCFunction)File_DirCreate, 1, |
| PyDoc_STR("(short vRefNum, long parentDirID, Str255 directoryName) -> (long createdDirID)")}, |
| {"HDelete", (PyCFunction)File_HDelete, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, |
| {"HGetFInfo", (PyCFunction)File_HGetFInfo, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> (FInfo fndrInfo)")}, |
| {"HSetFInfo", (PyCFunction)File_HSetFInfo, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, FInfo fndrInfo) -> None")}, |
| {"HSetFLock", (PyCFunction)File_HSetFLock, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, |
| {"HRstFLock", (PyCFunction)File_HRstFLock, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, |
| {"HRename", (PyCFunction)File_HRename, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 oldName, Str255 newName) -> None")}, |
| {"CatMove", (PyCFunction)File_CatMove, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 oldName, long newDirID, Str255 newName) -> None")}, |
| {"FSMakeFSSpec", (PyCFunction)File_FSMakeFSSpec, 1, |
| PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> (FSSpec spec)")}, |
| {"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, |
| PyDoc_STR("(SInt16 forkRefNum, UInt16 positionMode, SInt64 positionOffset) -> None")}, |
| {"FSGetForkSize", (PyCFunction)File_FSGetForkSize, 1, |
| PyDoc_STR("(SInt16 forkRefNum) -> (SInt64 forkSize)")}, |
| {"FSSetForkSize", (PyCFunction)File_FSSetForkSize, 1, |
| PyDoc_STR("(SInt16 forkRefNum, UInt16 positionMode, SInt64 positionOffset) -> None")}, |
| {"FSAllocateFork", (PyCFunction)File_FSAllocateFork, 1, |
| PyDoc_STR("(SInt16 forkRefNum, FSAllocationFlags flags, UInt16 positionMode, SInt64 positionOffset, UInt64 requestCount) -> (UInt64 actualCount)")}, |
| {"FSFlushFork", (PyCFunction)File_FSFlushFork, 1, |
| PyDoc_STR("(SInt16 forkRefNum) -> None")}, |
| {"FSCloseFork", (PyCFunction)File_FSCloseFork, 1, |
| PyDoc_STR("(SInt16 forkRefNum) -> None")}, |
| {"FSGetDataForkName", (PyCFunction)File_FSGetDataForkName, 1, |
| PyDoc_STR("() -> (HFSUniStr255 dataForkName)")}, |
| {"FSGetResourceForkName", (PyCFunction)File_FSGetResourceForkName, 1, |
| PyDoc_STR("() -> (HFSUniStr255 resourceForkName)")}, |
| {"FSPathMakeRef", (PyCFunction)File_FSPathMakeRef, 1, |
| PyDoc_STR("(char* path) -> (FSRef ref, Boolean isDirectory)")}, |
| {"FNNotify", (PyCFunction)File_FNNotify, 1, |
| PyDoc_STR("(FSRef ref, FNMessage message, OptionBits flags) -> None")}, |
| {"FNNotifyByPath", (PyCFunction)File_FNNotifyByPath, 1, |
| PyDoc_STR("(char* path, FNMessage message, OptionBits flags) -> None")}, |
| {"FNNotifyAll", (PyCFunction)File_FNNotifyAll, 1, |
| PyDoc_STR("(FNMessage message, OptionBits flags) -> None")}, |
| {"FSRefMakePath", (PyCFunction)File_FSRefMakePath, 1, |
| PyDoc_STR("(FSRef) -> string")}, |
| {NULL, NULL, 0} |
| }; |
| |
| |
| |
| |
| void init_File(void) |
| { |
| PyObject *m; |
| PyObject *d; |
| |
| |
| |
| |
| m = Py_InitModule("_File", File_methods); |
| d = PyModule_GetDict(m); |
| File_Error = PyMac_GetOSErrException(); |
| if (File_Error == NULL || |
| PyDict_SetItemString(d, "Error", File_Error) != 0) |
| return; |
| } |
| |
| /* ======================== End module _File ======================== */ |
| |