Regenerated with PyDoc_STR() around docstrings.

Mac/Modules/ae/_AEmodule.c

@@ -759,64 +759,64 @@ static PyObject *AEDesc_AEResolve(AEDescObject *_self, PyObject *_args)
 
 static PyMethodDef AEDesc_methods[] = {
 	{"AECoerceDesc", (PyCFunction)AEDesc_AECoerceDesc, 1,
-	 "(DescType toType) -> (AEDesc result)"},
+	 PyDoc_STR("(DescType toType) -> (AEDesc result)")},
 	{"AEDuplicateDesc", (PyCFunction)AEDesc_AEDuplicateDesc, 1,
-	 "() -> (AEDesc result)"},
+	 PyDoc_STR("() -> (AEDesc result)")},
 	{"AECountItems", (PyCFunction)AEDesc_AECountItems, 1,
-	 "() -> (long theCount)"},
+	 PyDoc_STR("() -> (long theCount)")},
 	{"AEPutPtr", (PyCFunction)AEDesc_AEPutPtr, 1,
-	 "(long index, DescType typeCode, Buffer dataPtr) -> None"},
+	 PyDoc_STR("(long index, DescType typeCode, Buffer dataPtr) -> None")},
 	{"AEPutDesc", (PyCFunction)AEDesc_AEPutDesc, 1,
-	 "(long index, AEDesc theAEDesc) -> None"},
+	 PyDoc_STR("(long index, AEDesc theAEDesc) -> None")},
 	{"AEGetNthPtr", (PyCFunction)AEDesc_AEGetNthPtr, 1,
-	 "(long index, DescType desiredType, Buffer dataPtr) -> (AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr)"},
+	 PyDoc_STR("(long index, DescType desiredType, Buffer dataPtr) -> (AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr)")},
 	{"AEGetNthDesc", (PyCFunction)AEDesc_AEGetNthDesc, 1,
-	 "(long index, DescType desiredType) -> (AEKeyword theAEKeyword, AEDesc result)"},
+	 PyDoc_STR("(long index, DescType desiredType) -> (AEKeyword theAEKeyword, AEDesc result)")},
 	{"AESizeOfNthItem", (PyCFunction)AEDesc_AESizeOfNthItem, 1,
-	 "(long index) -> (DescType typeCode, Size dataSize)"},
+	 PyDoc_STR("(long index) -> (DescType typeCode, Size dataSize)")},
 	{"AEDeleteItem", (PyCFunction)AEDesc_AEDeleteItem, 1,
-	 "(long index) -> None"},
+	 PyDoc_STR("(long index) -> None")},
 	{"AEPutParamPtr", (PyCFunction)AEDesc_AEPutParamPtr, 1,
-	 "(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"},
+	 PyDoc_STR("(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None")},
 	{"AEPutParamDesc", (PyCFunction)AEDesc_AEPutParamDesc, 1,
-	 "(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"},
+	 PyDoc_STR("(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None")},
 	{"AEGetParamPtr", (PyCFunction)AEDesc_AEGetParamPtr, 1,
-	 "(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)"},
+	 PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)")},
 	{"AEGetParamDesc", (PyCFunction)AEDesc_AEGetParamDesc, 1,
-	 "(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)"},
+	 PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)")},
 	{"AESizeOfParam", (PyCFunction)AEDesc_AESizeOfParam, 1,
-	 "(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)"},
+	 PyDoc_STR("(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)")},
 	{"AEDeleteParam", (PyCFunction)AEDesc_AEDeleteParam, 1,
-	 "(AEKeyword theAEKeyword) -> None"},
+	 PyDoc_STR("(AEKeyword theAEKeyword) -> None")},
 	{"AEGetAttributePtr", (PyCFunction)AEDesc_AEGetAttributePtr, 1,
-	 "(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)"},
+	 PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)")},
 	{"AEGetAttributeDesc", (PyCFunction)AEDesc_AEGetAttributeDesc, 1,
-	 "(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)"},
+	 PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)")},
 	{"AESizeOfAttribute", (PyCFunction)AEDesc_AESizeOfAttribute, 1,
-	 "(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)"},
+	 PyDoc_STR("(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)")},
 	{"AEPutAttributePtr", (PyCFunction)AEDesc_AEPutAttributePtr, 1,
-	 "(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"},
+	 PyDoc_STR("(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None")},
 	{"AEPutAttributeDesc", (PyCFunction)AEDesc_AEPutAttributeDesc, 1,
-	 "(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"},
+	 PyDoc_STR("(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"AEGetDescDataSize", (PyCFunction)AEDesc_AEGetDescDataSize, 1,
-	 "() -> (Size _rv)"},
+	 PyDoc_STR("() -> (Size _rv)")},
 #endif
 	{"AESend", (PyCFunction)AEDesc_AESend, 1,
-	 "(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)"},
+	 PyDoc_STR("(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)")},
 	{"AEResetTimer", (PyCFunction)AEDesc_AEResetTimer, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"AESuspendTheCurrentEvent", (PyCFunction)AEDesc_AESuspendTheCurrentEvent, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"AEResumeTheCurrentEvent", (PyCFunction)AEDesc_AEResumeTheCurrentEvent, 1,
-	 "(AppleEvent reply, EventHandler dispatcher) -> None"},
+	 PyDoc_STR("(AppleEvent reply, EventHandler dispatcher) -> None")},
 	{"AEGetTheCurrentEvent", (PyCFunction)AEDesc_AEGetTheCurrentEvent, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"AESetTheCurrentEvent", (PyCFunction)AEDesc_AESetTheCurrentEvent, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"AEResolve", (PyCFunction)AEDesc_AEResolve, 1,
-	 "(short callbackFlags) -> (AEDesc theToken)"},
+	 PyDoc_STR("(short callbackFlags) -> (AEDesc theToken)")},
 	{NULL, NULL, 0}
 };
 
@@ -1307,44 +1307,44 @@ static PyObject *AE_AECallObjectAccessor(PyObject *_self, PyObject *_args)
 
 static PyMethodDef AE_methods[] = {
 	{"AECoercePtr", (PyCFunction)AE_AECoercePtr, 1,
-	 "(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)"},
+	 PyDoc_STR("(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)")},
 	{"AECreateDesc", (PyCFunction)AE_AECreateDesc, 1,
-	 "(DescType typeCode, Buffer dataPtr) -> (AEDesc result)"},
+	 PyDoc_STR("(DescType typeCode, Buffer dataPtr) -> (AEDesc result)")},
 	{"AECreateList", (PyCFunction)AE_AECreateList, 1,
-	 "(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)"},
+	 PyDoc_STR("(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)")},
 	{"AECreateAppleEvent", (PyCFunction)AE_AECreateAppleEvent, 1,
-	 "(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)"},
+	 PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)")},
 
 #if TARGET_API_MAC_CARBON
 	{"AEReplaceDescData", (PyCFunction)AE_AEReplaceDescData, 1,
-	 "(DescType typeCode, Buffer dataPtr) -> (AEDesc theAEDesc)"},
+	 PyDoc_STR("(DescType typeCode, Buffer dataPtr) -> (AEDesc theAEDesc)")},
 #endif
 	{"AEProcessAppleEvent", (PyCFunction)AE_AEProcessAppleEvent, 1,
-	 "(EventRecord theEventRecord) -> None"},
+	 PyDoc_STR("(EventRecord theEventRecord) -> None")},
 	{"AEGetInteractionAllowed", (PyCFunction)AE_AEGetInteractionAllowed, 1,
-	 "() -> (AEInteractAllowed level)"},
+	 PyDoc_STR("() -> (AEInteractAllowed level)")},
 	{"AESetInteractionAllowed", (PyCFunction)AE_AESetInteractionAllowed, 1,
-	 "(AEInteractAllowed level) -> None"},
+	 PyDoc_STR("(AEInteractAllowed level) -> None")},
 	{"AEInteractWithUser", (PyCFunction)AE_AEInteractWithUser, 1,
-	 "(long timeOutInTicks) -> None"},
+	 PyDoc_STR("(long timeOutInTicks) -> None")},
 	{"AEInstallEventHandler", (PyCFunction)AE_AEInstallEventHandler, 1,
-	 "(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None"},
+	 PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None")},
 	{"AERemoveEventHandler", (PyCFunction)AE_AERemoveEventHandler, 1,
-	 "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None"},
+	 PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None")},
 	{"AEGetEventHandler", (PyCFunction)AE_AEGetEventHandler, 1,
-	 "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)"},
+	 PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)")},
 	{"AEInstallSpecialHandler", (PyCFunction)AE_AEInstallSpecialHandler, 1,
-	 "(AEKeyword functionClass) -> None"},
+	 PyDoc_STR("(AEKeyword functionClass) -> None")},
 	{"AERemoveSpecialHandler", (PyCFunction)AE_AERemoveSpecialHandler, 1,
-	 "(AEKeyword functionClass) -> None"},
+	 PyDoc_STR("(AEKeyword functionClass) -> None")},
 	{"AEManagerInfo", (PyCFunction)AE_AEManagerInfo, 1,
-	 "(AEKeyword keyWord) -> (long result)"},
+	 PyDoc_STR("(AEKeyword keyWord) -> (long result)")},
 	{"AEObjectInit", (PyCFunction)AE_AEObjectInit, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"AEDisposeToken", (PyCFunction)AE_AEDisposeToken, 1,
-	 "() -> (AEDesc theToken)"},
+	 PyDoc_STR("() -> (AEDesc theToken)")},
 	{"AECallObjectAccessor", (PyCFunction)AE_AECallObjectAccessor, 1,
-	 "(DescType desiredClass, AEDesc containerToken, DescType containerClass, DescType keyForm, AEDesc keyData) -> (AEDesc token)"},
+	 PyDoc_STR("(DescType desiredClass, AEDesc containerToken, DescType containerClass, DescType keyForm, AEDesc keyData) -> (AEDesc token)")},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/cg/_CGmodule.c

