/* ========================== Module _Res =========================== */ #include "Python.h" #include "pymactoolbox.h" /* 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) #include #ifdef USE_TOOLBOX_OBJECT_GLUE extern PyObject *_ResObj_New(Handle); extern int _ResObj_Convert(PyObject *, Handle *); extern PyObject *_OptResObj_New(Handle); extern int _OptResObj_Convert(PyObject *, Handle *); #define ResObj_New _ResObj_New #define ResObj_Convert _ResObj_Convert #define OptResObj_New _OptResObj_New #define OptResObj_Convert _OptResObj_Convert #endif /* Function to dispose a resource, with a "normal" calling sequence */ static void PyMac_AutoDisposeHandle(Handle h) { DisposeHandle(h); } static PyObject *Res_Error; /* ---------------------- Object type Resource ---------------------- */ PyTypeObject Resource_Type; #define ResObj_Check(x) ((x)->ob_type == &Resource_Type || PyObject_TypeCheck((x), &Resource_Type)) typedef struct ResourceObject { PyObject_HEAD Handle ob_itself; void (*ob_freeit)(Handle ptr); } ResourceObject; PyObject *ResObj_New(Handle itself) { ResourceObject *it; if (itself == NULL) return PyMac_Error(resNotFound); it = PyObject_NEW(ResourceObject, &Resource_Type); if (it == NULL) return NULL; it->ob_itself = itself; it->ob_freeit = NULL; return (PyObject *)it; } int ResObj_Convert(PyObject *v, Handle *p_itself) { if (!ResObj_Check(v)) { PyObject *tmp; if ( (tmp=PyObject_CallMethod(v, "as_Resource", "")) ) { *p_itself = ((ResourceObject *)tmp)->ob_itself; Py_DECREF(tmp); return 1; } PyErr_Clear(); } if (!ResObj_Check(v)) { PyErr_SetString(PyExc_TypeError, "Resource required"); return 0; } *p_itself = ((ResourceObject *)v)->ob_itself; return 1; } static void ResObj_dealloc(ResourceObject *self) { if (self->ob_freeit && self->ob_itself) { self->ob_freeit(self->ob_itself); } self->ob_itself = NULL; self->ob_type->tp_free((PyObject *)self); } static PyObject *ResObj_HomeResFile(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; #ifndef HomeResFile PyMac_PRECHECK(HomeResFile); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = HomeResFile(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *ResObj_MacLoadResource(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; #ifndef MacLoadResource PyMac_PRECHECK(MacLoadResource); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; MacLoadResource(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *ResObj_ReleaseResource(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; #ifndef ReleaseResource PyMac_PRECHECK(ReleaseResource); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; ReleaseResource(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *ResObj_DetachResource(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; #ifndef DetachResource PyMac_PRECHECK(DetachResource); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; DetachResource(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *ResObj_GetResAttrs(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; #ifndef GetResAttrs PyMac_PRECHECK(GetResAttrs); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetResAttrs(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *ResObj_GetResInfo(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; short theID; ResType theType; Str255 name; #ifndef GetResInfo PyMac_PRECHECK(GetResInfo); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; GetResInfo(_self->ob_itself, &theID, &theType, name); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("hO&O&", theID, PyMac_BuildOSType, theType, PyMac_BuildStr255, name); return _res; } static PyObject *ResObj_SetResInfo(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; short theID; Str255 name; #ifndef SetResInfo PyMac_PRECHECK(SetResInfo); #endif if (!PyArg_ParseTuple(_args, "hO&", &theID, PyMac_GetStr255, name)) return NULL; SetResInfo(_self->ob_itself, theID, name); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *ResObj_AddResource(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; ResType theType; short theID; Str255 name; #ifndef AddResource PyMac_PRECHECK(AddResource); #endif if (!PyArg_ParseTuple(_args, "O&hO&", PyMac_GetOSType, &theType, &theID, PyMac_GetStr255, name)) return NULL; AddResource(_self->ob_itself, theType, theID, name); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *ResObj_GetResourceSizeOnDisk(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; long _rv; #ifndef GetResourceSizeOnDisk PyMac_PRECHECK(GetResourceSizeOnDisk); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetResourceSizeOnDisk(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("l", _rv); return _res; } static PyObject *ResObj_GetMaxResourceSize(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; long _rv; #ifndef GetMaxResourceSize PyMac_PRECHECK(GetMaxResourceSize); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetMaxResourceSize(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("l", _rv); return _res; } static PyObject *ResObj_SetResAttrs(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; short attrs; #ifndef SetResAttrs PyMac_PRECHECK(SetResAttrs); #endif if (!PyArg_ParseTuple(_args, "h", &attrs)) return NULL; SetResAttrs(_self->ob_itself, attrs); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *ResObj_ChangedResource(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; #ifndef ChangedResource PyMac_PRECHECK(ChangedResource); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; ChangedResource(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *ResObj_RemoveResource(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; #ifndef RemoveResource PyMac_PRECHECK(RemoveResource); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; RemoveResource(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *ResObj_WriteResource(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; #ifndef WriteResource PyMac_PRECHECK(WriteResource); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; WriteResource(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *ResObj_SetResourceSize(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; long newSize; #ifndef SetResourceSize PyMac_PRECHECK(SetResourceSize); #endif if (!PyArg_ParseTuple(_args, "l", &newSize)) return NULL; SetResourceSize(_self->ob_itself, newSize); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *ResObj_GetNextFOND(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; Handle _rv; #ifndef GetNextFOND PyMac_PRECHECK(GetNextFOND); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetNextFOND(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *ResObj_as_Control(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; _res = CtlObj_New((ControlHandle)_self->ob_itself); return _res; } static PyObject *ResObj_as_Menu(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; _res = MenuObj_New((MenuHandle)_self->ob_itself); return _res; } static PyObject *ResObj_LoadResource(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; #ifndef LoadResource PyMac_PRECHECK(LoadResource); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; LoadResource(_self->ob_itself); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *ResObj_AutoDispose(ResourceObject *_self, PyObject *_args) { PyObject *_res = NULL; int onoff, old = 0; if (!PyArg_ParseTuple(_args, "i", &onoff)) return NULL; if ( _self->ob_freeit ) old = 1; if ( onoff ) _self->ob_freeit = PyMac_AutoDisposeHandle; else _self->ob_freeit = NULL; _res = Py_BuildValue("i", old); return _res; } static PyMethodDef ResObj_methods[] = { {"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1, PyDoc_STR("() -> (short _rv)")}, {"MacLoadResource", (PyCFunction)ResObj_MacLoadResource, 1, PyDoc_STR("() -> None")}, {"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1, PyDoc_STR("() -> None")}, {"DetachResource", (PyCFunction)ResObj_DetachResource, 1, PyDoc_STR("() -> None")}, {"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1, PyDoc_STR("() -> (short _rv)")}, {"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1, PyDoc_STR("() -> (short theID, ResType theType, Str255 name)")}, {"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1, PyDoc_STR("(short theID, Str255 name) -> None")}, {"AddResource", (PyCFunction)ResObj_AddResource, 1, PyDoc_STR("(ResType theType, short theID, Str255 name) -> None")}, {"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1, PyDoc_STR("() -> (long _rv)")}, {"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1, PyDoc_STR("() -> (long _rv)")}, {"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1, PyDoc_STR("(short attrs) -> None")}, {"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1, PyDoc_STR("() -> None")}, {"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1, PyDoc_STR("() -> None")}, {"WriteResource", (PyCFunction)ResObj_WriteResource, 1, PyDoc_STR("() -> None")}, {"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1, PyDoc_STR("(long newSize) -> None")}, {"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1, PyDoc_STR("() -> (Handle _rv)")}, {"as_Control", (PyCFunction)ResObj_as_Control, 1, PyDoc_STR("Return this resource/handle as a Control")}, {"as_Menu", (PyCFunction)ResObj_as_Menu, 1, PyDoc_STR("Return this resource/handle as a Menu")}, {"LoadResource", (PyCFunction)ResObj_LoadResource, 1, PyDoc_STR("() -> None")}, {"AutoDispose", (PyCFunction)ResObj_AutoDispose, 1, PyDoc_STR("(int)->int. Automatically DisposeHandle the object on Python object cleanup")}, {NULL, NULL, 0} }; static PyObject *ResObj_get_data(ResourceObject *self, void *closure) { PyObject *res; char state; state = HGetState(self->ob_itself); HLock(self->ob_itself); res = PyString_FromStringAndSize( *self->ob_itself, GetHandleSize(self->ob_itself)); HUnlock(self->ob_itself); HSetState(self->ob_itself, state); return res; } static int ResObj_set_data(ResourceObject *self, PyObject *v, void *closure) { char *data; long size; if ( v == NULL ) return -1; if ( !PyString_Check(v) ) return -1; size = PyString_Size(v); data = PyString_AsString(v); /* XXXX Do I need the GetState/SetState calls? */ SetHandleSize(self->ob_itself, size); if ( MemError()) return -1; HLock(self->ob_itself); memcpy((char *)*self->ob_itself, data, size); HUnlock(self->ob_itself); /* XXXX Should I do the Changed call immedeately? */ return 0; return 0; } static PyObject *ResObj_get_size(ResourceObject *self, void *closure) { return PyInt_FromLong(GetHandleSize(self->ob_itself)); } #define ResObj_set_size NULL static PyGetSetDef ResObj_getsetlist[] = { {"data", (getter)ResObj_get_data, (setter)ResObj_set_data, "The resource data"}, {"size", (getter)ResObj_get_size, (setter)ResObj_set_size, "The length of the resource data"}, {NULL, NULL, NULL, NULL}, }; #define ResObj_compare NULL #define ResObj_repr NULL #define ResObj_hash NULL static int ResObj_tp_init(PyObject *self, PyObject *args, PyObject *kwds) { char *srcdata = NULL; int srclen = 0; Handle itself; char *kw[] = {"itself", 0}; if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, ResObj_Convert, &itself)) { ((ResourceObject *)self)->ob_itself = itself; return 0; } PyErr_Clear(); if (!PyArg_ParseTupleAndKeywords(args, kwds, "|s#", kw, &srcdata, &srclen)) return -1; if ((itself = NewHandle(srclen)) == NULL) { PyErr_NoMemory(); return 0; } ((ResourceObject *)self)->ob_itself = itself; if (srclen && srcdata) { HLock(itself); memcpy(*itself, srcdata, srclen); HUnlock(itself); } return 0; } #define ResObj_tp_alloc PyType_GenericAlloc static PyObject *ResObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyObject *self; if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; ((ResourceObject *)self)->ob_itself = NULL; ((ResourceObject *)self)->ob_freeit = NULL; return self; } #define ResObj_tp_free PyObject_Del PyTypeObject Resource_Type = { PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ "_Res.Resource", /*tp_name*/ sizeof(ResourceObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor) ResObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ (getattrfunc)0, /*tp_getattr*/ (setattrfunc)0, /*tp_setattr*/ (cmpfunc) ResObj_compare, /*tp_compare*/ (reprfunc) ResObj_repr, /*tp_repr*/ (PyNumberMethods *)0, /* tp_as_number */ (PySequenceMethods *)0, /* tp_as_sequence */ (PyMappingMethods *)0, /* tp_as_mapping */ (hashfunc) ResObj_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*/ ResObj_methods, /* tp_methods */ 0, /*tp_members*/ ResObj_getsetlist, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ ResObj_tp_init, /* tp_init */ ResObj_tp_alloc, /* tp_alloc */ ResObj_tp_new, /* tp_new */ ResObj_tp_free, /* tp_free */ }; /* -------------------- End object type Resource -------------------- */ static PyObject *Res_CloseResFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short refNum; #ifndef CloseResFile PyMac_PRECHECK(CloseResFile); #endif if (!PyArg_ParseTuple(_args, "h", &refNum)) return NULL; CloseResFile(refNum); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Res_ResError(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; #ifndef ResError PyMac_PRECHECK(ResError); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _err = ResError(); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Res_CurResFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; #ifndef CurResFile PyMac_PRECHECK(CurResFile); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = CurResFile(); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_UseResFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short refNum; #ifndef UseResFile PyMac_PRECHECK(UseResFile); #endif if (!PyArg_ParseTuple(_args, "h", &refNum)) return NULL; UseResFile(refNum); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Res_CountTypes(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; #ifndef CountTypes PyMac_PRECHECK(CountTypes); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = CountTypes(); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_Count1Types(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; #ifndef Count1Types PyMac_PRECHECK(Count1Types); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = Count1Types(); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_GetIndType(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; ResType theType; short index; #ifndef GetIndType PyMac_PRECHECK(GetIndType); #endif if (!PyArg_ParseTuple(_args, "h", &index)) return NULL; GetIndType(&theType, index); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("O&", PyMac_BuildOSType, theType); return _res; } static PyObject *Res_Get1IndType(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; ResType theType; short index; #ifndef Get1IndType PyMac_PRECHECK(Get1IndType); #endif if (!PyArg_ParseTuple(_args, "h", &index)) return NULL; Get1IndType(&theType, index); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("O&", PyMac_BuildOSType, theType); return _res; } static PyObject *Res_SetResLoad(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; Boolean load; #ifndef SetResLoad PyMac_PRECHECK(SetResLoad); #endif if (!PyArg_ParseTuple(_args, "b", &load)) return NULL; SetResLoad(load); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Res_CountResources(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; ResType theType; #ifndef CountResources PyMac_PRECHECK(CountResources); #endif if (!PyArg_ParseTuple(_args, "O&", PyMac_GetOSType, &theType)) return NULL; _rv = CountResources(theType); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_Count1Resources(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; ResType theType; #ifndef Count1Resources PyMac_PRECHECK(Count1Resources); #endif if (!PyArg_ParseTuple(_args, "O&", PyMac_GetOSType, &theType)) return NULL; _rv = Count1Resources(theType); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_GetIndResource(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; Handle _rv; ResType theType; short index; #ifndef GetIndResource PyMac_PRECHECK(GetIndResource); #endif if (!PyArg_ParseTuple(_args, "O&h", PyMac_GetOSType, &theType, &index)) return NULL; _rv = GetIndResource(theType, index); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Res_Get1IndResource(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; Handle _rv; ResType theType; short index; #ifndef Get1IndResource PyMac_PRECHECK(Get1IndResource); #endif if (!PyArg_ParseTuple(_args, "O&h", PyMac_GetOSType, &theType, &index)) return NULL; _rv = Get1IndResource(theType, index); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Res_GetResource(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; Handle _rv; ResType theType; short theID; #ifndef GetResource PyMac_PRECHECK(GetResource); #endif if (!PyArg_ParseTuple(_args, "O&h", PyMac_GetOSType, &theType, &theID)) return NULL; _rv = GetResource(theType, theID); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Res_Get1Resource(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; Handle _rv; ResType theType; short theID; #ifndef Get1Resource PyMac_PRECHECK(Get1Resource); #endif if (!PyArg_ParseTuple(_args, "O&h", PyMac_GetOSType, &theType, &theID)) return NULL; _rv = Get1Resource(theType, theID); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Res_GetNamedResource(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; Handle _rv; ResType theType; Str255 name; #ifndef GetNamedResource PyMac_PRECHECK(GetNamedResource); #endif if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetOSType, &theType, PyMac_GetStr255, name)) return NULL; _rv = GetNamedResource(theType, name); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Res_Get1NamedResource(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; Handle _rv; ResType theType; Str255 name; #ifndef Get1NamedResource PyMac_PRECHECK(Get1NamedResource); #endif if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetOSType, &theType, PyMac_GetStr255, name)) return NULL; _rv = Get1NamedResource(theType, name); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Res_UniqueID(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; ResType theType; #ifndef UniqueID PyMac_PRECHECK(UniqueID); #endif if (!PyArg_ParseTuple(_args, "O&", PyMac_GetOSType, &theType)) return NULL; _rv = UniqueID(theType); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_Unique1ID(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; ResType theType; #ifndef Unique1ID PyMac_PRECHECK(Unique1ID); #endif if (!PyArg_ParseTuple(_args, "O&", PyMac_GetOSType, &theType)) return NULL; _rv = Unique1ID(theType); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_UpdateResFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short refNum; #ifndef UpdateResFile PyMac_PRECHECK(UpdateResFile); #endif if (!PyArg_ParseTuple(_args, "h", &refNum)) return NULL; UpdateResFile(refNum); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Res_SetResPurge(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; Boolean install; #ifndef SetResPurge PyMac_PRECHECK(SetResPurge); #endif if (!PyArg_ParseTuple(_args, "b", &install)) return NULL; SetResPurge(install); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Res_GetResFileAttrs(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; short refNum; #ifndef GetResFileAttrs PyMac_PRECHECK(GetResFileAttrs); #endif if (!PyArg_ParseTuple(_args, "h", &refNum)) return NULL; _rv = GetResFileAttrs(refNum); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_SetResFileAttrs(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short refNum; short attrs; #ifndef SetResFileAttrs PyMac_PRECHECK(SetResFileAttrs); #endif if (!PyArg_ParseTuple(_args, "hh", &refNum, &attrs)) return NULL; SetResFileAttrs(refNum, attrs); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Res_OpenRFPerm(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; Str255 fileName; short vRefNum; SignedByte permission; #ifndef OpenRFPerm PyMac_PRECHECK(OpenRFPerm); #endif if (!PyArg_ParseTuple(_args, "O&hb", PyMac_GetStr255, fileName, &vRefNum, &permission)) return NULL; _rv = OpenRFPerm(fileName, vRefNum, permission); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_HOpenResFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; short vRefNum; long dirID; Str255 fileName; SignedByte permission; #ifndef HOpenResFile PyMac_PRECHECK(HOpenResFile); #endif if (!PyArg_ParseTuple(_args, "hlO&b", &vRefNum, &dirID, PyMac_GetStr255, fileName, &permission)) return NULL; _rv = HOpenResFile(vRefNum, dirID, fileName, permission); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_HCreateResFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short vRefNum; long dirID; Str255 fileName; #ifndef HCreateResFile PyMac_PRECHECK(HCreateResFile); #endif if (!PyArg_ParseTuple(_args, "hlO&", &vRefNum, &dirID, PyMac_GetStr255, fileName)) return NULL; HCreateResFile(vRefNum, dirID, fileName); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Res_FSpOpenResFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; FSSpec spec; SignedByte permission; #ifndef FSpOpenResFile PyMac_PRECHECK(FSpOpenResFile); #endif if (!PyArg_ParseTuple(_args, "O&b", PyMac_GetFSSpec, &spec, &permission)) return NULL; _rv = FSpOpenResFile(&spec, permission); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_FSpCreateResFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; FSSpec spec; OSType creator; OSType fileType; ScriptCode scriptTag; #ifndef FSpCreateResFile PyMac_PRECHECK(FSpCreateResFile); #endif if (!PyArg_ParseTuple(_args, "O&O&O&h", PyMac_GetFSSpec, &spec, PyMac_GetOSType, &creator, PyMac_GetOSType, &fileType, &scriptTag)) return NULL; FSpCreateResFile(&spec, creator, fileType, scriptTag); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Res_InsertResourceFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; SInt16 refNum; RsrcChainLocation where; #ifndef InsertResourceFile PyMac_PRECHECK(InsertResourceFile); #endif if (!PyArg_ParseTuple(_args, "hh", &refNum, &where)) return NULL; _err = InsertResourceFile(refNum, where); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Res_DetachResourceFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; SInt16 refNum; #ifndef DetachResourceFile PyMac_PRECHECK(DetachResourceFile); #endif if (!PyArg_ParseTuple(_args, "h", &refNum)) return NULL; _err = DetachResourceFile(refNum); if (_err != noErr) return PyMac_Error(_err); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Res_FSpResourceFileAlreadyOpen(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; Boolean _rv; FSSpec resourceFile; Boolean inChain; SInt16 refNum; #ifndef FSpResourceFileAlreadyOpen PyMac_PRECHECK(FSpResourceFileAlreadyOpen); #endif if (!PyArg_ParseTuple(_args, "O&", PyMac_GetFSSpec, &resourceFile)) return NULL; _rv = FSpResourceFileAlreadyOpen(&resourceFile, &inChain, &refNum); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("bbh", _rv, inChain, refNum); return _res; } static PyObject *Res_FSpOpenOrphanResFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; FSSpec spec; SignedByte permission; SInt16 refNum; #ifndef FSpOpenOrphanResFile PyMac_PRECHECK(FSpOpenOrphanResFile); #endif if (!PyArg_ParseTuple(_args, "O&b", PyMac_GetFSSpec, &spec, &permission)) return NULL; _err = FSpOpenOrphanResFile(&spec, permission, &refNum); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("h", refNum); return _res; } static PyObject *Res_GetTopResourceFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; SInt16 refNum; #ifndef GetTopResourceFile PyMac_PRECHECK(GetTopResourceFile); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _err = GetTopResourceFile(&refNum); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("h", refNum); return _res; } static PyObject *Res_GetNextResourceFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; SInt16 curRefNum; SInt16 nextRefNum; #ifndef GetNextResourceFile PyMac_PRECHECK(GetNextResourceFile); #endif if (!PyArg_ParseTuple(_args, "h", &curRefNum)) return NULL; _err = GetNextResourceFile(curRefNum, &nextRefNum); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("h", nextRefNum); return _res; } static PyObject *Res_FSOpenResFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; short _rv; FSRef ref; SignedByte permission; #ifndef FSOpenResFile PyMac_PRECHECK(FSOpenResFile); #endif if (!PyArg_ParseTuple(_args, "O&b", PyMac_GetFSRef, &ref, &permission)) return NULL; _rv = FSOpenResFile(&ref, permission); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Res_FSCreateResFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; FSRef parentRef; UniChar *nameLength__in__; UniCharCount nameLength__len__; int nameLength__in_len__; FSRef newRef; FSSpec newSpec; #ifndef FSCreateResFile PyMac_PRECHECK(FSCreateResFile); #endif if (!PyArg_ParseTuple(_args, "O&u#", PyMac_GetFSRef, &parentRef, &nameLength__in__, &nameLength__in_len__)) return NULL; nameLength__len__ = nameLength__in_len__; FSCreateResFile(&parentRef, nameLength__len__, nameLength__in__, 0, (FSCatalogInfo *)0, &newRef, &newSpec); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("O&O&", PyMac_BuildFSRef, &newRef, PyMac_BuildFSSpec, &newSpec); return _res; } static PyObject *Res_FSResourceFileAlreadyOpen(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; Boolean _rv; FSRef resourceFileRef; Boolean inChain; SInt16 refNum; #ifndef FSResourceFileAlreadyOpen PyMac_PRECHECK(FSResourceFileAlreadyOpen); #endif if (!PyArg_ParseTuple(_args, "O&", PyMac_GetFSRef, &resourceFileRef)) return NULL; _rv = FSResourceFileAlreadyOpen(&resourceFileRef, &inChain, &refNum); { OSErr _err = ResError(); if (_err != noErr) return PyMac_Error(_err); } _res = Py_BuildValue("bbh", _rv, inChain, refNum); return _res; } static PyObject *Res_FSCreateResourceFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; FSRef parentRef; UniChar *nameLength__in__; UniCharCount nameLength__len__; int nameLength__in_len__; UniChar *forkNameLength__in__; UniCharCount forkNameLength__len__; int forkNameLength__in_len__; FSRef newRef; FSSpec newSpec; #ifndef FSCreateResourceFile PyMac_PRECHECK(FSCreateResourceFile); #endif if (!PyArg_ParseTuple(_args, "O&u#u#", PyMac_GetFSRef, &parentRef, &nameLength__in__, &nameLength__in_len__, &forkNameLength__in__, &forkNameLength__in_len__)) return NULL; nameLength__len__ = nameLength__in_len__; forkNameLength__len__ = forkNameLength__in_len__; _err = FSCreateResourceFile(&parentRef, nameLength__len__, nameLength__in__, 0, (FSCatalogInfo *)0, forkNameLength__len__, forkNameLength__in__, &newRef, &newSpec); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&O&", PyMac_BuildFSRef, &newRef, PyMac_BuildFSSpec, &newSpec); return _res; } static PyObject *Res_FSOpenResourceFile(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; OSErr _err; FSRef ref; UniChar *forkNameLength__in__; UniCharCount forkNameLength__len__; int forkNameLength__in_len__; SignedByte permissions; SInt16 refNum; #ifndef FSOpenResourceFile PyMac_PRECHECK(FSOpenResourceFile); #endif if (!PyArg_ParseTuple(_args, "O&u#b", PyMac_GetFSRef, &ref, &forkNameLength__in__, &forkNameLength__in_len__, &permissions)) return NULL; forkNameLength__len__ = forkNameLength__in_len__; _err = FSOpenResourceFile(&ref, forkNameLength__len__, forkNameLength__in__, permissions, &refNum); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("h", refNum); return _res; } static PyObject *Res_Handle(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; char *buf; int len; Handle h; ResourceObject *rv; if (!PyArg_ParseTuple(_args, "s#", &buf, &len)) return NULL; h = NewHandle(len); if ( h == NULL ) { PyErr_NoMemory(); return NULL; } HLock(h); memcpy(*h, buf, len); HUnlock(h); rv = (ResourceObject *)ResObj_New(h); rv->ob_freeit = PyMac_AutoDisposeHandle; _res = (PyObject *)rv; return _res; } static PyMethodDef Res_methods[] = { {"CloseResFile", (PyCFunction)Res_CloseResFile, 1, PyDoc_STR("(short refNum) -> None")}, {"ResError", (PyCFunction)Res_ResError, 1, PyDoc_STR("() -> None")}, {"CurResFile", (PyCFunction)Res_CurResFile, 1, PyDoc_STR("() -> (short _rv)")}, {"UseResFile", (PyCFunction)Res_UseResFile, 1, PyDoc_STR("(short refNum) -> None")}, {"CountTypes", (PyCFunction)Res_CountTypes, 1, PyDoc_STR("() -> (short _rv)")}, {"Count1Types", (PyCFunction)Res_Count1Types, 1, PyDoc_STR("() -> (short _rv)")}, {"GetIndType", (PyCFunction)Res_GetIndType, 1, PyDoc_STR("(short index) -> (ResType theType)")}, {"Get1IndType", (PyCFunction)Res_Get1IndType, 1, PyDoc_STR("(short index) -> (ResType theType)")}, {"SetResLoad", (PyCFunction)Res_SetResLoad, 1, PyDoc_STR("(Boolean load) -> None")}, {"CountResources", (PyCFunction)Res_CountResources, 1, PyDoc_STR("(ResType theType) -> (short _rv)")}, {"Count1Resources", (PyCFunction)Res_Count1Resources, 1, PyDoc_STR("(ResType theType) -> (short _rv)")}, {"GetIndResource", (PyCFunction)Res_GetIndResource, 1, PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")}, {"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1, PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")}, {"GetResource", (PyCFunction)Res_GetResource, 1, PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")}, {"Get1Resource", (PyCFunction)Res_Get1Resource, 1, PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")}, {"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1, PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")}, {"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1, PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")}, {"UniqueID", (PyCFunction)Res_UniqueID, 1, PyDoc_STR("(ResType theType) -> (short _rv)")}, {"Unique1ID", (PyCFunction)Res_Unique1ID, 1, PyDoc_STR("(ResType theType) -> (short _rv)")}, {"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1, PyDoc_STR("(short refNum) -> None")}, {"SetResPurge", (PyCFunction)Res_SetResPurge, 1, PyDoc_STR("(Boolean install) -> None")}, {"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1, PyDoc_STR("(short refNum) -> (short _rv)")}, {"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1, PyDoc_STR("(short refNum, short attrs) -> None")}, {"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1, PyDoc_STR("(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)")}, {"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1, PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)")}, {"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1, PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, {"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1, PyDoc_STR("(FSSpec spec, SignedByte permission) -> (short _rv)")}, {"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1, PyDoc_STR("(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None")}, {"InsertResourceFile", (PyCFunction)Res_InsertResourceFile, 1, PyDoc_STR("(SInt16 refNum, RsrcChainLocation where) -> None")}, {"DetachResourceFile", (PyCFunction)Res_DetachResourceFile, 1, PyDoc_STR("(SInt16 refNum) -> None")}, {"FSpResourceFileAlreadyOpen", (PyCFunction)Res_FSpResourceFileAlreadyOpen, 1, PyDoc_STR("(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")}, {"FSpOpenOrphanResFile", (PyCFunction)Res_FSpOpenOrphanResFile, 1, PyDoc_STR("(FSSpec spec, SignedByte permission) -> (SInt16 refNum)")}, {"GetTopResourceFile", (PyCFunction)Res_GetTopResourceFile, 1, PyDoc_STR("() -> (SInt16 refNum)")}, {"GetNextResourceFile", (PyCFunction)Res_GetNextResourceFile, 1, PyDoc_STR("(SInt16 curRefNum) -> (SInt16 nextRefNum)")}, {"FSOpenResFile", (PyCFunction)Res_FSOpenResFile, 1, PyDoc_STR("(FSRef ref, SignedByte permission) -> (short _rv)")}, {"FSCreateResFile", (PyCFunction)Res_FSCreateResFile, 1, PyDoc_STR("(FSRef parentRef, Buffer nameLength) -> (FSRef newRef, FSSpec newSpec)")}, {"FSResourceFileAlreadyOpen", (PyCFunction)Res_FSResourceFileAlreadyOpen, 1, PyDoc_STR("(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")}, {"FSCreateResourceFile", (PyCFunction)Res_FSCreateResourceFile, 1, PyDoc_STR("(FSRef parentRef, Buffer nameLength, Buffer forkNameLength) -> (FSRef newRef, FSSpec newSpec)")}, {"FSOpenResourceFile", (PyCFunction)Res_FSOpenResourceFile, 1, PyDoc_STR("(FSRef ref, Buffer forkNameLength, SignedByte permissions) -> (SInt16 refNum)")}, {"Handle", (PyCFunction)Res_Handle, 1, PyDoc_STR("Convert a string to a Handle object.\n\nResource() and Handle() are very similar, but objects created with Handle() are\nby default automatically DisposeHandle()d upon object cleanup. Use AutoDispose()\nto change this.\n")}, {NULL, NULL, 0} }; /* Alternative version of ResObj_New, which returns None for null argument */ PyObject *OptResObj_New(Handle itself) { if (itself == NULL) { Py_INCREF(Py_None); return Py_None; } return ResObj_New(itself); } int OptResObj_Convert(PyObject *v, Handle *p_itself) { PyObject *tmp; if ( v == Py_None ) { *p_itself = NULL; return 1; } if (ResObj_Check(v)) { *p_itself = ((ResourceObject *)v)->ob_itself; return 1; } /* If it isn't a resource yet see whether it is convertible */ if ( (tmp=PyObject_CallMethod(v, "as_Resource", "")) ) { *p_itself = ((ResourceObject *)tmp)->ob_itself; Py_DECREF(tmp); return 1; } PyErr_Clear(); PyErr_SetString(PyExc_TypeError, "Resource required"); return 0; } void init_Res(void) { PyObject *m; PyObject *d; PyMac_INIT_TOOLBOX_OBJECT_NEW(Handle, ResObj_New); PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Handle, ResObj_Convert); PyMac_INIT_TOOLBOX_OBJECT_NEW(Handle, OptResObj_New); PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Handle, OptResObj_Convert); m = Py_InitModule("_Res", Res_methods); d = PyModule_GetDict(m); Res_Error = PyMac_GetOSErrException(); if (Res_Error == NULL || PyDict_SetItemString(d, "Error", Res_Error) != 0) return; Resource_Type.ob_type = &PyType_Type; if (PyType_Ready(&Resource_Type) < 0) return; Py_INCREF(&Resource_Type); PyModule_AddObject(m, "Resource", (PyObject *)&Resource_Type); /* Backward-compatible name */ Py_INCREF(&Resource_Type); PyModule_AddObject(m, "ResourceType", (PyObject *)&Resource_Type); } /* ======================== End module _Res ========================= */