From 69ac361cb54c2134a13bd27b685ba8d01e3c9aa9 Mon Sep 17 00:00:00 2001 From: Jack Jansen Date: Tue, 1 Jan 2002 22:43:13 +0000 Subject: Added some support for unicode arguments. --- Mac/Modules/cf/_CFmodule.c | 69 ++++++++++++++++++++++++++ Mac/Modules/cf/cfscan.py | 9 ++-- Mac/Modules/cf/cfsupport.py | 2 - Mac/Modules/mlte/_Mltemodule.c | 27 +++++++++++ Mac/Modules/mlte/mltescan.py | 3 -- Mac/Modules/mlte/mltesupport.py | 2 + Mac/Modules/res/_Resmodule.c | 104 ++++++++++++++++++++++++++++++++++++++++ Mac/Modules/res/resscan.py | 7 ++- Mac/Modules/res/ressupport.py | 4 +- 9 files changed, 215 insertions(+), 12 deletions(-) diff --git a/Mac/Modules/cf/_CFmodule.c b/Mac/Modules/cf/_CFmodule.c index a748813..a47fe85 100644 --- a/Mac/Modules/cf/_CFmodule.c +++ b/Mac/Modules/cf/_CFmodule.c @@ -2046,6 +2046,26 @@ static PyObject *CFMutableStringRefObj_CFStringAppend(CFMutableStringRefObject * return _res; } +static PyObject *CFMutableStringRefObj_CFStringAppendCharacters(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + UniChar *chars__in__; + UniCharCount chars__len__; + int chars__in_len__; +#ifndef CFStringAppendCharacters + PyMac_PRECHECK(CFStringAppendCharacters); +#endif + if (!PyArg_ParseTuple(_args, "u#", + &chars__in__, &chars__in_len__)) + return NULL; + chars__len__ = chars__in_len__; + CFStringAppendCharacters(_self->ob_itself, + chars__in__, chars__len__); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + static PyObject *CFMutableStringRefObj_CFStringAppendPascalString(CFMutableStringRefObject *_self, PyObject *_args) { PyObject *_res = NULL; @@ -2217,6 +2237,8 @@ static PyObject *CFMutableStringRefObj_CFStringTrimWhitespace(CFMutableStringRef static PyMethodDef CFMutableStringRefObj_methods[] = { {"CFStringAppend", (PyCFunction)CFMutableStringRefObj_CFStringAppend, 1, "(CFStringRef appendedString) -> None"}, + {"CFStringAppendCharacters", (PyCFunction)CFMutableStringRefObj_CFStringAppendCharacters, 1, + "(Buffer chars) -> None"}, {"CFStringAppendPascalString", (PyCFunction)CFMutableStringRefObj_CFStringAppendPascalString, 1, "(Str255 pStr, CFStringEncoding encoding) -> None"}, {"CFStringAppendCString", (PyCFunction)CFMutableStringRefObj_CFStringAppendCString, 1, @@ -3221,6 +3243,27 @@ static PyObject *CF_CFStringCreateWithCString(PyObject *_self, PyObject *_args) return _res; } +static PyObject *CF_CFStringCreateWithCharacters(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + UniChar *chars__in__; + UniCharCount chars__len__; + int chars__in_len__; +#ifndef CFStringCreateWithCharacters + PyMac_PRECHECK(CFStringCreateWithCharacters); +#endif + if (!PyArg_ParseTuple(_args, "u#", + &chars__in__, &chars__in_len__)) + return NULL; + chars__len__ = chars__in_len__; + _rv = CFStringCreateWithCharacters((CFAllocatorRef)NULL, + chars__in__, chars__len__); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + static PyObject *CF_CFStringCreateWithPascalStringNoCopy(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; @@ -3265,6 +3308,28 @@ static PyObject *CF_CFStringCreateWithCStringNoCopy(PyObject *_self, PyObject *_ return _res; } +static PyObject *CF_CFStringCreateWithCharactersNoCopy(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + UniChar *chars__in__; + UniCharCount chars__len__; + int chars__in_len__; +#ifndef CFStringCreateWithCharactersNoCopy + PyMac_PRECHECK(CFStringCreateWithCharactersNoCopy); +#endif + if (!PyArg_ParseTuple(_args, "u#", + &chars__in__, &chars__in_len__)) + return NULL; + chars__len__ = chars__in_len__; + _rv = CFStringCreateWithCharactersNoCopy((CFAllocatorRef)NULL, + chars__in__, chars__len__, + (CFAllocatorRef)NULL); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + static PyObject *CF_CFStringCreateMutable(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; @@ -3667,10 +3732,14 @@ static PyMethodDef CF_methods[] = { "(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"}, {"CFStringCreateWithCString", (PyCFunction)CF_CFStringCreateWithCString, 1, "(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"}, + {"CFStringCreateWithCharacters", (PyCFunction)CF_CFStringCreateWithCharacters, 1, + "(Buffer chars) -> (CFStringRef _rv)"}, {"CFStringCreateWithPascalStringNoCopy", (PyCFunction)CF_CFStringCreateWithPascalStringNoCopy, 1, "(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"}, {"CFStringCreateWithCStringNoCopy", (PyCFunction)CF_CFStringCreateWithCStringNoCopy, 1, "(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"}, + {"CFStringCreateWithCharactersNoCopy", (PyCFunction)CF_CFStringCreateWithCharactersNoCopy, 1, + "(Buffer chars) -> (CFStringRef _rv)"}, {"CFStringCreateMutable", (PyCFunction)CF_CFStringCreateMutable, 1, "(CFIndex maxLength) -> (CFMutableStringRef _rv)"}, {"CFStringCreateMutableCopy", (PyCFunction)CF_CFStringCreateMutableCopy, 1, diff --git a/Mac/Modules/cf/cfscan.py b/Mac/Modules/cf/cfscan.py index b8ccb31..3e09df4 100644 --- a/Mac/Modules/cf/cfscan.py +++ b/Mac/Modules/cf/cfscan.py @@ -92,6 +92,9 @@ class MyScanner(Scanner_OSX): "CFStringGetCString", "CFStringGetCharacters", "CFURLCreateStringWithFileSystemPath", # Gone in later releases + "CFStringCreateMutableWithExternalCharactersNoCopy", # Not a clue... + "CFStringSetExternalCharactersNoCopy", + "CFStringGetCharacterAtIndex", # No format for single unichars yet. ] def makegreylist(self): @@ -105,9 +108,6 @@ class MyScanner(Scanner_OSX): "void_ptr", # Ditto for various array lookup methods "CFArrayApplierFunction", # Callback function pointer "CFDictionaryApplierFunction", # Callback function pointer - "UniChar_ptr", # XXXX To be done - "const_UniChar_ptr", # XXXX To be done - "UniChar", # XXXX To be done "va_list", # For printf-to-a-cfstring. Use Python. "const_CFStringEncoding_ptr", # To be done, I guess ] @@ -118,6 +118,9 @@ class MyScanner(Scanner_OSX): ([("UInt8_ptr", "*", "InMode"), ("CFIndex", "*", "InMode")], [("UcharInBuffer", "*", "*")]), + ([("UniChar_ptr", "*", "InMode"), ("CFIndex", "*", "InMode")], + [("UnicodeInBuffer", "*", "*")]), + # Some functions return a const char *. Don't worry, we won't modify it. ([("const_char_ptr", "*", "ReturnMode")], [("return_stringptr", "*", "*")]), diff --git a/Mac/Modules/cf/cfsupport.py b/Mac/Modules/cf/cfsupport.py index 0f95abe..fb275c3 100644 --- a/Mac/Modules/cf/cfsupport.py +++ b/Mac/Modules/cf/cfsupport.py @@ -171,8 +171,6 @@ CFOptionFlags = Type("CFOptionFlags", "l") CFStringEncoding = Type("CFStringEncoding", "l") CFComparisonResult = Type("CFComparisonResult", "l") # a bit dangerous, it's an enum CFURLPathStyle = Type("CFURLPathStyle", "l") # a bit dangerous, it's an enum -FSRef_ptr = OpaqueType("FSRef", "PyMac_BuildFSRef", "PyMac_GetFSRef") -FSRef = OpaqueByValueType("FSRef", "PyMac_BuildFSRef", "PyMac_GetFSRef") char_ptr = stringptr return_stringptr = Type("char *", "s") # ONLY FOR RETURN VALUES!! diff --git a/Mac/Modules/mlte/_Mltemodule.c b/Mac/Modules/mlte/_Mltemodule.c index 4acc4b5..c159e07 100644 --- a/Mac/Modules/mlte/_Mltemodule.c +++ b/Mac/Modules/mlte/_Mltemodule.c @@ -1006,6 +1006,31 @@ static PyObject *TXNObj_TXNActivate(TXNObjectObject *_self, PyObject *_args) return _res; } +static PyObject *TXNObj_TXNEchoMode(TXNObjectObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + UniChar iEchoCharacter; + TextEncoding iEncoding; + Boolean iOn; +#ifndef TXNEchoMode + PyMac_PRECHECK(TXNEchoMode); +#endif + if (!PyArg_ParseTuple(_args, "hlb", + &iEchoCharacter, + &iEncoding, + &iOn)) + return NULL; + _err = TXNEchoMode(_self->ob_itself, + iEchoCharacter, + iEncoding, + iOn); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + static PyObject *TXNObj_TXNDoFontMenuSelection(TXNObjectObject *_self, PyObject *_args) { PyObject *_res = NULL; @@ -1251,6 +1276,8 @@ static PyMethodDef TXNObj_methods[] = { "(TXNFrameID iTXNFrameID, WindowPtr iWindow, DragReference iDragReference, Boolean iDifferentObjectSameWindow) -> None"}, {"TXNActivate", (PyCFunction)TXNObj_TXNActivate, 1, "(TXNFrameID iTXNFrameID, TXNScrollBarState iActiveState) -> None"}, + {"TXNEchoMode", (PyCFunction)TXNObj_TXNEchoMode, 1, + "(UniChar iEchoCharacter, TextEncoding iEncoding, Boolean iOn) -> None"}, {"TXNDoFontMenuSelection", (PyCFunction)TXNObj_TXNDoFontMenuSelection, 1, "(TXNFontMenuObject iTXNFontMenuObject, SInt16 iMenuID, SInt16 iMenuItem) -> None"}, {"TXNPrepareFontMenu", (PyCFunction)TXNObj_TXNPrepareFontMenu, 1, diff --git a/Mac/Modules/mlte/mltescan.py b/Mac/Modules/mlte/mltescan.py index c4b3d47..80c966e 100644 --- a/Mac/Modules/mlte/mltescan.py +++ b/Mac/Modules/mlte/mltescan.py @@ -93,9 +93,6 @@ MovieFileType = FOUR_CHAR_CODE('moov') "TXNTypeAttributes", #TBD "TXNMatchTextRecord", #TBD "TXNBackground", #TBD - "UniChar", #TBD - "UniCharCount", #TBD - "UniChar_ptr", #TBD "TXNFindUPP", "ATSUStyle", #TBD "TXNActionKeyMapperProcPtr", diff --git a/Mac/Modules/mlte/mltesupport.py b/Mac/Modules/mlte/mltesupport.py index 3ce2463..e2f5767 100644 --- a/Mac/Modules/mlte/mltesupport.py +++ b/Mac/Modules/mlte/mltesupport.py @@ -129,6 +129,8 @@ CFStringRef = OpaqueByValueType("CFStringRef", "CFStringRefObj") OptFSSpecPtr = OpaqueByValueType("FSSpec *", "OptFSSpecPtr") OptRectPtr = OpaqueByValueType("Rect *", "OptRectPtr") + +UniChar = Type("UniChar", "h") # XXXX For now... # ADD object type here execfile("mltetypetest.py") diff --git a/Mac/Modules/res/_Resmodule.c b/Mac/Modules/res/_Resmodule.c index 0c4576b..195d14b 100644 --- a/Mac/Modules/res/_Resmodule.c +++ b/Mac/Modules/res/_Resmodule.c @@ -1382,6 +1382,36 @@ static PyObject *Res_FSOpenResFile(PyObject *_self, PyObject *_args) 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; + 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; @@ -1406,6 +1436,74 @@ static PyObject *Res_FSResourceFileAlreadyOpen(PyObject *_self, PyObject *_args) return _res; } +static PyObject *Res_FSCreateResourceFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _rv; + 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; + 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__; + _rv = FSCreateResourceFile(&parentRef, + nameLength__len__, nameLength__in__, + 0, + (FSCatalogInfo *)0, + forkNameLength__len__, forkNameLength__in__, + &newRef, + &newSpec); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("hO&O&", + _rv, + PyMac_BuildFSRef, newRef, + PyMac_BuildFSSpec, newSpec); + return _res; +} + +static PyObject *Res_FSOpenResourceFile(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _rv; + FSRef ref; + UniChar *forkNameLength__in__; + UniCharCount forkNameLength__len__; + int forkNameLength__in_len__; + SignedByte permissions; + SInt16 refNum; + if (!PyArg_ParseTuple(_args, "O&u#b", + PyMac_GetFSRef, &ref, + &forkNameLength__in__, &forkNameLength__in_len__, + &permissions)) + return NULL; + forkNameLength__len__ = forkNameLength__in_len__; + _rv = FSOpenResourceFile(&ref, + forkNameLength__len__, forkNameLength__in__, + permissions, + &refNum); + { + OSErr _err = ResError(); + if (_err != noErr) return PyMac_Error(_err); + } + _res = Py_BuildValue("hh", + _rv, + refNum); + return _res; +} + static PyObject *Res_Resource(PyObject *_self, PyObject *_args) { PyObject *_res = NULL; @@ -1569,8 +1667,14 @@ static PyMethodDef Res_methods[] = { #endif {"FSOpenResFile", (PyCFunction)Res_FSOpenResFile, 1, "(FSRef ref, SignedByte permission) -> (short _rv)"}, + {"FSCreateResFile", (PyCFunction)Res_FSCreateResFile, 1, + "(FSRef parentRef, Buffer nameLength) -> (FSRef newRef, FSSpec newSpec)"}, {"FSResourceFileAlreadyOpen", (PyCFunction)Res_FSResourceFileAlreadyOpen, 1, "(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"}, + {"FSCreateResourceFile", (PyCFunction)Res_FSCreateResourceFile, 1, + "(FSRef parentRef, Buffer nameLength, Buffer forkNameLength) -> (OSErr _rv, FSRef newRef, FSSpec newSpec)"}, + {"FSOpenResourceFile", (PyCFunction)Res_FSOpenResourceFile, 1, + "(FSRef ref, Buffer forkNameLength, SignedByte permissions) -> (OSErr _rv, SInt16 refNum)"}, {"Resource", (PyCFunction)Res_Resource, 1, "Convert a string to a resource object.\n\nThe created resource object is actually just a handle,\napply AddResource() to write it to a resource file.\nSee also the Handle() docstring.\n"}, {"Handle", (PyCFunction)Res_Handle, 1, diff --git a/Mac/Modules/res/resscan.py b/Mac/Modules/res/resscan.py index ecdd86b..dcdb07b 100644 --- a/Mac/Modules/res/resscan.py +++ b/Mac/Modules/res/resscan.py @@ -48,7 +48,6 @@ class ResourcesScanner(Scanner): def makeblacklisttypes(self): return [ - "UniCharCount", #TBD ] def makegreylist(self): @@ -86,7 +85,11 @@ class ResourcesScanner(Scanner): [("OutBuffer", "*", "InOutMode")]), ([("SInt8", "*", "*")], - [("SignedByte", "*", "*")]) + [("SignedByte", "*", "*")]), + + + ([("UniCharCount", "*", "InMode"), ("UniChar_ptr", "*", "InMode")], + [("UnicodeReverseInBuffer", "*", "*")]), ] if __name__ == "__main__": diff --git a/Mac/Modules/res/ressupport.py b/Mac/Modules/res/ressupport.py index 056e214..6fedcf3 100644 --- a/Mac/Modules/res/ressupport.py +++ b/Mac/Modules/res/ressupport.py @@ -5,8 +5,6 @@ from macsupport import * -FSRef_ptr = OpaqueType("FSRef", "PyMac_BuildFSRef", "PyMac_GetFSRef") - class ResMixIn: def checkit(self): @@ -20,6 +18,8 @@ class ResFunction(ResMixIn, FunctionGenerator): pass class ResMethod(ResMixIn, MethodGenerator): pass RsrcChainLocation = Type("RsrcChainLocation", "h") +FSCatalogInfoBitmap = FakeType("0") # Type("FSCatalogInfoBitmap", "l") +FSCatalogInfo_ptr = FakeType("(FSCatalogInfo *)0") # includestuff etc. are imported from macsupport -- cgit v0.12