@@ -1148,121 +1148,121 @@ static PyObject *CGContextRefObj_ClipCGContextToRegion(CGContextRefObject *_self
 
 static PyMethodDef CGContextRefObj_methods[] = {
 	{"CGContextSaveGState", (PyCFunction)CGContextRefObj_CGContextSaveGState, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextRestoreGState", (PyCFunction)CGContextRefObj_CGContextRestoreGState, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextScaleCTM", (PyCFunction)CGContextRefObj_CGContextScaleCTM, 1,
-	 "(float sx, float sy) -> None"},
+	 PyDoc_STR("(float sx, float sy) -> None")},
 	{"CGContextTranslateCTM", (PyCFunction)CGContextRefObj_CGContextTranslateCTM, 1,
-	 "(float tx, float ty) -> None"},
+	 PyDoc_STR("(float tx, float ty) -> None")},
 	{"CGContextRotateCTM", (PyCFunction)CGContextRefObj_CGContextRotateCTM, 1,
-	 "(float angle) -> None"},
+	 PyDoc_STR("(float angle) -> None")},
 	{"CGContextConcatCTM", (PyCFunction)CGContextRefObj_CGContextConcatCTM, 1,
-	 "(CGAffineTransform transform) -> None"},
+	 PyDoc_STR("(CGAffineTransform transform) -> None")},
 	{"CGContextGetCTM", (PyCFunction)CGContextRefObj_CGContextGetCTM, 1,
-	 "() -> (CGAffineTransform _rv)"},
+	 PyDoc_STR("() -> (CGAffineTransform _rv)")},
 	{"CGContextSetLineWidth", (PyCFunction)CGContextRefObj_CGContextSetLineWidth, 1,
-	 "(float width) -> None"},
+	 PyDoc_STR("(float width) -> None")},
 	{"CGContextSetLineCap", (PyCFunction)CGContextRefObj_CGContextSetLineCap, 1,
-	 "(int cap) -> None"},
+	 PyDoc_STR("(int cap) -> None")},
 	{"CGContextSetLineJoin", (PyCFunction)CGContextRefObj_CGContextSetLineJoin, 1,
-	 "(int join) -> None"},
+	 PyDoc_STR("(int join) -> None")},
 	{"CGContextSetMiterLimit", (PyCFunction)CGContextRefObj_CGContextSetMiterLimit, 1,
-	 "(float limit) -> None"},
+	 PyDoc_STR("(float limit) -> None")},
 	{"CGContextSetFlatness", (PyCFunction)CGContextRefObj_CGContextSetFlatness, 1,
-	 "(float flatness) -> None"},
+	 PyDoc_STR("(float flatness) -> None")},
 	{"CGContextSetAlpha", (PyCFunction)CGContextRefObj_CGContextSetAlpha, 1,
-	 "(float alpha) -> None"},
+	 PyDoc_STR("(float alpha) -> None")},
 	{"CGContextBeginPath", (PyCFunction)CGContextRefObj_CGContextBeginPath, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextMoveToPoint", (PyCFunction)CGContextRefObj_CGContextMoveToPoint, 1,
-	 "(float x, float y) -> None"},
+	 PyDoc_STR("(float x, float y) -> None")},
 	{"CGContextAddLineToPoint", (PyCFunction)CGContextRefObj_CGContextAddLineToPoint, 1,
-	 "(float x, float y) -> None"},
+	 PyDoc_STR("(float x, float y) -> None")},
 	{"CGContextAddCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddCurveToPoint, 1,
-	 "(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y) -> None"},
+	 PyDoc_STR("(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y) -> None")},
 	{"CGContextAddQuadCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddQuadCurveToPoint, 1,
-	 "(float cpx, float cpy, float x, float y) -> None"},
+	 PyDoc_STR("(float cpx, float cpy, float x, float y) -> None")},
 	{"CGContextClosePath", (PyCFunction)CGContextRefObj_CGContextClosePath, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextAddRect", (PyCFunction)CGContextRefObj_CGContextAddRect, 1,
-	 "(CGRect rect) -> None"},
+	 PyDoc_STR("(CGRect rect) -> None")},
 	{"CGContextAddArc", (PyCFunction)CGContextRefObj_CGContextAddArc, 1,
-	 "(float x, float y, float radius, float startAngle, float endAngle, int clockwise) -> None"},
+	 PyDoc_STR("(float x, float y, float radius, float startAngle, float endAngle, int clockwise) -> None")},
 	{"CGContextAddArcToPoint", (PyCFunction)CGContextRefObj_CGContextAddArcToPoint, 1,
-	 "(float x1, float y1, float x2, float y2, float radius) -> None"},
+	 PyDoc_STR("(float x1, float y1, float x2, float y2, float radius) -> None")},
 	{"CGContextIsPathEmpty", (PyCFunction)CGContextRefObj_CGContextIsPathEmpty, 1,
-	 "() -> (int _rv)"},
+	 PyDoc_STR("() -> (int _rv)")},
 	{"CGContextGetPathCurrentPoint", (PyCFunction)CGContextRefObj_CGContextGetPathCurrentPoint, 1,
-	 "() -> (CGPoint _rv)"},
+	 PyDoc_STR("() -> (CGPoint _rv)")},
 	{"CGContextGetPathBoundingBox", (PyCFunction)CGContextRefObj_CGContextGetPathBoundingBox, 1,
-	 "() -> (CGRect _rv)"},
+	 PyDoc_STR("() -> (CGRect _rv)")},
 	{"CGContextDrawPath", (PyCFunction)CGContextRefObj_CGContextDrawPath, 1,
-	 "(int mode) -> None"},
+	 PyDoc_STR("(int mode) -> None")},
 	{"CGContextFillPath", (PyCFunction)CGContextRefObj_CGContextFillPath, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextEOFillPath", (PyCFunction)CGContextRefObj_CGContextEOFillPath, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextStrokePath", (PyCFunction)CGContextRefObj_CGContextStrokePath, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextFillRect", (PyCFunction)CGContextRefObj_CGContextFillRect, 1,
-	 "(CGRect rect) -> None"},
+	 PyDoc_STR("(CGRect rect) -> None")},
 	{"CGContextStrokeRect", (PyCFunction)CGContextRefObj_CGContextStrokeRect, 1,
-	 "(CGRect rect) -> None"},
+	 PyDoc_STR("(CGRect rect) -> None")},
 	{"CGContextStrokeRectWithWidth", (PyCFunction)CGContextRefObj_CGContextStrokeRectWithWidth, 1,
-	 "(CGRect rect, float width) -> None"},
+	 PyDoc_STR("(CGRect rect, float width) -> None")},
 	{"CGContextClearRect", (PyCFunction)CGContextRefObj_CGContextClearRect, 1,
-	 "(CGRect rect) -> None"},
+	 PyDoc_STR("(CGRect rect) -> None")},
 	{"CGContextClip", (PyCFunction)CGContextRefObj_CGContextClip, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextEOClip", (PyCFunction)CGContextRefObj_CGContextEOClip, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextClipToRect", (PyCFunction)CGContextRefObj_CGContextClipToRect, 1,
-	 "(CGRect rect) -> None"},
+	 PyDoc_STR("(CGRect rect) -> None")},
 	{"CGContextSetGrayFillColor", (PyCFunction)CGContextRefObj_CGContextSetGrayFillColor, 1,
-	 "(float gray, float alpha) -> None"},
+	 PyDoc_STR("(float gray, float alpha) -> None")},
 	{"CGContextSetGrayStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetGrayStrokeColor, 1,
-	 "(float gray, float alpha) -> None"},
+	 PyDoc_STR("(float gray, float alpha) -> None")},
 	{"CGContextSetRGBFillColor", (PyCFunction)CGContextRefObj_CGContextSetRGBFillColor, 1,
-	 "(float r, float g, float b, float alpha) -> None"},
+	 PyDoc_STR("(float r, float g, float b, float alpha) -> None")},
 	{"CGContextSetRGBStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetRGBStrokeColor, 1,
-	 "(float r, float g, float b, float alpha) -> None"},
+	 PyDoc_STR("(float r, float g, float b, float alpha) -> None")},
 	{"CGContextSetCMYKFillColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKFillColor, 1,
-	 "(float c, float m, float y, float k, float alpha) -> None"},
+	 PyDoc_STR("(float c, float m, float y, float k, float alpha) -> None")},
 	{"CGContextSetCMYKStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKStrokeColor, 1,
-	 "(float c, float m, float y, float k, float alpha) -> None"},
+	 PyDoc_STR("(float c, float m, float y, float k, float alpha) -> None")},
 	{"CGContextSetCharacterSpacing", (PyCFunction)CGContextRefObj_CGContextSetCharacterSpacing, 1,
-	 "(float spacing) -> None"},
+	 PyDoc_STR("(float spacing) -> None")},
 	{"CGContextSetTextPosition", (PyCFunction)CGContextRefObj_CGContextSetTextPosition, 1,
-	 "(float x, float y) -> None"},
+	 PyDoc_STR("(float x, float y) -> None")},
 	{"CGContextGetTextPosition", (PyCFunction)CGContextRefObj_CGContextGetTextPosition, 1,
-	 "() -> (CGPoint _rv)"},
+	 PyDoc_STR("() -> (CGPoint _rv)")},
 	{"CGContextSetTextMatrix", (PyCFunction)CGContextRefObj_CGContextSetTextMatrix, 1,
-	 "(CGAffineTransform transform) -> None"},
+	 PyDoc_STR("(CGAffineTransform transform) -> None")},
 	{"CGContextGetTextMatrix", (PyCFunction)CGContextRefObj_CGContextGetTextMatrix, 1,
-	 "() -> (CGAffineTransform _rv)"},
+	 PyDoc_STR("() -> (CGAffineTransform _rv)")},
 	{"CGContextSetTextDrawingMode", (PyCFunction)CGContextRefObj_CGContextSetTextDrawingMode, 1,
-	 "(int mode) -> None"},
+	 PyDoc_STR("(int mode) -> None")},
 	{"CGContextSetFontSize", (PyCFunction)CGContextRefObj_CGContextSetFontSize, 1,
-	 "(float size) -> None"},
+	 PyDoc_STR("(float size) -> None")},
 	{"CGContextSelectFont", (PyCFunction)CGContextRefObj_CGContextSelectFont, 1,
-	 "(char * name, float size, int textEncoding) -> None"},
+	 PyDoc_STR("(char * name, float size, int textEncoding) -> None")},
 	{"CGContextShowText", (PyCFunction)CGContextRefObj_CGContextShowText, 1,
-	 "(Buffer cstring) -> None"},
+	 PyDoc_STR("(Buffer cstring) -> None")},
 	{"CGContextShowTextAtPoint", (PyCFunction)CGContextRefObj_CGContextShowTextAtPoint, 1,
-	 "(float x, float y, Buffer cstring) -> None"},
+	 PyDoc_STR("(float x, float y, Buffer cstring) -> None")},
 	{"CGContextEndPage", (PyCFunction)CGContextRefObj_CGContextEndPage, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextFlush", (PyCFunction)CGContextRefObj_CGContextFlush, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextSynchronize", (PyCFunction)CGContextRefObj_CGContextSynchronize, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CGContextSetShouldAntialias", (PyCFunction)CGContextRefObj_CGContextSetShouldAntialias, 1,
-	 "(int shouldAntialias) -> None"},
+	 PyDoc_STR("(int shouldAntialias) -> None")},
 	{"SyncCGContextOriginWithPort", (PyCFunction)CGContextRefObj_SyncCGContextOriginWithPort, 1,
-	 "(CGrafPtr port) -> None"},
+	 PyDoc_STR("(CGrafPtr port) -> None")},
 	{"ClipCGContextToRegion", (PyCFunction)CGContextRefObj_ClipCGContextToRegion, 1,
-	 "(Rect portRect, RgnHandle region) -> None"},
+	 PyDoc_STR("(Rect portRect, RgnHandle region) -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -1323,7 +1323,7 @@ static PyObject *CG_CreateCGContextForPort(PyObject *_self, PyObject *_args)
 
 static PyMethodDef CG_methods[] = {
 	{"CreateCGContextForPort", (PyCFunction)CG_CreateCGContextForPort, 1,
-	 "(CGrafPtr) -> CGContextRef"},
+	 PyDoc_STR("(CGrafPtr) -> CGContextRef")},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/cm/_Cmmodule.c

@@ -277,31 +277,31 @@ static PyObject *CmpInstObj_ComponentSetTarget(ComponentInstanceObject *_self, P
 
 static PyMethodDef CmpInstObj_methods[] = {
 	{"CloseComponent", (PyCFunction)CmpInstObj_CloseComponent, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetComponentInstanceError", (PyCFunction)CmpInstObj_GetComponentInstanceError, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetComponentInstanceError", (PyCFunction)CmpInstObj_SetComponentInstanceError, 1,
-	 "(OSErr theError) -> None"},
+	 PyDoc_STR("(OSErr theError) -> None")},
 	{"GetComponentInstanceStorage", (PyCFunction)CmpInstObj_GetComponentInstanceStorage, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"SetComponentInstanceStorage", (PyCFunction)CmpInstObj_SetComponentInstanceStorage, 1,
-	 "(Handle theStorage) -> None"},
+	 PyDoc_STR("(Handle theStorage) -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"GetComponentInstanceA5", (PyCFunction)CmpInstObj_GetComponentInstanceA5, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"SetComponentInstanceA5", (PyCFunction)CmpInstObj_SetComponentInstanceA5, 1,
-	 "(long theA5) -> None"},
+	 PyDoc_STR("(long theA5) -> None")},
 #endif
 	{"ComponentFunctionImplemented", (PyCFunction)CmpInstObj_ComponentFunctionImplemented, 1,
-	 "(short ftnNumber) -> (long _rv)"},
+	 PyDoc_STR("(short ftnNumber) -> (long _rv)")},
 	{"GetComponentVersion", (PyCFunction)CmpInstObj_GetComponentVersion, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"ComponentSetTarget", (PyCFunction)CmpInstObj_ComponentSetTarget, 1,
-	 "(ComponentInstance target) -> (long _rv)"},
+	 PyDoc_STR("(ComponentInstance target) -> (long _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -669,35 +669,35 @@ static PyObject *CmpObj_GetComponentIconSuite(ComponentObject *_self, PyObject *
 
 static PyMethodDef CmpObj_methods[] = {
 	{"UnregisterComponent", (PyCFunction)CmpObj_UnregisterComponent, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetComponentInfo", (PyCFunction)CmpObj_GetComponentInfo, 1,
-	 "(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)"},
+	 PyDoc_STR("(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)")},
 	{"OpenComponent", (PyCFunction)CmpObj_OpenComponent, 1,
-	 "() -> (ComponentInstance _rv)"},
+	 PyDoc_STR("() -> (ComponentInstance _rv)")},
 	{"ResolveComponentAlias", (PyCFunction)CmpObj_ResolveComponentAlias, 1,
-	 "() -> (Component _rv)"},
+	 PyDoc_STR("() -> (Component _rv)")},
 	{"GetComponentPublicIndString", (PyCFunction)CmpObj_GetComponentPublicIndString, 1,
-	 "(Str255 theString, short strListID, short index) -> None"},
+	 PyDoc_STR("(Str255 theString, short strListID, short index) -> None")},
 	{"GetComponentRefcon", (PyCFunction)CmpObj_GetComponentRefcon, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"SetComponentRefcon", (PyCFunction)CmpObj_SetComponentRefcon, 1,
-	 "(long theRefcon) -> None"},
+	 PyDoc_STR("(long theRefcon) -> None")},
 	{"OpenComponentResFile", (PyCFunction)CmpObj_OpenComponentResFile, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"GetComponentResource", (PyCFunction)CmpObj_GetComponentResource, 1,
-	 "(OSType resType, short resID) -> (Handle theResource)"},
+	 PyDoc_STR("(OSType resType, short resID) -> (Handle theResource)")},
 	{"GetComponentIndString", (PyCFunction)CmpObj_GetComponentIndString, 1,
-	 "(Str255 theString, short strListID, short index) -> None"},
+	 PyDoc_STR("(Str255 theString, short strListID, short index) -> None")},
 	{"CountComponentInstances", (PyCFunction)CmpObj_CountComponentInstances, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"SetDefaultComponent", (PyCFunction)CmpObj_SetDefaultComponent, 1,
-	 "(short flags) -> None"},
+	 PyDoc_STR("(short flags) -> None")},
 	{"CaptureComponent", (PyCFunction)CmpObj_CaptureComponent, 1,
-	 "(Component capturingComponent) -> (Component _rv)"},
+	 PyDoc_STR("(Component capturingComponent) -> (Component _rv)")},
 	{"UncaptureComponent", (PyCFunction)CmpObj_UncaptureComponent, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetComponentIconSuite", (PyCFunction)CmpObj_GetComponentIconSuite, 1,
-	 "() -> (Handle iconSuite)"},
+	 PyDoc_STR("() -> (Handle iconSuite)")},
 	{NULL, NULL, 0}
 };
 
@@ -870,19 +870,19 @@ static PyObject *Cm_RegisterComponentResourceFile(PyObject *_self, PyObject *_ar
 
 static PyMethodDef Cm_methods[] = {
 	{"RegisterComponentResource", (PyCFunction)Cm_RegisterComponentResource, 1,
-	 "(ComponentResourceHandle cr, short global) -> (Component _rv)"},
+	 PyDoc_STR("(ComponentResourceHandle cr, short global) -> (Component _rv)")},
 	{"FindNextComponent", (PyCFunction)Cm_FindNextComponent, 1,
-	 "(Component aComponent, ComponentDescription looking) -> (Component _rv)"},
+	 PyDoc_STR("(Component aComponent, ComponentDescription looking) -> (Component _rv)")},
 	{"CountComponents", (PyCFunction)Cm_CountComponents, 1,
-	 "(ComponentDescription looking) -> (long _rv)"},
+	 PyDoc_STR("(ComponentDescription looking) -> (long _rv)")},
 	{"GetComponentListModSeed", (PyCFunction)Cm_GetComponentListModSeed, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"CloseComponentResFile", (PyCFunction)Cm_CloseComponentResFile, 1,
-	 "(short refnum) -> None"},
+	 PyDoc_STR("(short refnum) -> None")},
 	{"OpenDefaultComponent", (PyCFunction)Cm_OpenDefaultComponent, 1,
-	 "(OSType componentType, OSType componentSubType) -> (ComponentInstance _rv)"},
+	 PyDoc_STR("(OSType componentType, OSType componentSubType) -> (ComponentInstance _rv)")},
 	{"RegisterComponentResourceFile", (PyCFunction)Cm_RegisterComponentResourceFile, 1,
-	 "(short resRefNum, short global) -> (long _rv)"},
+	 PyDoc_STR("(short resRefNum, short global) -> (long _rv)")},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/drag/_Dragmodule.c

@@ -684,59 +684,59 @@ static PyObject *DragObj_UpdateDragHilite(DragObjObject *_self, PyObject *_args)
 
 static PyMethodDef DragObj_methods[] = {
 	{"DisposeDrag", (PyCFunction)DragObj_DisposeDrag, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"AddDragItemFlavor", (PyCFunction)DragObj_AddDragItemFlavor, 1,
-	 "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, FlavorFlags theFlags) -> None"},
+	 PyDoc_STR("(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, FlavorFlags theFlags) -> None")},
 	{"SetDragItemFlavorData", (PyCFunction)DragObj_SetDragItemFlavorData, 1,
-	 "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> None"},
+	 PyDoc_STR("(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> None")},
 	{"SetDragImage", (PyCFunction)DragObj_SetDragImage, 1,
-	 "(PixMapHandle imagePixMap, RgnHandle imageRgn, Point imageOffsetPt, DragImageFlags theImageFlags) -> None"},
+	 PyDoc_STR("(PixMapHandle imagePixMap, RgnHandle imageRgn, Point imageOffsetPt, DragImageFlags theImageFlags) -> None")},
 	{"ChangeDragBehaviors", (PyCFunction)DragObj_ChangeDragBehaviors, 1,
-	 "(DragBehaviors inBehaviorsToSet, DragBehaviors inBehaviorsToClear) -> None"},
+	 PyDoc_STR("(DragBehaviors inBehaviorsToSet, DragBehaviors inBehaviorsToClear) -> None")},
 	{"TrackDrag", (PyCFunction)DragObj_TrackDrag, 1,
-	 "(EventRecord theEvent, RgnHandle theRegion) -> None"},
+	 PyDoc_STR("(EventRecord theEvent, RgnHandle theRegion) -> None")},
 	{"CountDragItems", (PyCFunction)DragObj_CountDragItems, 1,
-	 "() -> (UInt16 numItems)"},
+	 PyDoc_STR("() -> (UInt16 numItems)")},
 	{"GetDragItemReferenceNumber", (PyCFunction)DragObj_GetDragItemReferenceNumber, 1,
-	 "(UInt16 index) -> (ItemReference theItemRef)"},
+	 PyDoc_STR("(UInt16 index) -> (ItemReference theItemRef)")},
 	{"CountDragItemFlavors", (PyCFunction)DragObj_CountDragItemFlavors, 1,
-	 "(ItemReference theItemRef) -> (UInt16 numFlavors)"},
+	 PyDoc_STR("(ItemReference theItemRef) -> (UInt16 numFlavors)")},
 	{"GetFlavorType", (PyCFunction)DragObj_GetFlavorType, 1,
-	 "(ItemReference theItemRef, UInt16 index) -> (FlavorType theType)"},
+	 PyDoc_STR("(ItemReference theItemRef, UInt16 index) -> (FlavorType theType)")},
 	{"GetFlavorFlags", (PyCFunction)DragObj_GetFlavorFlags, 1,
-	 "(ItemReference theItemRef, FlavorType theType) -> (FlavorFlags theFlags)"},
+	 PyDoc_STR("(ItemReference theItemRef, FlavorType theType) -> (FlavorFlags theFlags)")},
 	{"GetFlavorDataSize", (PyCFunction)DragObj_GetFlavorDataSize, 1,
-	 "(ItemReference theItemRef, FlavorType theType) -> (Size dataSize)"},
+	 PyDoc_STR("(ItemReference theItemRef, FlavorType theType) -> (Size dataSize)")},
 	{"GetFlavorData", (PyCFunction)DragObj_GetFlavorData, 1,
-	 "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> (Buffer dataPtr)"},
+	 PyDoc_STR("(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> (Buffer dataPtr)")},
 	{"GetDragItemBounds", (PyCFunction)DragObj_GetDragItemBounds, 1,
-	 "(ItemReference theItemRef) -> (Rect itemBounds)"},
+	 PyDoc_STR("(ItemReference theItemRef) -> (Rect itemBounds)")},
 	{"SetDragItemBounds", (PyCFunction)DragObj_SetDragItemBounds, 1,
-	 "(ItemReference theItemRef, Rect itemBounds) -> None"},
+	 PyDoc_STR("(ItemReference theItemRef, Rect itemBounds) -> None")},
 	{"GetDropLocation", (PyCFunction)DragObj_GetDropLocation, 1,
-	 "() -> (AEDesc dropLocation)"},
+	 PyDoc_STR("() -> (AEDesc dropLocation)")},
 	{"SetDropLocation", (PyCFunction)DragObj_SetDropLocation, 1,
-	 "(AEDesc dropLocation) -> None"},
+	 PyDoc_STR("(AEDesc dropLocation) -> None")},
 	{"GetDragAttributes", (PyCFunction)DragObj_GetDragAttributes, 1,
-	 "() -> (DragAttributes flags)"},
+	 PyDoc_STR("() -> (DragAttributes flags)")},
 	{"GetDragMouse", (PyCFunction)DragObj_GetDragMouse, 1,
-	 "() -> (Point mouse, Point globalPinnedMouse)"},
+	 PyDoc_STR("() -> (Point mouse, Point globalPinnedMouse)")},
 	{"SetDragMouse", (PyCFunction)DragObj_SetDragMouse, 1,
-	 "(Point globalPinnedMouse) -> None"},
+	 PyDoc_STR("(Point globalPinnedMouse) -> None")},
 	{"GetDragOrigin", (PyCFunction)DragObj_GetDragOrigin, 1,
-	 "() -> (Point globalInitialMouse)"},
+	 PyDoc_STR("() -> (Point globalInitialMouse)")},
 	{"GetDragModifiers", (PyCFunction)DragObj_GetDragModifiers, 1,
-	 "() -> (SInt16 modifiers, SInt16 mouseDownModifiers, SInt16 mouseUpModifiers)"},
+	 PyDoc_STR("() -> (SInt16 modifiers, SInt16 mouseDownModifiers, SInt16 mouseUpModifiers)")},
 	{"ShowDragHilite", (PyCFunction)DragObj_ShowDragHilite, 1,
-	 "(RgnHandle hiliteFrame, Boolean inside) -> None"},
+	 PyDoc_STR("(RgnHandle hiliteFrame, Boolean inside) -> None")},
 	{"HideDragHilite", (PyCFunction)DragObj_HideDragHilite, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DragPreScroll", (PyCFunction)DragObj_DragPreScroll, 1,
-	 "(SInt16 dH, SInt16 dV) -> None"},
+	 PyDoc_STR("(SInt16 dH, SInt16 dV) -> None")},
 	{"DragPostScroll", (PyCFunction)DragObj_DragPostScroll, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"UpdateDragHilite", (PyCFunction)DragObj_UpdateDragHilite, 1,
-	 "(RgnHandle updateRgn) -> None"},
+	 PyDoc_STR("(RgnHandle updateRgn) -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -959,23 +959,23 @@ static PyObject *Drag_RemoveReceiveHandler(PyObject *_self, PyObject *_args)
 
 static PyMethodDef Drag_methods[] = {
 	{"NewDrag", (PyCFunction)Drag_NewDrag, 1,
-	 "() -> (DragRef theDrag)"},
+	 PyDoc_STR("() -> (DragRef theDrag)")},
 	{"GetDragHiliteColor", (PyCFunction)Drag_GetDragHiliteColor, 1,
-	 "(WindowPtr window) -> (RGBColor color)"},
+	 PyDoc_STR("(WindowPtr window) -> (RGBColor color)")},
 	{"WaitMouseMoved", (PyCFunction)Drag_WaitMouseMoved, 1,
-	 "(Point initialMouse) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point initialMouse) -> (Boolean _rv)")},
 	{"ZoomRects", (PyCFunction)Drag_ZoomRects, 1,
-	 "(Rect fromRect, Rect toRect, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None"},
+	 PyDoc_STR("(Rect fromRect, Rect toRect, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None")},
 	{"ZoomRegion", (PyCFunction)Drag_ZoomRegion, 1,
-	 "(RgnHandle region, Point zoomDistance, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None"},
+	 PyDoc_STR("(RgnHandle region, Point zoomDistance, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None")},
 	{"InstallTrackingHandler", (PyCFunction)Drag_InstallTrackingHandler, 1,
-	 NULL},
+	 PyDoc_STR(NULL)},
 	{"InstallReceiveHandler", (PyCFunction)Drag_InstallReceiveHandler, 1,
-	 NULL},
+	 PyDoc_STR(NULL)},
 	{"RemoveTrackingHandler", (PyCFunction)Drag_RemoveTrackingHandler, 1,
-	 NULL},
+	 PyDoc_STR(NULL)},
 	{"RemoveReceiveHandler", (PyCFunction)Drag_RemoveReceiveHandler, 1,
-	 NULL},
+	 PyDoc_STR(NULL)},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/evt/_Evtmodule.c

@@ -592,93 +592,93 @@ static PyObject *Evt_WaitNextEvent(PyObject *_self, PyObject *_args)
 
 static PyMethodDef Evt_methods[] = {
 	{"GetMouse", (PyCFunction)Evt_GetMouse, 1,
-	 "() -> (Point mouseLoc)"},
+	 PyDoc_STR("() -> (Point mouseLoc)")},
 	{"Button", (PyCFunction)Evt_Button, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"StillDown", (PyCFunction)Evt_StillDown, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"WaitMouseUp", (PyCFunction)Evt_WaitMouseUp, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"GetCaretTime", (PyCFunction)Evt_GetCaretTime, 1,
-	 "() -> (UInt32 _rv)"},
+	 PyDoc_STR("() -> (UInt32 _rv)")},
 	{"GetKeys", (PyCFunction)Evt_GetKeys, 1,
-	 "() -> (KeyMap theKeys)"},
+	 PyDoc_STR("() -> (KeyMap theKeys)")},
 	{"GetDblTime", (PyCFunction)Evt_GetDblTime, 1,
-	 "() -> (UInt32 _rv)"},
+	 PyDoc_STR("() -> (UInt32 _rv)")},
 	{"SetEventMask", (PyCFunction)Evt_SetEventMask, 1,
-	 "(EventMask value) -> None"},
+	 PyDoc_STR("(EventMask value) -> None")},
 	{"GetNextEvent", (PyCFunction)Evt_GetNextEvent, 1,
-	 "(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"},
+	 PyDoc_STR("(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)")},
 	{"EventAvail", (PyCFunction)Evt_EventAvail, 1,
-	 "(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"},
+	 PyDoc_STR("(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)")},
 	{"PostEvent", (PyCFunction)Evt_PostEvent, 1,
-	 "(EventKind eventNum, UInt32 eventMsg) -> None"},
+	 PyDoc_STR("(EventKind eventNum, UInt32 eventMsg) -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"OSEventAvail", (PyCFunction)Evt_OSEventAvail, 1,
-	 "(EventMask mask) -> (Boolean _rv, EventRecord theEvent)"},
+	 PyDoc_STR("(EventMask mask) -> (Boolean _rv, EventRecord theEvent)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"GetOSEvent", (PyCFunction)Evt_GetOSEvent, 1,
-	 "(EventMask mask) -> (Boolean _rv, EventRecord theEvent)"},
+	 PyDoc_STR("(EventMask mask) -> (Boolean _rv, EventRecord theEvent)")},
 #endif
 	{"FlushEvents", (PyCFunction)Evt_FlushEvents, 1,
-	 "(EventMask whichMask, EventMask stopMask) -> None"},
+	 PyDoc_STR("(EventMask whichMask, EventMask stopMask) -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SystemClick", (PyCFunction)Evt_SystemClick, 1,
-	 "(EventRecord theEvent, WindowPtr theWindow) -> None"},
+	 PyDoc_STR("(EventRecord theEvent, WindowPtr theWindow) -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"SystemTask", (PyCFunction)Evt_SystemTask, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"SystemEvent", (PyCFunction)Evt_SystemEvent, 1,
-	 "(EventRecord theEvent) -> (Boolean _rv)"},
+	 PyDoc_STR("(EventRecord theEvent) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetGlobalMouse", (PyCFunction)Evt_GetGlobalMouse, 1,
-	 "() -> (Point globalMouse)"},
+	 PyDoc_STR("() -> (Point globalMouse)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetCurrentKeyModifiers", (PyCFunction)Evt_GetCurrentKeyModifiers, 1,
-	 "() -> (UInt32 _rv)"},
+	 PyDoc_STR("() -> (UInt32 _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CheckEventQueueForUserCancel", (PyCFunction)Evt_CheckEventQueueForUserCancel, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 	{"KeyScript", (PyCFunction)Evt_KeyScript, 1,
-	 "(short code) -> None"},
+	 PyDoc_STR("(short code) -> None")},
 	{"IsCmdChar", (PyCFunction)Evt_IsCmdChar, 1,
-	 "(EventRecord event, short test) -> (Boolean _rv)"},
+	 PyDoc_STR("(EventRecord event, short test) -> (Boolean _rv)")},
 	{"LMGetKeyThresh", (PyCFunction)Evt_LMGetKeyThresh, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"LMSetKeyThresh", (PyCFunction)Evt_LMSetKeyThresh, 1,
-	 "(SInt16 value) -> None"},
+	 PyDoc_STR("(SInt16 value) -> None")},
 	{"LMGetKeyRepThresh", (PyCFunction)Evt_LMGetKeyRepThresh, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"LMSetKeyRepThresh", (PyCFunction)Evt_LMSetKeyRepThresh, 1,
-	 "(SInt16 value) -> None"},
+	 PyDoc_STR("(SInt16 value) -> None")},
 	{"LMGetKbdLast", (PyCFunction)Evt_LMGetKbdLast, 1,
-	 "() -> (UInt8 _rv)"},
+	 PyDoc_STR("() -> (UInt8 _rv)")},
 	{"LMSetKbdLast", (PyCFunction)Evt_LMSetKbdLast, 1,
-	 "(UInt8 value) -> None"},
+	 PyDoc_STR("(UInt8 value) -> None")},
 	{"LMGetKbdType", (PyCFunction)Evt_LMGetKbdType, 1,
-	 "() -> (UInt8 _rv)"},
+	 PyDoc_STR("() -> (UInt8 _rv)")},
 	{"LMSetKbdType", (PyCFunction)Evt_LMSetKbdType, 1,
-	 "(UInt8 value) -> None"},
+	 PyDoc_STR("(UInt8 value) -> None")},
 	{"TickCount", (PyCFunction)Evt_TickCount, 1,
-	 "() -> (UInt32 _rv)"},
+	 PyDoc_STR("() -> (UInt32 _rv)")},
 	{"WaitNextEvent", (PyCFunction)Evt_WaitNextEvent, 1,
-	 "(EventMask eventMask, UInt32 sleep [,RegionHandle]) -> (Boolean _rv, EventRecord theEvent)"},
+	 PyDoc_STR("(EventMask eventMask, UInt32 sleep [,RegionHandle]) -> (Boolean _rv, EventRecord theEvent)")},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/fm/_Fmmodule.c

@@ -369,48 +369,48 @@ static PyMethodDef Fm_methods[] = {
 
 #if !TARGET_API_MAC_CARBON
 	{"InitFonts", (PyCFunction)Fm_InitFonts, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 	{"GetFontName", (PyCFunction)Fm_GetFontName, 1,
-	 "(short familyID) -> (Str255 name)"},
+	 PyDoc_STR("(short familyID) -> (Str255 name)")},
 	{"GetFNum", (PyCFunction)Fm_GetFNum, 1,
-	 "(Str255 name) -> (short familyID)"},
+	 PyDoc_STR("(Str255 name) -> (short familyID)")},
 	{"RealFont", (PyCFunction)Fm_RealFont, 1,
-	 "(short fontNum, short size) -> (Boolean _rv)"},
+	 PyDoc_STR("(short fontNum, short size) -> (Boolean _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SetFontLock", (PyCFunction)Fm_SetFontLock, 1,
-	 "(Boolean lockFlag) -> None"},
+	 PyDoc_STR("(Boolean lockFlag) -> None")},
 #endif
 	{"SetFScaleDisable", (PyCFunction)Fm_SetFScaleDisable, 1,
-	 "(Boolean fscaleDisable) -> None"},
+	 PyDoc_STR("(Boolean fscaleDisable) -> None")},
 	{"FontMetrics", (PyCFunction)Fm_FontMetrics, 1,
-	 "() -> (FMetricRec theMetrics)"},
+	 PyDoc_STR("() -> (FMetricRec theMetrics)")},
 	{"SetFractEnable", (PyCFunction)Fm_SetFractEnable, 1,
-	 "(Boolean fractEnable) -> None"},
+	 PyDoc_STR("(Boolean fractEnable) -> None")},
 	{"GetDefFontSize", (PyCFunction)Fm_GetDefFontSize, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"IsOutline", (PyCFunction)Fm_IsOutline, 1,
-	 "(Point numer, Point denom) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point numer, Point denom) -> (Boolean _rv)")},
 	{"SetOutlinePreferred", (PyCFunction)Fm_SetOutlinePreferred, 1,
-	 "(Boolean outlinePreferred) -> None"},
+	 PyDoc_STR("(Boolean outlinePreferred) -> None")},
 	{"GetOutlinePreferred", (PyCFunction)Fm_GetOutlinePreferred, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"SetPreserveGlyph", (PyCFunction)Fm_SetPreserveGlyph, 1,
-	 "(Boolean preserveGlyph) -> None"},
+	 PyDoc_STR("(Boolean preserveGlyph) -> None")},
 	{"GetPreserveGlyph", (PyCFunction)Fm_GetPreserveGlyph, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"FlushFonts", (PyCFunction)Fm_FlushFonts, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 	{"GetSysFont", (PyCFunction)Fm_GetSysFont, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"GetAppFont", (PyCFunction)Fm_GetAppFont, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"QDTextBounds", (PyCFunction)Fm_QDTextBounds, 1,
-	 "(Buffer inText) -> (Rect bounds)"},
+	 PyDoc_STR("(Buffer inText) -> (Rect bounds)")},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/help/_Helpmodule.c

@@ -249,35 +249,35 @@ static PyObject *Help_HMGetBalloonWindow(PyObject *_self, PyObject *_args)
 
 static PyMethodDef Help_methods[] = {
 	{"HMGetHelpMenuHandle", (PyCFunction)Help_HMGetHelpMenuHandle, 1,
-	 "() -> (MenuRef mh)"},
+	 PyDoc_STR("() -> (MenuRef mh)")},
 	{"HMRemoveBalloon", (PyCFunction)Help_HMRemoveBalloon, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"HMIsBalloon", (PyCFunction)Help_HMIsBalloon, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"HMGetBalloons", (PyCFunction)Help_HMGetBalloons, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"HMSetBalloons", (PyCFunction)Help_HMSetBalloons, 1,
-	 "(Boolean flag) -> None"},
+	 PyDoc_STR("(Boolean flag) -> None")},
 	{"HMSetFont", (PyCFunction)Help_HMSetFont, 1,
-	 "(SInt16 font) -> None"},
+	 PyDoc_STR("(SInt16 font) -> None")},
 	{"HMSetFontSize", (PyCFunction)Help_HMSetFontSize, 1,
-	 "(UInt16 fontSize) -> None"},
+	 PyDoc_STR("(UInt16 fontSize) -> None")},
 	{"HMGetFont", (PyCFunction)Help_HMGetFont, 1,
-	 "() -> (SInt16 font)"},
+	 PyDoc_STR("() -> (SInt16 font)")},
 	{"HMGetFontSize", (PyCFunction)Help_HMGetFontSize, 1,
-	 "() -> (UInt16 fontSize)"},
+	 PyDoc_STR("() -> (UInt16 fontSize)")},
 	{"HMSetDialogResID", (PyCFunction)Help_HMSetDialogResID, 1,
-	 "(SInt16 resID) -> None"},
+	 PyDoc_STR("(SInt16 resID) -> None")},
 	{"HMSetMenuResID", (PyCFunction)Help_HMSetMenuResID, 1,
-	 "(SInt16 menuID, SInt16 resID) -> None"},
+	 PyDoc_STR("(SInt16 menuID, SInt16 resID) -> None")},
 	{"HMScanTemplateItems", (PyCFunction)Help_HMScanTemplateItems, 1,
-	 "(SInt16 whichID, SInt16 whichResFile, ResType whichType) -> None"},
+	 PyDoc_STR("(SInt16 whichID, SInt16 whichResFile, ResType whichType) -> None")},
 	{"HMGetDialogResID", (PyCFunction)Help_HMGetDialogResID, 1,
-	 "() -> (SInt16 resID)"},
+	 PyDoc_STR("() -> (SInt16 resID)")},
 	{"HMGetMenuResID", (PyCFunction)Help_HMGetMenuResID, 1,
-	 "(SInt16 menuID) -> (SInt16 resID)"},
+	 PyDoc_STR("(SInt16 menuID) -> (SInt16 resID)")},
 	{"HMGetBalloonWindow", (PyCFunction)Help_HMGetBalloonWindow, 1,
-	 "() -> (WindowPtr window)"},
+	 PyDoc_STR("() -> (WindowPtr window)")},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/ibcarbon/_IBCarbon.c

@@ -130,13 +130,13 @@ static PyObject *IBNibRefObj_SetMenuBarFromNib(IBNibRefObject *_self, PyObject *
 
 static PyMethodDef IBNibRefObj_methods[] = {
 	{"CreateWindowFromNib", (PyCFunction)IBNibRefObj_CreateWindowFromNib, 1,
-	 "(CFStringRef inName) -> (WindowPtr outWindow)"},
+	 PyDoc_STR("(CFStringRef inName) -> (WindowPtr outWindow)")},
 	{"CreateMenuFromNib", (PyCFunction)IBNibRefObj_CreateMenuFromNib, 1,
-	 "(CFStringRef inName) -> (MenuHandle outMenuRef)"},
+	 PyDoc_STR("(CFStringRef inName) -> (MenuHandle outMenuRef)")},
 	{"CreateMenuBarFromNib", (PyCFunction)IBNibRefObj_CreateMenuBarFromNib, 1,
-	 "(CFStringRef inName) -> (Handle outMenuBar)"},
+	 PyDoc_STR("(CFStringRef inName) -> (Handle outMenuBar)")},
 	{"SetMenuBarFromNib", (PyCFunction)IBNibRefObj_SetMenuBarFromNib, 1,
-	 "(CFStringRef inName) -> None"},
+	 PyDoc_STR("(CFStringRef inName) -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -196,7 +196,7 @@ static PyObject *IBCarbon_CreateNibReference(PyObject *_self, PyObject *_args)
 
 static PyMethodDef IBCarbon_methods[] = {
 	{"CreateNibReference", (PyCFunction)IBCarbon_CreateNibReference, 1,
-	 "(CFStringRef inNibName) -> (IBNibRef outNibRef)"},
+	 PyDoc_STR("(CFStringRef inNibName) -> (IBNibRef outNibRef)")},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/list/_Listmodule.c

@@ -556,53 +556,53 @@ static PyObject *ListObj_as_Resource(ListObject *_self, PyObject *_args)
 
 static PyMethodDef ListObj_methods[] = {
 	{"LAddColumn", (PyCFunction)ListObj_LAddColumn, 1,
-	 "(short count, short colNum) -> (short _rv)"},
+	 PyDoc_STR("(short count, short colNum) -> (short _rv)")},
 	{"LAddRow", (PyCFunction)ListObj_LAddRow, 1,
-	 "(short count, short rowNum) -> (short _rv)"},
+	 PyDoc_STR("(short count, short rowNum) -> (short _rv)")},
 	{"LDelColumn", (PyCFunction)ListObj_LDelColumn, 1,
-	 "(short count, short colNum) -> None"},
+	 PyDoc_STR("(short count, short colNum) -> None")},
 	{"LDelRow", (PyCFunction)ListObj_LDelRow, 1,
-	 "(short count, short rowNum) -> None"},
+	 PyDoc_STR("(short count, short rowNum) -> None")},
 	{"LGetSelect", (PyCFunction)ListObj_LGetSelect, 1,
-	 "(Boolean next, Point theCell) -> (Boolean _rv, Point theCell)"},
+	 PyDoc_STR("(Boolean next, Point theCell) -> (Boolean _rv, Point theCell)")},
 	{"LLastClick", (PyCFunction)ListObj_LLastClick, 1,
-	 "() -> (Point _rv)"},
+	 PyDoc_STR("() -> (Point _rv)")},
 	{"LNextCell", (PyCFunction)ListObj_LNextCell, 1,
-	 "(Boolean hNext, Boolean vNext, Point theCell) -> (Boolean _rv, Point theCell)"},
+	 PyDoc_STR("(Boolean hNext, Boolean vNext, Point theCell) -> (Boolean _rv, Point theCell)")},
 	{"LSize", (PyCFunction)ListObj_LSize, 1,
-	 "(short listWidth, short listHeight) -> None"},
+	 PyDoc_STR("(short listWidth, short listHeight) -> None")},
 	{"LSetDrawingMode", (PyCFunction)ListObj_LSetDrawingMode, 1,
-	 "(Boolean drawIt) -> None"},
+	 PyDoc_STR("(Boolean drawIt) -> None")},
 	{"LScroll", (PyCFunction)ListObj_LScroll, 1,
-	 "(short dCols, short dRows) -> None"},
+	 PyDoc_STR("(short dCols, short dRows) -> None")},
 	{"LAutoScroll", (PyCFunction)ListObj_LAutoScroll, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"LUpdate", (PyCFunction)ListObj_LUpdate, 1,
-	 "(RgnHandle theRgn) -> None"},
+	 PyDoc_STR("(RgnHandle theRgn) -> None")},
 	{"LActivate", (PyCFunction)ListObj_LActivate, 1,
-	 "(Boolean act) -> None"},
+	 PyDoc_STR("(Boolean act) -> None")},
 	{"LCellSize", (PyCFunction)ListObj_LCellSize, 1,
-	 "(Point cSize) -> None"},
+	 PyDoc_STR("(Point cSize) -> None")},
 	{"LClick", (PyCFunction)ListObj_LClick, 1,
-	 "(Point pt, EventModifiers modifiers) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt, EventModifiers modifiers) -> (Boolean _rv)")},
 	{"LAddToCell", (PyCFunction)ListObj_LAddToCell, 1,
-	 "(Buffer dataPtr, Point theCell) -> None"},
+	 PyDoc_STR("(Buffer dataPtr, Point theCell) -> None")},
 	{"LClrCell", (PyCFunction)ListObj_LClrCell, 1,
-	 "(Point theCell) -> None"},
+	 PyDoc_STR("(Point theCell) -> None")},
 	{"LGetCell", (PyCFunction)ListObj_LGetCell, 1,
-	 "(Buffer dataPtr, Point theCell) -> (Buffer dataPtr)"},
+	 PyDoc_STR("(Buffer dataPtr, Point theCell) -> (Buffer dataPtr)")},
 	{"LRect", (PyCFunction)ListObj_LRect, 1,
-	 "(Point theCell) -> (Rect cellRect)"},
+	 PyDoc_STR("(Point theCell) -> (Rect cellRect)")},
 	{"LSetCell", (PyCFunction)ListObj_LSetCell, 1,
-	 "(Buffer dataPtr, Point theCell) -> None"},
+	 PyDoc_STR("(Buffer dataPtr, Point theCell) -> None")},
 	{"LSetSelect", (PyCFunction)ListObj_LSetSelect, 1,
-	 "(Boolean setIt, Point theCell) -> None"},
+	 PyDoc_STR("(Boolean setIt, Point theCell) -> None")},
 	{"LDraw", (PyCFunction)ListObj_LDraw, 1,
-	 "(Point theCell) -> None"},
+	 PyDoc_STR("(Point theCell) -> None")},
 	{"LGetCellDataLocation", (PyCFunction)ListObj_LGetCellDataLocation, 1,
-	 "(Point theCell) -> (short offset, short len)"},
+	 PyDoc_STR("(Point theCell) -> (short offset, short len)")},
 	{"as_Resource", (PyCFunction)ListObj_as_Resource, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -1082,49 +1082,49 @@ static PyObject *List_as_List(PyObject *_self, PyObject *_args)
 
 static PyMethodDef List_methods[] = {
 	{"CreateCustomList", (PyCFunction)List_CreateCustomList, 1,
-	 "(Rect rView, Rect dataBounds, Point cellSize, ListDefSpec theSpec, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle outList)"},
+	 PyDoc_STR("(Rect rView, Rect dataBounds, Point cellSize, ListDefSpec theSpec, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle outList)")},
 	{"LNew", (PyCFunction)List_LNew, 1,
-	 "(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle _rv)"},
+	 PyDoc_STR("(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle _rv)")},
 	{"GetListPort", (PyCFunction)List_GetListPort, 1,
-	 "(ListHandle list) -> (CGrafPtr _rv)"},
+	 PyDoc_STR("(ListHandle list) -> (CGrafPtr _rv)")},
 	{"GetListVerticalScrollBar", (PyCFunction)List_GetListVerticalScrollBar, 1,
-	 "(ListHandle list) -> (ControlHandle _rv)"},
+	 PyDoc_STR("(ListHandle list) -> (ControlHandle _rv)")},
 	{"GetListHorizontalScrollBar", (PyCFunction)List_GetListHorizontalScrollBar, 1,
-	 "(ListHandle list) -> (ControlHandle _rv)"},
+	 PyDoc_STR("(ListHandle list) -> (ControlHandle _rv)")},
 	{"GetListActive", (PyCFunction)List_GetListActive, 1,
-	 "(ListHandle list) -> (Boolean _rv)"},
+	 PyDoc_STR("(ListHandle list) -> (Boolean _rv)")},
 	{"GetListClickTime", (PyCFunction)List_GetListClickTime, 1,
-	 "(ListHandle list) -> (SInt32 _rv)"},
+	 PyDoc_STR("(ListHandle list) -> (SInt32 _rv)")},
 	{"GetListRefCon", (PyCFunction)List_GetListRefCon, 1,
-	 "(ListHandle list) -> (SInt32 _rv)"},
+	 PyDoc_STR("(ListHandle list) -> (SInt32 _rv)")},
 	{"GetListDefinition", (PyCFunction)List_GetListDefinition, 1,
-	 "(ListHandle list) -> (Handle _rv)"},
+	 PyDoc_STR("(ListHandle list) -> (Handle _rv)")},
 	{"GetListUserHandle", (PyCFunction)List_GetListUserHandle, 1,
-	 "(ListHandle list) -> (Handle _rv)"},
+	 PyDoc_STR("(ListHandle list) -> (Handle _rv)")},
 	{"GetListDataHandle", (PyCFunction)List_GetListDataHandle, 1,
-	 "(ListHandle list) -> (DataHandle _rv)"},
+	 PyDoc_STR("(ListHandle list) -> (DataHandle _rv)")},
 	{"GetListFlags", (PyCFunction)List_GetListFlags, 1,
-	 "(ListHandle list) -> (OptionBits _rv)"},
+	 PyDoc_STR("(ListHandle list) -> (OptionBits _rv)")},
 	{"GetListSelectionFlags", (PyCFunction)List_GetListSelectionFlags, 1,
-	 "(ListHandle list) -> (OptionBits _rv)"},
+	 PyDoc_STR("(ListHandle list) -> (OptionBits _rv)")},
 	{"SetListViewBounds", (PyCFunction)List_SetListViewBounds, 1,
-	 "(ListHandle list, Rect view) -> None"},
+	 PyDoc_STR("(ListHandle list, Rect view) -> None")},
 	{"SetListPort", (PyCFunction)List_SetListPort, 1,
-	 "(ListHandle list, CGrafPtr port) -> None"},
+	 PyDoc_STR("(ListHandle list, CGrafPtr port) -> None")},
 	{"SetListCellIndent", (PyCFunction)List_SetListCellIndent, 1,
-	 "(ListHandle list, Point indent) -> None"},
+	 PyDoc_STR("(ListHandle list, Point indent) -> None")},
 	{"SetListClickTime", (PyCFunction)List_SetListClickTime, 1,
-	 "(ListHandle list, SInt32 time) -> None"},
+	 PyDoc_STR("(ListHandle list, SInt32 time) -> None")},
 	{"SetListRefCon", (PyCFunction)List_SetListRefCon, 1,
-	 "(ListHandle list, SInt32 refCon) -> None"},
+	 PyDoc_STR("(ListHandle list, SInt32 refCon) -> None")},
 	{"SetListUserHandle", (PyCFunction)List_SetListUserHandle, 1,
-	 "(ListHandle list, Handle userHandle) -> None"},
+	 PyDoc_STR("(ListHandle list, Handle userHandle) -> None")},
 	{"SetListFlags", (PyCFunction)List_SetListFlags, 1,
-	 "(ListHandle list, OptionBits listFlags) -> None"},
+	 PyDoc_STR("(ListHandle list, OptionBits listFlags) -> None")},
 	{"SetListSelectionFlags", (PyCFunction)List_SetListSelectionFlags, 1,
-	 "(ListHandle list, OptionBits selectionFlags) -> None"},
+	 PyDoc_STR("(ListHandle list, OptionBits selectionFlags) -> None")},
 	{"as_List", (PyCFunction)List_as_List, 1,
-	 "(Resource)->List.\nReturns List object (which is not auto-freed!)"},
+	 PyDoc_STR("(Resource)->List.\nReturns List object (which is not auto-freed!)")},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/qdoffs/_Qdoffsmodule.c

@@ -123,11 +123,11 @@ static PyObject *GWorldObj_as_GrafPtr(GWorldObject *_self, PyObject *_args)
 
 static PyMethodDef GWorldObj_methods[] = {
 	{"GetGWorldDevice", (PyCFunction)GWorldObj_GetGWorldDevice, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"GetGWorldPixMap", (PyCFunction)GWorldObj_GetGWorldPixMap, 1,
-	 "() -> (PixMapHandle _rv)"},
+	 PyDoc_STR("() -> (PixMapHandle _rv)")},
 	{"as_GrafPtr", (PyCFunction)GWorldObj_as_GrafPtr, 1,
-	 "() -> (GrafPtr _rv)"},
+	 PyDoc_STR("() -> (GrafPtr _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -604,51 +604,51 @@ static PyObject *Qdoffs_PutPixMapBytes(PyObject *_self, PyObject *_args)
 
 static PyMethodDef Qdoffs_methods[] = {
 	{"NewGWorld", (PyCFunction)Qdoffs_NewGWorld, 1,
-	 "(short PixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldPtr offscreenGWorld)"},
+	 PyDoc_STR("(short PixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldPtr offscreenGWorld)")},
 	{"LockPixels", (PyCFunction)Qdoffs_LockPixels, 1,
-	 "(PixMapHandle pm) -> (Boolean _rv)"},
+	 PyDoc_STR("(PixMapHandle pm) -> (Boolean _rv)")},
 	{"UnlockPixels", (PyCFunction)Qdoffs_UnlockPixels, 1,
-	 "(PixMapHandle pm) -> None"},
+	 PyDoc_STR("(PixMapHandle pm) -> None")},
 	{"UpdateGWorld", (PyCFunction)Qdoffs_UpdateGWorld, 1,
-	 "(short pixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldFlags _rv, GWorldPtr offscreenGWorld)"},
+	 PyDoc_STR("(short pixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldFlags _rv, GWorldPtr offscreenGWorld)")},
 	{"GetGWorld", (PyCFunction)Qdoffs_GetGWorld, 1,
-	 "() -> (CGrafPtr port, GDHandle gdh)"},
+	 PyDoc_STR("() -> (CGrafPtr port, GDHandle gdh)")},
 	{"SetGWorld", (PyCFunction)Qdoffs_SetGWorld, 1,
-	 "(CGrafPtr port, GDHandle gdh) -> None"},
+	 PyDoc_STR("(CGrafPtr port, GDHandle gdh) -> None")},
 	{"CTabChanged", (PyCFunction)Qdoffs_CTabChanged, 1,
-	 "(CTabHandle ctab) -> None"},
+	 PyDoc_STR("(CTabHandle ctab) -> None")},
 	{"PixPatChanged", (PyCFunction)Qdoffs_PixPatChanged, 1,
-	 "(PixPatHandle ppat) -> None"},
+	 PyDoc_STR("(PixPatHandle ppat) -> None")},
 	{"PortChanged", (PyCFunction)Qdoffs_PortChanged, 1,
-	 "(GrafPtr port) -> None"},
+	 PyDoc_STR("(GrafPtr port) -> None")},
 	{"GDeviceChanged", (PyCFunction)Qdoffs_GDeviceChanged, 1,
-	 "(GDHandle gdh) -> None"},
+	 PyDoc_STR("(GDHandle gdh) -> None")},
 	{"AllowPurgePixels", (PyCFunction)Qdoffs_AllowPurgePixels, 1,
-	 "(PixMapHandle pm) -> None"},
+	 PyDoc_STR("(PixMapHandle pm) -> None")},
 	{"NoPurgePixels", (PyCFunction)Qdoffs_NoPurgePixels, 1,
-	 "(PixMapHandle pm) -> None"},
+	 PyDoc_STR("(PixMapHandle pm) -> None")},
 	{"GetPixelsState", (PyCFunction)Qdoffs_GetPixelsState, 1,
-	 "(PixMapHandle pm) -> (GWorldFlags _rv)"},
+	 PyDoc_STR("(PixMapHandle pm) -> (GWorldFlags _rv)")},
 	{"SetPixelsState", (PyCFunction)Qdoffs_SetPixelsState, 1,
-	 "(PixMapHandle pm, GWorldFlags state) -> None"},
+	 PyDoc_STR("(PixMapHandle pm, GWorldFlags state) -> None")},
 	{"GetPixRowBytes", (PyCFunction)Qdoffs_GetPixRowBytes, 1,
-	 "(PixMapHandle pm) -> (long _rv)"},
+	 PyDoc_STR("(PixMapHandle pm) -> (long _rv)")},
 	{"NewScreenBuffer", (PyCFunction)Qdoffs_NewScreenBuffer, 1,
-	 "(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)"},
+	 PyDoc_STR("(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)")},
 	{"DisposeScreenBuffer", (PyCFunction)Qdoffs_DisposeScreenBuffer, 1,
-	 "(PixMapHandle offscreenPixMap) -> None"},
+	 PyDoc_STR("(PixMapHandle offscreenPixMap) -> None")},
 	{"QDDone", (PyCFunction)Qdoffs_QDDone, 1,
-	 "(GrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(GrafPtr port) -> (Boolean _rv)")},
 	{"OffscreenVersion", (PyCFunction)Qdoffs_OffscreenVersion, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"NewTempScreenBuffer", (PyCFunction)Qdoffs_NewTempScreenBuffer, 1,
-	 "(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)"},
+	 PyDoc_STR("(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)")},
 	{"PixMap32Bit", (PyCFunction)Qdoffs_PixMap32Bit, 1,
-	 "(PixMapHandle pmHandle) -> (Boolean _rv)"},
+	 PyDoc_STR("(PixMapHandle pmHandle) -> (Boolean _rv)")},
 	{"GetPixMapBytes", (PyCFunction)Qdoffs_GetPixMapBytes, 1,
-	 "(pixmap, int start, int size) -> string. Return bytes from the pixmap"},
+	 PyDoc_STR("(pixmap, int start, int size) -> string. Return bytes from the pixmap")},
 	{"PutPixMapBytes", (PyCFunction)Qdoffs_PutPixMapBytes, 1,
-	 "(pixmap, int start, string data). Store bytes into the pixmap"},
+	 PyDoc_STR("(pixmap, int start, string data). Store bytes into the pixmap")},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/snd/_Sndmodule.c

@@ -271,32 +271,32 @@ static PyObject *SndCh_SndSetInfo(SndChannelObject *_self, PyObject *_args)
 
 static PyMethodDef SndCh_methods[] = {
 	{"SndDoCommand", (PyCFunction)SndCh_SndDoCommand, 1,
-	 "(SndCommand cmd, Boolean noWait) -> None"},
+	 PyDoc_STR("(SndCommand cmd, Boolean noWait) -> None")},
 	{"SndDoImmediate", (PyCFunction)SndCh_SndDoImmediate, 1,
-	 "(SndCommand cmd) -> None"},
+	 PyDoc_STR("(SndCommand cmd) -> None")},
 	{"SndPlay", (PyCFunction)SndCh_SndPlay, 1,
-	 "(SndListHandle sndHandle, Boolean async) -> None"},
+	 PyDoc_STR("(SndListHandle sndHandle, Boolean async) -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SndStartFilePlay", (PyCFunction)SndCh_SndStartFilePlay, 1,
-	 "(short fRefNum, short resNum, long bufferSize, Boolean async) -> None"},
+	 PyDoc_STR("(short fRefNum, short resNum, long bufferSize, Boolean async) -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"SndPauseFilePlay", (PyCFunction)SndCh_SndPauseFilePlay, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"SndStopFilePlay", (PyCFunction)SndCh_SndStopFilePlay, 1,
-	 "(Boolean quietNow) -> None"},
+	 PyDoc_STR("(Boolean quietNow) -> None")},
 #endif
 	{"SndChannelStatus", (PyCFunction)SndCh_SndChannelStatus, 1,
-	 "(short theLength) -> (SCStatus theStatus)"},
+	 PyDoc_STR("(short theLength) -> (SCStatus theStatus)")},
 	{"SndGetInfo", (PyCFunction)SndCh_SndGetInfo, 1,
-	 "(OSType selector, void * infoPtr) -> None"},
+	 PyDoc_STR("(OSType selector, void * infoPtr) -> None")},
 	{"SndSetInfo", (PyCFunction)SndCh_SndSetInfo, 1,
-	 "(OSType selector, void * infoPtr) -> None"},
+	 PyDoc_STR("(OSType selector, void * infoPtr) -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -1292,109 +1292,109 @@ static PyObject *Snd_SPBBytesToMilliseconds(PyObject *_self, PyObject *_args)
 
 static PyMethodDef Snd_methods[] = {
 	{"SPB", (PyCFunction)Snd_SPB, 1,
-	 NULL},
+	 PyDoc_STR(NULL)},
 	{"SysBeep", (PyCFunction)Snd_SysBeep, 1,
-	 "(short duration) -> None"},
+	 PyDoc_STR("(short duration) -> None")},
 	{"SndNewChannel", (PyCFunction)Snd_SndNewChannel, 1,
-	 "(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)"},
+	 PyDoc_STR("(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SndControl", (PyCFunction)Snd_SndControl, 1,
-	 "(short id) -> (SndCommand cmd)"},
+	 PyDoc_STR("(short id) -> (SndCommand cmd)")},
 #endif
 	{"SndSoundManagerVersion", (PyCFunction)Snd_SndSoundManagerVersion, 1,
-	 "() -> (NumVersion _rv)"},
+	 PyDoc_STR("() -> (NumVersion _rv)")},
 	{"SndManagerStatus", (PyCFunction)Snd_SndManagerStatus, 1,
-	 "(short theLength) -> (SMStatus theStatus)"},
+	 PyDoc_STR("(short theLength) -> (SMStatus theStatus)")},
 	{"SndGetSysBeepState", (PyCFunction)Snd_SndGetSysBeepState, 1,
-	 "() -> (short sysBeepState)"},
+	 PyDoc_STR("() -> (short sysBeepState)")},
 	{"SndSetSysBeepState", (PyCFunction)Snd_SndSetSysBeepState, 1,
-	 "(short sysBeepState) -> None"},
+	 PyDoc_STR("(short sysBeepState) -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"MACEVersion", (PyCFunction)Snd_MACEVersion, 1,
-	 "() -> (NumVersion _rv)"},
+	 PyDoc_STR("() -> (NumVersion _rv)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"Comp3to1", (PyCFunction)Snd_Comp3to1, 1,
-	 "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+	 PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"Exp1to3", (PyCFunction)Snd_Exp1to3, 1,
-	 "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+	 PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"Comp6to1", (PyCFunction)Snd_Comp6to1, 1,
-	 "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+	 PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"Exp1to6", (PyCFunction)Snd_Exp1to6, 1,
-	 "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
+	 PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")},
 #endif
 	{"GetSysBeepVolume", (PyCFunction)Snd_GetSysBeepVolume, 1,
-	 "() -> (long level)"},
+	 PyDoc_STR("() -> (long level)")},
 	{"SetSysBeepVolume", (PyCFunction)Snd_SetSysBeepVolume, 1,
-	 "(long level) -> None"},
+	 PyDoc_STR("(long level) -> None")},
 	{"GetDefaultOutputVolume", (PyCFunction)Snd_GetDefaultOutputVolume, 1,
-	 "() -> (long level)"},
+	 PyDoc_STR("() -> (long level)")},
 	{"SetDefaultOutputVolume", (PyCFunction)Snd_SetDefaultOutputVolume, 1,
-	 "(long level) -> None"},
+	 PyDoc_STR("(long level) -> None")},
 	{"GetSoundHeaderOffset", (PyCFunction)Snd_GetSoundHeaderOffset, 1,
-	 "(SndListHandle sndHandle) -> (long offset)"},
+	 PyDoc_STR("(SndListHandle sndHandle) -> (long offset)")},
 	{"GetCompressionInfo", (PyCFunction)Snd_GetCompressionInfo, 1,
-	 "(short compressionID, OSType format, short numChannels, short sampleSize) -> (CompressionInfo cp)"},
+	 PyDoc_STR("(short compressionID, OSType format, short numChannels, short sampleSize) -> (CompressionInfo cp)")},
 	{"SetSoundPreference", (PyCFunction)Snd_SetSoundPreference, 1,
-	 "(OSType theType, Handle settings) -> (Str255 name)"},
+	 PyDoc_STR("(OSType theType, Handle settings) -> (Str255 name)")},
 	{"GetSoundPreference", (PyCFunction)Snd_GetSoundPreference, 1,
-	 "(OSType theType, Handle settings) -> (Str255 name)"},
+	 PyDoc_STR("(OSType theType, Handle settings) -> (Str255 name)")},
 	{"GetCompressionName", (PyCFunction)Snd_GetCompressionName, 1,
-	 "(OSType compressionType) -> (Str255 compressionName)"},
+	 PyDoc_STR("(OSType compressionType) -> (Str255 compressionName)")},
 	{"SPBVersion", (PyCFunction)Snd_SPBVersion, 1,
-	 "() -> (NumVersion _rv)"},
+	 PyDoc_STR("() -> (NumVersion _rv)")},
 	{"SndRecord", (PyCFunction)Snd_SndRecord, 1,
-	 "(Point corner, OSType quality) -> (SndListHandle sndHandle)"},
+	 PyDoc_STR("(Point corner, OSType quality) -> (SndListHandle sndHandle)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SndRecordToFile", (PyCFunction)Snd_SndRecordToFile, 1,
-	 "(Point corner, OSType quality, short fRefNum) -> None"},
+	 PyDoc_STR("(Point corner, OSType quality, short fRefNum) -> None")},
 #endif
 	{"SPBSignInDevice", (PyCFunction)Snd_SPBSignInDevice, 1,
-	 "(short deviceRefNum, Str255 deviceName) -> None"},
+	 PyDoc_STR("(short deviceRefNum, Str255 deviceName) -> None")},
 	{"SPBSignOutDevice", (PyCFunction)Snd_SPBSignOutDevice, 1,
-	 "(short deviceRefNum) -> None"},
+	 PyDoc_STR("(short deviceRefNum) -> None")},
 	{"SPBGetIndexedDevice", (PyCFunction)Snd_SPBGetIndexedDevice, 1,
-	 "(short count) -> (Str255 deviceName, Handle deviceIconHandle)"},
+	 PyDoc_STR("(short count) -> (Str255 deviceName, Handle deviceIconHandle)")},
 	{"SPBOpenDevice", (PyCFunction)Snd_SPBOpenDevice, 1,
-	 "(Str255 deviceName, short permission) -> (long inRefNum)"},
+	 PyDoc_STR("(Str255 deviceName, short permission) -> (long inRefNum)")},
 	{"SPBCloseDevice", (PyCFunction)Snd_SPBCloseDevice, 1,
-	 "(long inRefNum) -> None"},
+	 PyDoc_STR("(long inRefNum) -> None")},
 	{"SPBRecord", (PyCFunction)Snd_SPBRecord, 1,
-	 "(SPBPtr inParamPtr, Boolean asynchFlag) -> None"},
+	 PyDoc_STR("(SPBPtr inParamPtr, Boolean asynchFlag) -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SPBRecordToFile", (PyCFunction)Snd_SPBRecordToFile, 1,
-	 "(short fRefNum, SPBPtr inParamPtr, Boolean asynchFlag) -> None"},
+	 PyDoc_STR("(short fRefNum, SPBPtr inParamPtr, Boolean asynchFlag) -> None")},
 #endif
 	{"SPBPauseRecording", (PyCFunction)Snd_SPBPauseRecording, 1,
-	 "(long inRefNum) -> None"},
+	 PyDoc_STR("(long inRefNum) -> None")},
 	{"SPBResumeRecording", (PyCFunction)Snd_SPBResumeRecording, 1,
-	 "(long inRefNum) -> None"},
+	 PyDoc_STR("(long inRefNum) -> None")},
 	{"SPBStopRecording", (PyCFunction)Snd_SPBStopRecording, 1,
-	 "(long inRefNum) -> None"},
+	 PyDoc_STR("(long inRefNum) -> None")},
 	{"SPBGetRecordingStatus", (PyCFunction)Snd_SPBGetRecordingStatus, 1,
-	 "(long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded)"},
+	 PyDoc_STR("(long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded)")},
 	{"SPBGetDeviceInfo", (PyCFunction)Snd_SPBGetDeviceInfo, 1,
-	 "(long inRefNum, OSType infoType, void * infoData) -> None"},
+	 PyDoc_STR("(long inRefNum, OSType infoType, void * infoData) -> None")},
 	{"SPBSetDeviceInfo", (PyCFunction)Snd_SPBSetDeviceInfo, 1,
-	 "(long inRefNum, OSType infoType, void * infoData) -> None"},
+	 PyDoc_STR("(long inRefNum, OSType infoType, void * infoData) -> None")},
 	{"SPBMillisecondsToBytes", (PyCFunction)Snd_SPBMillisecondsToBytes, 1,
-	 "(long inRefNum) -> (long milliseconds)"},
+	 PyDoc_STR("(long inRefNum) -> (long milliseconds)")},
 	{"SPBBytesToMilliseconds", (PyCFunction)Snd_SPBBytesToMilliseconds, 1,
-	 "(long inRefNum) -> (long byteCount)"},
+	 PyDoc_STR("(long inRefNum) -> (long byteCount)")},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/te/_TEmodule.c

@@ -774,79 +774,79 @@ static PyObject *TEObj_as_Resource(TEObject *_self, PyObject *_args)
 
 static PyMethodDef TEObj_methods[] = {
 	{"TESetText", (PyCFunction)TEObj_TESetText, 1,
-	 "(Buffer text) -> None"},
+	 PyDoc_STR("(Buffer text) -> None")},
 	{"TEGetText", (PyCFunction)TEObj_TEGetText, 1,
-	 "() -> (CharsHandle _rv)"},
+	 PyDoc_STR("() -> (CharsHandle _rv)")},
 	{"TEIdle", (PyCFunction)TEObj_TEIdle, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TESetSelect", (PyCFunction)TEObj_TESetSelect, 1,
-	 "(long selStart, long selEnd) -> None"},
+	 PyDoc_STR("(long selStart, long selEnd) -> None")},
 	{"TEActivate", (PyCFunction)TEObj_TEActivate, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TEDeactivate", (PyCFunction)TEObj_TEDeactivate, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TEKey", (PyCFunction)TEObj_TEKey, 1,
-	 "(CharParameter key) -> None"},
+	 PyDoc_STR("(CharParameter key) -> None")},
 	{"TECut", (PyCFunction)TEObj_TECut, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TECopy", (PyCFunction)TEObj_TECopy, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TEPaste", (PyCFunction)TEObj_TEPaste, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TEDelete", (PyCFunction)TEObj_TEDelete, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TEInsert", (PyCFunction)TEObj_TEInsert, 1,
-	 "(Buffer text) -> None"},
+	 PyDoc_STR("(Buffer text) -> None")},
 	{"TESetAlignment", (PyCFunction)TEObj_TESetAlignment, 1,
-	 "(short just) -> None"},
+	 PyDoc_STR("(short just) -> None")},
 	{"TEUpdate", (PyCFunction)TEObj_TEUpdate, 1,
-	 "(Rect rUpdate) -> None"},
+	 PyDoc_STR("(Rect rUpdate) -> None")},
 	{"TEScroll", (PyCFunction)TEObj_TEScroll, 1,
-	 "(short dh, short dv) -> None"},
+	 PyDoc_STR("(short dh, short dv) -> None")},
 	{"TESelView", (PyCFunction)TEObj_TESelView, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TEPinScroll", (PyCFunction)TEObj_TEPinScroll, 1,
-	 "(short dh, short dv) -> None"},
+	 PyDoc_STR("(short dh, short dv) -> None")},
 	{"TEAutoView", (PyCFunction)TEObj_TEAutoView, 1,
-	 "(Boolean fAuto) -> None"},
+	 PyDoc_STR("(Boolean fAuto) -> None")},
 	{"TECalText", (PyCFunction)TEObj_TECalText, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TEGetOffset", (PyCFunction)TEObj_TEGetOffset, 1,
-	 "(Point pt) -> (short _rv)"},
+	 PyDoc_STR("(Point pt) -> (short _rv)")},
 	{"TEGetPoint", (PyCFunction)TEObj_TEGetPoint, 1,
-	 "(short offset) -> (Point _rv)"},
+	 PyDoc_STR("(short offset) -> (Point _rv)")},
 	{"TEClick", (PyCFunction)TEObj_TEClick, 1,
-	 "(Point pt, Boolean fExtend) -> None"},
+	 PyDoc_STR("(Point pt, Boolean fExtend) -> None")},
 	{"TESetStyleHandle", (PyCFunction)TEObj_TESetStyleHandle, 1,
-	 "(TEStyleHandle theHandle) -> None"},
+	 PyDoc_STR("(TEStyleHandle theHandle) -> None")},
 	{"TEGetStyleHandle", (PyCFunction)TEObj_TEGetStyleHandle, 1,
-	 "() -> (TEStyleHandle _rv)"},
+	 PyDoc_STR("() -> (TEStyleHandle _rv)")},
 	{"TEGetStyle", (PyCFunction)TEObj_TEGetStyle, 1,
-	 "(short offset) -> (TextStyle theStyle, short lineHeight, short fontAscent)"},
+	 PyDoc_STR("(short offset) -> (TextStyle theStyle, short lineHeight, short fontAscent)")},
 	{"TEStylePaste", (PyCFunction)TEObj_TEStylePaste, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TESetStyle", (PyCFunction)TEObj_TESetStyle, 1,
-	 "(short mode, TextStyle newStyle, Boolean fRedraw) -> None"},
+	 PyDoc_STR("(short mode, TextStyle newStyle, Boolean fRedraw) -> None")},
 	{"TEReplaceStyle", (PyCFunction)TEObj_TEReplaceStyle, 1,
-	 "(short mode, TextStyle oldStyle, TextStyle newStyle, Boolean fRedraw) -> None"},
+	 PyDoc_STR("(short mode, TextStyle oldStyle, TextStyle newStyle, Boolean fRedraw) -> None")},
 	{"TEGetStyleScrapHandle", (PyCFunction)TEObj_TEGetStyleScrapHandle, 1,
-	 "() -> (StScrpHandle _rv)"},
+	 PyDoc_STR("() -> (StScrpHandle _rv)")},
 	{"TEStyleInsert", (PyCFunction)TEObj_TEStyleInsert, 1,
-	 "(Buffer text, StScrpHandle hST) -> None"},
+	 PyDoc_STR("(Buffer text, StScrpHandle hST) -> None")},
 	{"TEGetHeight", (PyCFunction)TEObj_TEGetHeight, 1,
-	 "(long endLine, long startLine) -> (long _rv)"},
+	 PyDoc_STR("(long endLine, long startLine) -> (long _rv)")},
 	{"TEContinuousStyle", (PyCFunction)TEObj_TEContinuousStyle, 1,
-	 "(short mode, TextStyle aStyle) -> (Boolean _rv, short mode, TextStyle aStyle)"},
+	 PyDoc_STR("(short mode, TextStyle aStyle) -> (Boolean _rv, short mode, TextStyle aStyle)")},
 	{"TEUseStyleScrap", (PyCFunction)TEObj_TEUseStyleScrap, 1,
-	 "(long rangeStart, long rangeEnd, StScrpHandle newStyles, Boolean fRedraw) -> None"},
+	 PyDoc_STR("(long rangeStart, long rangeEnd, StScrpHandle newStyles, Boolean fRedraw) -> None")},
 	{"TENumStyles", (PyCFunction)TEObj_TENumStyles, 1,
-	 "(long rangeStart, long rangeEnd) -> (long _rv)"},
+	 PyDoc_STR("(long rangeStart, long rangeEnd) -> (long _rv)")},
 	{"TEFeatureFlag", (PyCFunction)TEObj_TEFeatureFlag, 1,
-	 "(short feature, short action) -> (short _rv)"},
+	 PyDoc_STR("(short feature, short action) -> (short _rv)")},
 	{"TEGetHiliteRgn", (PyCFunction)TEObj_TEGetHiliteRgn, 1,
-	 "(RgnHandle region) -> None"},
+	 PyDoc_STR("(RgnHandle region) -> None")},
 	{"as_Resource", (PyCFunction)TEObj_as_Resource, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -1155,37 +1155,37 @@ static PyObject *TE_as_TE(PyObject *_self, PyObject *_args)
 
 static PyMethodDef TE_methods[] = {
 	{"TEScrapHandle", (PyCFunction)TE_TEScrapHandle, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"TEGetScrapLength", (PyCFunction)TE_TEGetScrapLength, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"TENew", (PyCFunction)TE_TENew, 1,
-	 "(Rect destRect, Rect viewRect) -> (TEHandle _rv)"},
+	 PyDoc_STR("(Rect destRect, Rect viewRect) -> (TEHandle _rv)")},
 	{"TETextBox", (PyCFunction)TE_TETextBox, 1,
-	 "(Buffer text, Rect box, short just) -> None"},
+	 PyDoc_STR("(Buffer text, Rect box, short just) -> None")},
 	{"TEStyleNew", (PyCFunction)TE_TEStyleNew, 1,
-	 "(Rect destRect, Rect viewRect) -> (TEHandle _rv)"},
+	 PyDoc_STR("(Rect destRect, Rect viewRect) -> (TEHandle _rv)")},
 	{"TESetScrapLength", (PyCFunction)TE_TESetScrapLength, 1,
-	 "(long length) -> None"},
+	 PyDoc_STR("(long length) -> None")},
 	{"TEFromScrap", (PyCFunction)TE_TEFromScrap, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TEToScrap", (PyCFunction)TE_TEToScrap, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"TEGetScrapHandle", (PyCFunction)TE_TEGetScrapHandle, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"TESetScrapHandle", (PyCFunction)TE_TESetScrapHandle, 1,
-	 "(Handle value) -> None"},
+	 PyDoc_STR("(Handle value) -> None")},
 #endif
 	{"LMGetWordRedraw", (PyCFunction)TE_LMGetWordRedraw, 1,
-	 "() -> (UInt8 _rv)"},
+	 PyDoc_STR("() -> (UInt8 _rv)")},
 	{"LMSetWordRedraw", (PyCFunction)TE_LMSetWordRedraw, 1,
-	 "(UInt8 value) -> None"},
+	 PyDoc_STR("(UInt8 value) -> None")},
 	{"as_TE", (PyCFunction)TE_as_TE, 1,
-	 "(Handle h) -> (TEHandle _rv)"},
+	 PyDoc_STR("(Handle h) -> (TEHandle _rv)")},
 	{NULL, NULL, 0}
 };