Regenerated with PyDoc_STR() around docstrings.

23 files changed, 2151 insertions, 2151 deletions

diff --git a/Mac/Modules/ae/_AEmodule.c b/Mac/Modules/ae/_AEmodule.c
index 38c6bae..0d8b802 100644
--- a/Mac/Modules/ae/_AEmodule.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/app/_Appmodule.c b/Mac/Modules/app/_Appmodule.c
index d853927..e5362c9 100644
--- a/Mac/Modules/app/_Appmodule.c
+++ b/Mac/Modules/app/_Appmodule.c
@@ -107,9 +107,9 @@ static PyObject *ThemeDrawingStateObj_DisposeThemeDrawingState(ThemeDrawingState
 
 static PyMethodDef ThemeDrawingStateObj_methods[] = {
 	{"SetThemeDrawingState", (PyCFunction)ThemeDrawingStateObj_SetThemeDrawingState, 1,
-	 "(Boolean inDisposeNow) -> (OSStatus _rv)"},
+	 PyDoc_STR("(Boolean inDisposeNow) -> (OSStatus _rv)")},
 	{"DisposeThemeDrawingState", (PyCFunction)ThemeDrawingStateObj_DisposeThemeDrawingState, 1,
-	 "() -> (OSStatus _rv)"},
+	 PyDoc_STR("() -> (OSStatus _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -1646,149 +1646,149 @@ static PyObject *App_GetThemeMetric(PyObject *_self, PyObject *_args)
 
 static PyMethodDef App_methods[] = {
 	{"RegisterAppearanceClient", (PyCFunction)App_RegisterAppearanceClient, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"UnregisterAppearanceClient", (PyCFunction)App_UnregisterAppearanceClient, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetThemePen", (PyCFunction)App_SetThemePen, 1,
-	 "(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
+	 PyDoc_STR("(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None")},
 	{"SetThemeBackground", (PyCFunction)App_SetThemeBackground, 1,
-	 "(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
+	 PyDoc_STR("(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None")},
 	{"SetThemeTextColor", (PyCFunction)App_SetThemeTextColor, 1,
-	 "(ThemeTextColor inColor, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
+	 PyDoc_STR("(ThemeTextColor inColor, SInt16 inDepth, Boolean inIsColorDevice) -> None")},
 	{"SetThemeWindowBackground", (PyCFunction)App_SetThemeWindowBackground, 1,
-	 "(WindowPtr inWindow, ThemeBrush inBrush, Boolean inUpdate) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow, ThemeBrush inBrush, Boolean inUpdate) -> None")},
 	{"DrawThemeWindowHeader", (PyCFunction)App_DrawThemeWindowHeader, 1,
-	 "(Rect inRect, ThemeDrawState inState) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
 	{"DrawThemeWindowListViewHeader", (PyCFunction)App_DrawThemeWindowListViewHeader, 1,
-	 "(Rect inRect, ThemeDrawState inState) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
 	{"DrawThemePlacard", (PyCFunction)App_DrawThemePlacard, 1,
-	 "(Rect inRect, ThemeDrawState inState) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
 	{"DrawThemeEditTextFrame", (PyCFunction)App_DrawThemeEditTextFrame, 1,
-	 "(Rect inRect, ThemeDrawState inState) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
 	{"DrawThemeListBoxFrame", (PyCFunction)App_DrawThemeListBoxFrame, 1,
-	 "(Rect inRect, ThemeDrawState inState) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
 	{"DrawThemeFocusRect", (PyCFunction)App_DrawThemeFocusRect, 1,
-	 "(Rect inRect, Boolean inHasFocus) -> None"},
+	 PyDoc_STR("(Rect inRect, Boolean inHasFocus) -> None")},
 	{"DrawThemePrimaryGroup", (PyCFunction)App_DrawThemePrimaryGroup, 1,
-	 "(Rect inRect, ThemeDrawState inState) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
 	{"DrawThemeSecondaryGroup", (PyCFunction)App_DrawThemeSecondaryGroup, 1,
-	 "(Rect inRect, ThemeDrawState inState) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
 	{"DrawThemeSeparator", (PyCFunction)App_DrawThemeSeparator, 1,
-	 "(Rect inRect, ThemeDrawState inState) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
 	{"DrawThemeModelessDialogFrame", (PyCFunction)App_DrawThemeModelessDialogFrame, 1,
-	 "(Rect inRect, ThemeDrawState inState) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
 	{"DrawThemeGenericWell", (PyCFunction)App_DrawThemeGenericWell, 1,
-	 "(Rect inRect, ThemeDrawState inState, Boolean inFillCenter) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeDrawState inState, Boolean inFillCenter) -> None")},
 	{"DrawThemeFocusRegion", (PyCFunction)App_DrawThemeFocusRegion, 1,
-	 "(Boolean inHasFocus) -> None"},
+	 PyDoc_STR("(Boolean inHasFocus) -> None")},
 	{"IsThemeInColor", (PyCFunction)App_IsThemeInColor, 1,
-	 "(SInt16 inDepth, Boolean inIsColorDevice) -> (Boolean _rv)"},
+	 PyDoc_STR("(SInt16 inDepth, Boolean inIsColorDevice) -> (Boolean _rv)")},
 	{"GetThemeAccentColors", (PyCFunction)App_GetThemeAccentColors, 1,
-	 "() -> (CTabHandle outColors)"},
+	 PyDoc_STR("() -> (CTabHandle outColors)")},
 	{"DrawThemeMenuBarBackground", (PyCFunction)App_DrawThemeMenuBarBackground, 1,
-	 "(Rect inBounds, ThemeMenuBarState inState, UInt32 inAttributes) -> None"},
+	 PyDoc_STR("(Rect inBounds, ThemeMenuBarState inState, UInt32 inAttributes) -> None")},
 	{"GetThemeMenuBarHeight", (PyCFunction)App_GetThemeMenuBarHeight, 1,
-	 "() -> (SInt16 outHeight)"},
+	 PyDoc_STR("() -> (SInt16 outHeight)")},
 	{"DrawThemeMenuBackground", (PyCFunction)App_DrawThemeMenuBackground, 1,
-	 "(Rect inMenuRect, ThemeMenuType inMenuType) -> None"},
+	 PyDoc_STR("(Rect inMenuRect, ThemeMenuType inMenuType) -> None")},
 	{"GetThemeMenuBackgroundRegion", (PyCFunction)App_GetThemeMenuBackgroundRegion, 1,
-	 "(Rect inMenuRect, ThemeMenuType menuType) -> None"},
+	 PyDoc_STR("(Rect inMenuRect, ThemeMenuType menuType) -> None")},
 	{"DrawThemeMenuSeparator", (PyCFunction)App_DrawThemeMenuSeparator, 1,
-	 "(Rect inItemRect) -> None"},
+	 PyDoc_STR("(Rect inItemRect) -> None")},
 	{"GetThemeMenuSeparatorHeight", (PyCFunction)App_GetThemeMenuSeparatorHeight, 1,
-	 "() -> (SInt16 outHeight)"},
+	 PyDoc_STR("() -> (SInt16 outHeight)")},
 	{"GetThemeMenuItemExtra", (PyCFunction)App_GetThemeMenuItemExtra, 1,
-	 "(ThemeMenuItemType inItemType) -> (SInt16 outHeight, SInt16 outWidth)"},
+	 PyDoc_STR("(ThemeMenuItemType inItemType) -> (SInt16 outHeight, SInt16 outWidth)")},
 	{"GetThemeMenuTitleExtra", (PyCFunction)App_GetThemeMenuTitleExtra, 1,
-	 "(Boolean inIsSquished) -> (SInt16 outWidth)"},
+	 PyDoc_STR("(Boolean inIsSquished) -> (SInt16 outWidth)")},
 	{"DrawThemeTabPane", (PyCFunction)App_DrawThemeTabPane, 1,
-	 "(Rect inRect, ThemeDrawState inState) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
 	{"GetThemeTabRegion", (PyCFunction)App_GetThemeTabRegion, 1,
-	 "(Rect inRect, ThemeTabStyle inStyle, ThemeTabDirection inDirection) -> None"},
+	 PyDoc_STR("(Rect inRect, ThemeTabStyle inStyle, ThemeTabDirection inDirection) -> None")},
 	{"SetThemeCursor", (PyCFunction)App_SetThemeCursor, 1,
-	 "(ThemeCursor inCursor) -> None"},
+	 PyDoc_STR("(ThemeCursor inCursor) -> None")},
 	{"SetAnimatedThemeCursor", (PyCFunction)App_SetAnimatedThemeCursor, 1,
-	 "(ThemeCursor inCursor, UInt32 inAnimationStep) -> None"},
+	 PyDoc_STR("(ThemeCursor inCursor, UInt32 inAnimationStep) -> None")},
 	{"GetThemeScrollBarThumbStyle", (PyCFunction)App_GetThemeScrollBarThumbStyle, 1,
-	 "() -> (ThemeScrollBarThumbStyle outStyle)"},
+	 PyDoc_STR("() -> (ThemeScrollBarThumbStyle outStyle)")},
 	{"GetThemeScrollBarArrowStyle", (PyCFunction)App_GetThemeScrollBarArrowStyle, 1,
-	 "() -> (ThemeScrollBarArrowStyle outStyle)"},
+	 PyDoc_STR("() -> (ThemeScrollBarArrowStyle outStyle)")},
 	{"GetThemeCheckBoxStyle", (PyCFunction)App_GetThemeCheckBoxStyle, 1,
-	 "() -> (ThemeCheckBoxStyle outStyle)"},
+	 PyDoc_STR("() -> (ThemeCheckBoxStyle outStyle)")},
 	{"UseThemeFont", (PyCFunction)App_UseThemeFont, 1,
-	 "(ThemeFontID inFontID, ScriptCode inScript) -> None"},
+	 PyDoc_STR("(ThemeFontID inFontID, ScriptCode inScript) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"DrawThemeTextBox", (PyCFunction)App_DrawThemeTextBox, 1,
-	 "(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Rect inBoundingBox, SInt16 inJust) -> None"},
+	 PyDoc_STR("(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Rect inBoundingBox, SInt16 inJust) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"TruncateThemeText", (PyCFunction)App_TruncateThemeText, 1,
-	 "(CFMutableStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, SInt16 inPixelWidthLimit, TruncCode inTruncWhere) -> (Boolean outTruncated)"},
+	 PyDoc_STR("(CFMutableStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, SInt16 inPixelWidthLimit, TruncCode inTruncWhere) -> (Boolean outTruncated)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetThemeTextDimensions", (PyCFunction)App_GetThemeTextDimensions, 1,
-	 "(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Point ioBounds) -> (Point ioBounds, SInt16 outBaseline)"},
+	 PyDoc_STR("(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Point ioBounds) -> (Point ioBounds, SInt16 outBaseline)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetThemeTextShadowOutset", (PyCFunction)App_GetThemeTextShadowOutset, 1,
-	 "(ThemeFontID inFontID, ThemeDrawState inState) -> (Rect outOutset)"},
+	 PyDoc_STR("(ThemeFontID inFontID, ThemeDrawState inState) -> (Rect outOutset)")},
 #endif
 	{"DrawThemeScrollBarArrows", (PyCFunction)App_DrawThemeScrollBarArrows, 1,
-	 "(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)"},
+	 PyDoc_STR("(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)")},
 	{"GetThemeScrollBarTrackRect", (PyCFunction)App_GetThemeScrollBarTrackRect, 1,
-	 "(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)"},
+	 PyDoc_STR("(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)")},
 	{"HitTestThemeScrollBarArrows", (PyCFunction)App_HitTestThemeScrollBarArrows, 1,
-	 "(Rect scrollBarBounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz, Point ptHit) -> (Boolean _rv, Rect trackBounds, ControlPartCode partcode)"},
+	 PyDoc_STR("(Rect scrollBarBounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz, Point ptHit) -> (Boolean _rv, Rect trackBounds, ControlPartCode partcode)")},
 	{"DrawThemeScrollBarDelimiters", (PyCFunction)App_DrawThemeScrollBarDelimiters, 1,
-	 "(ThemeWindowType flavor, Rect inContRect, ThemeDrawState state, ThemeWindowAttributes attributes) -> None"},
+	 PyDoc_STR("(ThemeWindowType flavor, Rect inContRect, ThemeDrawState state, ThemeWindowAttributes attributes) -> None")},
 	{"DrawThemeButton", (PyCFunction)App_DrawThemeButton, 1,
-	 "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo, ThemeButtonDrawInfo inPrevInfo, UInt32 inUserData) -> None"},
+	 PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo, ThemeButtonDrawInfo inPrevInfo, UInt32 inUserData) -> None")},
 	{"GetThemeButtonRegion", (PyCFunction)App_GetThemeButtonRegion, 1,
-	 "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo) -> None"},
+	 PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo) -> None")},
 	{"GetThemeButtonContentBounds", (PyCFunction)App_GetThemeButtonContentBounds, 1,
-	 "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)"},
+	 PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)")},
 	{"GetThemeButtonBackgroundBounds", (PyCFunction)App_GetThemeButtonBackgroundBounds, 1,
-	 "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)"},
+	 PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)")},
 	{"PlayThemeSound", (PyCFunction)App_PlayThemeSound, 1,
-	 "(ThemeSoundKind kind) -> None"},
+	 PyDoc_STR("(ThemeSoundKind kind) -> None")},
 	{"BeginThemeDragSound", (PyCFunction)App_BeginThemeDragSound, 1,
-	 "(ThemeDragSoundKind kind) -> None"},
+	 PyDoc_STR("(ThemeDragSoundKind kind) -> None")},
 	{"EndThemeDragSound", (PyCFunction)App_EndThemeDragSound, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DrawThemeTickMark", (PyCFunction)App_DrawThemeTickMark, 1,
-	 "(Rect bounds, ThemeDrawState state) -> None"},
+	 PyDoc_STR("(Rect bounds, ThemeDrawState state) -> None")},
 	{"DrawThemeChasingArrows", (PyCFunction)App_DrawThemeChasingArrows, 1,
-	 "(Rect bounds, UInt32 index, ThemeDrawState state, UInt32 eraseData) -> None"},
+	 PyDoc_STR("(Rect bounds, UInt32 index, ThemeDrawState state, UInt32 eraseData) -> None")},
 	{"DrawThemePopupArrow", (PyCFunction)App_DrawThemePopupArrow, 1,
-	 "(Rect bounds, ThemeArrowOrientation orientation, ThemePopupArrowSize size, ThemeDrawState state, UInt32 eraseData) -> None"},
+	 PyDoc_STR("(Rect bounds, ThemeArrowOrientation orientation, ThemePopupArrowSize size, ThemeDrawState state, UInt32 eraseData) -> None")},
 	{"DrawThemeStandaloneGrowBox", (PyCFunction)App_DrawThemeStandaloneGrowBox, 1,
-	 "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None"},
+	 PyDoc_STR("(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None")},
 	{"DrawThemeStandaloneNoGrowBox", (PyCFunction)App_DrawThemeStandaloneNoGrowBox, 1,
-	 "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None"},
+	 PyDoc_STR("(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None")},
 	{"GetThemeStandaloneGrowBoxBounds", (PyCFunction)App_GetThemeStandaloneGrowBoxBounds, 1,
-	 "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall) -> (Rect bounds)"},
+	 PyDoc_STR("(Point origin, ThemeGrowDirection growDirection, Boolean isSmall) -> (Rect bounds)")},
 	{"NormalizeThemeDrawingState", (PyCFunction)App_NormalizeThemeDrawingState, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetThemeDrawingState", (PyCFunction)App_GetThemeDrawingState, 1,
-	 "() -> (ThemeDrawingState outState)"},
+	 PyDoc_STR("() -> (ThemeDrawingState outState)")},
 	{"ApplyThemeBackground", (PyCFunction)App_ApplyThemeBackground, 1,
-	 "(ThemeBackgroundKind inKind, Rect bounds, ThemeDrawState inState, SInt16 inDepth, Boolean inColorDev) -> None"},
+	 PyDoc_STR("(ThemeBackgroundKind inKind, Rect bounds, ThemeDrawState inState, SInt16 inDepth, Boolean inColorDev) -> None")},
 	{"SetThemeTextColorForWindow", (PyCFunction)App_SetThemeTextColorForWindow, 1,
-	 "(WindowPtr window, Boolean isActive, SInt16 depth, Boolean isColorDev) -> None"},
+	 PyDoc_STR("(WindowPtr window, Boolean isActive, SInt16 depth, Boolean isColorDev) -> None")},
 	{"IsValidAppearanceFileType", (PyCFunction)App_IsValidAppearanceFileType, 1,
-	 "(OSType fileType) -> (Boolean _rv)"},
+	 PyDoc_STR("(OSType fileType) -> (Boolean _rv)")},
 	{"GetThemeBrushAsColor", (PyCFunction)App_GetThemeBrushAsColor, 1,
-	 "(ThemeBrush inBrush, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"},
+	 PyDoc_STR("(ThemeBrush inBrush, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)")},
 	{"GetThemeTextColor", (PyCFunction)App_GetThemeTextColor, 1,
-	 "(ThemeTextColor inColor, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"},
+	 PyDoc_STR("(ThemeTextColor inColor, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)")},
 
 #if TARGET_API_MAC_CARBON
 	{"GetThemeMetric", (PyCFunction)App_GetThemeMetric, 1,
-	 "(ThemeMetric inMetric) -> (SInt32 outMetric)"},
+	 PyDoc_STR("(ThemeMetric inMetric) -> (SInt32 outMetric)")},
 #endif
 	{NULL, NULL, 0}
 };
diff --git a/Mac/Modules/carbonevt/_CarbonEvtmodule.c b/Mac/Modules/carbonevt/_CarbonEvtmodule.c
index 5dce28b..9ef572c 100755
--- a/Mac/Modules/carbonevt/_CarbonEvtmodule.c
+++ b/Mac/Modules/carbonevt/_CarbonEvtmodule.c
@@ -380,31 +380,31 @@ static PyObject *EventRef_GetEventParameter(EventRefObject *_self, PyObject *_ar
 
 static PyMethodDef EventRef_methods[] = {
 	{"RetainEvent", (PyCFunction)EventRef_RetainEvent, 1,
-	 "() -> (EventRef _rv)"},
+	 PyDoc_STR("() -> (EventRef _rv)")},
 	{"GetEventRetainCount", (PyCFunction)EventRef_GetEventRetainCount, 1,
-	 "() -> (UInt32 _rv)"},
+	 PyDoc_STR("() -> (UInt32 _rv)")},
 	{"ReleaseEvent", (PyCFunction)EventRef_ReleaseEvent, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetEventParameter", (PyCFunction)EventRef_SetEventParameter, 1,
-	 "(OSType inName, OSType inType, Buffer inDataPtr) -> None"},
+	 PyDoc_STR("(OSType inName, OSType inType, Buffer inDataPtr) -> None")},
 	{"GetEventClass", (PyCFunction)EventRef_GetEventClass, 1,
-	 "() -> (UInt32 _rv)"},
+	 PyDoc_STR("() -> (UInt32 _rv)")},
 	{"GetEventKind", (PyCFunction)EventRef_GetEventKind, 1,
-	 "() -> (UInt32 _rv)"},
+	 PyDoc_STR("() -> (UInt32 _rv)")},
 	{"GetEventTime", (PyCFunction)EventRef_GetEventTime, 1,
-	 "() -> (double _rv)"},
+	 PyDoc_STR("() -> (double _rv)")},
 	{"SetEventTime", (PyCFunction)EventRef_SetEventTime, 1,
-	 "(double inTime) -> None"},
+	 PyDoc_STR("(double inTime) -> None")},
 	{"IsUserCancelEventRef", (PyCFunction)EventRef_IsUserCancelEventRef, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"ConvertEventRefToEventRecord", (PyCFunction)EventRef_ConvertEventRefToEventRecord, 1,
-	 "() -> (Boolean _rv, EventRecord outEvent)"},
+	 PyDoc_STR("() -> (Boolean _rv, EventRecord outEvent)")},
 	{"IsEventInMask", (PyCFunction)EventRef_IsEventInMask, 1,
-	 "(UInt16 inMask) -> (Boolean _rv)"},
+	 PyDoc_STR("(UInt16 inMask) -> (Boolean _rv)")},
 	{"SendEventToEventTarget", (PyCFunction)EventRef_SendEventToEventTarget, 1,
-	 "(EventTargetRef inTarget) -> None"},
+	 PyDoc_STR("(EventTargetRef inTarget) -> None")},
 	{"GetEventParameter", (PyCFunction)EventRef_GetEventParameter, 1,
-	 "(EventParamName eventName, EventParamType eventType) -> (String eventParamData)"},
+	 PyDoc_STR("(EventParamName eventName, EventParamType eventType) -> (String eventParamData)")},
 	{NULL, NULL, 0}
 };
 
@@ -577,17 +577,17 @@ static PyObject *EventQueueRef_IsEventInQueue(EventQueueRefObject *_self, PyObje
 
 static PyMethodDef EventQueueRef_methods[] = {
 	{"PostEventToQueue", (PyCFunction)EventQueueRef_PostEventToQueue, 1,
-	 "(EventRef inEvent, SInt16 inPriority) -> None"},
+	 PyDoc_STR("(EventRef inEvent, SInt16 inPriority) -> None")},
 	{"FlushEventsMatchingListFromQueue", (PyCFunction)EventQueueRef_FlushEventsMatchingListFromQueue, 1,
-	 "(UInt32 inNumTypes, EventTypeSpec inList) -> None"},
+	 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
 	{"FlushEventQueue", (PyCFunction)EventQueueRef_FlushEventQueue, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetNumEventsInQueue", (PyCFunction)EventQueueRef_GetNumEventsInQueue, 1,
-	 "() -> (UInt32 _rv)"},
+	 PyDoc_STR("() -> (UInt32 _rv)")},
 	{"RemoveEventFromQueue", (PyCFunction)EventQueueRef_RemoveEventFromQueue, 1,
-	 "(EventRef inEvent) -> None"},
+	 PyDoc_STR("(EventRef inEvent) -> None")},
 	{"IsEventInQueue", (PyCFunction)EventQueueRef_IsEventInQueue, 1,
-	 "(EventRef inEvent) -> (Boolean _rv)"},
+	 PyDoc_STR("(EventRef inEvent) -> (Boolean _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -679,7 +679,7 @@ static PyObject *EventLoopRef_QuitEventLoop(EventLoopRefObject *_self, PyObject
 
 static PyMethodDef EventLoopRef_methods[] = {
 	{"QuitEventLoop", (PyCFunction)EventLoopRef_QuitEventLoop, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -787,9 +787,9 @@ static PyObject *EventLoopTimerRef_SetEventLoopTimerNextFireTime(EventLoopTimerR
 
 static PyMethodDef EventLoopTimerRef_methods[] = {
 	{"RemoveEventLoopTimer", (PyCFunction)EventLoopTimerRef_RemoveEventLoopTimer, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetEventLoopTimerNextFireTime", (PyCFunction)EventLoopTimerRef_SetEventLoopTimerNextFireTime, 1,
-	 "(double inNextFire) -> None"},
+	 PyDoc_STR("(double inNextFire) -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -940,11 +940,11 @@ static PyObject *EventHandlerRef_RemoveEventHandler(EventHandlerRefObject *_self
 
 static PyMethodDef EventHandlerRef_methods[] = {
 	{"AddEventTypesToHandler", (PyCFunction)EventHandlerRef_AddEventTypesToHandler, 1,
-	 "(UInt32 inNumTypes, EventTypeSpec inList) -> None"},
+	 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
 	{"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1,
-	 "(UInt32 inNumTypes, EventTypeSpec inList) -> None"},
+	 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
 	{"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -1039,7 +1039,7 @@ static PyObject *EventHandlerCallRef_CallNextEventHandler(EventHandlerCallRefObj
 
 static PyMethodDef EventHandlerCallRef_methods[] = {
 	{"CallNextEventHandler", (PyCFunction)EventHandlerCallRef_CallNextEventHandler, 1,
-	 "(EventRef inEvent) -> None"},
+	 PyDoc_STR("(EventRef inEvent) -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -1154,9 +1154,9 @@ static PyObject *EventTargetRef_InstallEventHandler(EventTargetRefObject *_self,
 
 static PyMethodDef EventTargetRef_methods[] = {
 	{"InstallStandardEventHandler", (PyCFunction)EventTargetRef_InstallStandardEventHandler, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"InstallEventHandler", (PyCFunction)EventTargetRef_InstallEventHandler, 1,
-	 "(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)"},
+	 PyDoc_STR("(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)")},
 	{NULL, NULL, 0}
 };
 
@@ -1248,7 +1248,7 @@ static PyObject *EventHotKeyRef_UnregisterEventHotKey(EventHotKeyRefObject *_sel
 
 static PyMethodDef EventHotKeyRef_methods[] = {
 	{"UnregisterEventHotKey", (PyCFunction)EventHotKeyRef_UnregisterEventHotKey, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -1778,65 +1778,65 @@ static PyObject *CarbonEvents_RunApplicationEventLoop(PyObject *_self, PyObject
 
 static PyMethodDef CarbonEvents_methods[] = {
 	{"GetCurrentEventLoop", (PyCFunction)CarbonEvents_GetCurrentEventLoop, 1,
-	 "() -> (EventLoopRef _rv)"},
+	 PyDoc_STR("() -> (EventLoopRef _rv)")},
 	{"GetMainEventLoop", (PyCFunction)CarbonEvents_GetMainEventLoop, 1,
-	 "() -> (EventLoopRef _rv)"},
+	 PyDoc_STR("() -> (EventLoopRef _rv)")},
 	{"RunCurrentEventLoop", (PyCFunction)CarbonEvents_RunCurrentEventLoop, 1,
-	 "(double inTimeout) -> None"},
+	 PyDoc_STR("(double inTimeout) -> None")},
 	{"ReceiveNextEvent", (PyCFunction)CarbonEvents_ReceiveNextEvent, 1,
-	 "(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)"},
+	 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)")},
 	{"GetCurrentEventQueue", (PyCFunction)CarbonEvents_GetCurrentEventQueue, 1,
-	 "() -> (EventQueueRef _rv)"},
+	 PyDoc_STR("() -> (EventQueueRef _rv)")},
 	{"GetMainEventQueue", (PyCFunction)CarbonEvents_GetMainEventQueue, 1,
-	 "() -> (EventQueueRef _rv)"},
+	 PyDoc_STR("() -> (EventQueueRef _rv)")},
 	{"GetCurrentEventTime", (PyCFunction)CarbonEvents_GetCurrentEventTime, 1,
-	 "() -> (double _rv)"},
+	 PyDoc_STR("() -> (double _rv)")},
 	{"TrackMouseLocation", (PyCFunction)CarbonEvents_TrackMouseLocation, 1,
-	 "(GrafPtr inPort) -> (Point outPt, UInt16 outResult)"},
+	 PyDoc_STR("(GrafPtr inPort) -> (Point outPt, UInt16 outResult)")},
 	{"TrackMouseLocationWithOptions", (PyCFunction)CarbonEvents_TrackMouseLocationWithOptions, 1,
-	 "(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)"},
+	 PyDoc_STR("(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)")},
 	{"TrackMouseRegion", (PyCFunction)CarbonEvents_TrackMouseRegion, 1,
-	 "(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)"},
+	 PyDoc_STR("(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)")},
 	{"GetLastUserEventTime", (PyCFunction)CarbonEvents_GetLastUserEventTime, 1,
-	 "() -> (double _rv)"},
+	 PyDoc_STR("() -> (double _rv)")},
 	{"GetWindowEventTarget", (PyCFunction)CarbonEvents_GetWindowEventTarget, 1,
-	 "(WindowPtr inWindow) -> (EventTargetRef _rv)"},
+	 PyDoc_STR("(WindowPtr inWindow) -> (EventTargetRef _rv)")},
 	{"GetControlEventTarget", (PyCFunction)CarbonEvents_GetControlEventTarget, 1,
-	 "(ControlHandle inControl) -> (EventTargetRef _rv)"},
+	 PyDoc_STR("(ControlHandle inControl) -> (EventTargetRef _rv)")},
 	{"GetMenuEventTarget", (PyCFunction)CarbonEvents_GetMenuEventTarget, 1,
-	 "(MenuHandle inMenu) -> (EventTargetRef _rv)"},
+	 PyDoc_STR("(MenuHandle inMenu) -> (EventTargetRef _rv)")},
 	{"GetApplicationEventTarget", (PyCFunction)CarbonEvents_GetApplicationEventTarget, 1,
-	 "() -> (EventTargetRef _rv)"},
+	 PyDoc_STR("() -> (EventTargetRef _rv)")},
 	{"GetUserFocusEventTarget", (PyCFunction)CarbonEvents_GetUserFocusEventTarget, 1,
-	 "() -> (EventTargetRef _rv)"},
+	 PyDoc_STR("() -> (EventTargetRef _rv)")},
 	{"GetEventDispatcherTarget", (PyCFunction)CarbonEvents_GetEventDispatcherTarget, 1,
-	 "() -> (EventTargetRef _rv)"},
+	 PyDoc_STR("() -> (EventTargetRef _rv)")},
 	{"QuitApplicationEventLoop", (PyCFunction)CarbonEvents_QuitApplicationEventLoop, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"RunAppModalLoopForWindow", (PyCFunction)CarbonEvents_RunAppModalLoopForWindow, 1,
-	 "(WindowPtr inWindow) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow) -> None")},
 	{"QuitAppModalLoopForWindow", (PyCFunction)CarbonEvents_QuitAppModalLoopForWindow, 1,
-	 "(WindowPtr inWindow) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow) -> None")},
 	{"BeginAppModalStateForWindow", (PyCFunction)CarbonEvents_BeginAppModalStateForWindow, 1,
-	 "(WindowPtr inWindow) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow) -> None")},
 	{"EndAppModalStateForWindow", (PyCFunction)CarbonEvents_EndAppModalStateForWindow, 1,
-	 "(WindowPtr inWindow) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow) -> None")},
 	{"SetUserFocusWindow", (PyCFunction)CarbonEvents_SetUserFocusWindow, 1,
-	 "(WindowPtr inWindow) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow) -> None")},
 	{"GetUserFocusWindow", (PyCFunction)CarbonEvents_GetUserFocusWindow, 1,
-	 "() -> (WindowPtr _rv)"},
+	 PyDoc_STR("() -> (WindowPtr _rv)")},
 	{"SetWindowDefaultButton", (PyCFunction)CarbonEvents_SetWindowDefaultButton, 1,
-	 "(WindowPtr inWindow, ControlHandle inControl) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
 	{"SetWindowCancelButton", (PyCFunction)CarbonEvents_SetWindowCancelButton, 1,
-	 "(WindowPtr inWindow, ControlHandle inControl) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
 	{"GetWindowDefaultButton", (PyCFunction)CarbonEvents_GetWindowDefaultButton, 1,
-	 "(WindowPtr inWindow) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
 	{"GetWindowCancelButton", (PyCFunction)CarbonEvents_GetWindowCancelButton, 1,
-	 "(WindowPtr inWindow) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
 	{"RegisterEventHotKey", (PyCFunction)CarbonEvents_RegisterEventHotKey, 1,
-	 "(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)"},
+	 PyDoc_STR("(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)")},
 	{"RunApplicationEventLoop", (PyCFunction)CarbonEvents_RunApplicationEventLoop, 1,
-	 "() -> ()"},
+	 PyDoc_STR("() -> ()")},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/cf/_CFmodule.c b/Mac/Modules/cf/_CFmodule.c
index eb3f3f6..2942082 100644
--- a/Mac/Modules/cf/_CFmodule.c
+++ b/Mac/Modules/cf/_CFmodule.c
@@ -360,29 +360,29 @@ static PyObject *CFTypeRefObj_toPython(CFTypeRefObject *_self, PyObject *_args)
 
 static PyMethodDef CFTypeRefObj_methods[] = {
 	{"CFGetTypeID", (PyCFunction)CFTypeRefObj_CFGetTypeID, 1,
-	 "() -> (CFTypeID _rv)"},
+	 PyDoc_STR("() -> (CFTypeID _rv)")},
 	{"CFRetain", (PyCFunction)CFTypeRefObj_CFRetain, 1,
-	 "() -> (CFTypeRef _rv)"},
+	 PyDoc_STR("() -> (CFTypeRef _rv)")},
 	{"CFRelease", (PyCFunction)CFTypeRefObj_CFRelease, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CFGetRetainCount", (PyCFunction)CFTypeRefObj_CFGetRetainCount, 1,
-	 "() -> (CFIndex _rv)"},
+	 PyDoc_STR("() -> (CFIndex _rv)")},
 	{"CFEqual", (PyCFunction)CFTypeRefObj_CFEqual, 1,
-	 "(CFTypeRef cf2) -> (Boolean _rv)"},
+	 PyDoc_STR("(CFTypeRef cf2) -> (Boolean _rv)")},
 	{"CFHash", (PyCFunction)CFTypeRefObj_CFHash, 1,
-	 "() -> (CFHashCode _rv)"},
+	 PyDoc_STR("() -> (CFHashCode _rv)")},
 	{"CFCopyDescription", (PyCFunction)CFTypeRefObj_CFCopyDescription, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFPropertyListCreateXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateXMLData, 1,
-	 "() -> (CFDataRef _rv)"},
+	 PyDoc_STR("() -> (CFDataRef _rv)")},
 	{"CFPropertyListCreateDeepCopy", (PyCFunction)CFTypeRefObj_CFPropertyListCreateDeepCopy, 1,
-	 "(CFOptionFlags mutabilityOption) -> (CFTypeRef _rv)"},
+	 PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRef _rv)")},
 	{"CFShow", (PyCFunction)CFTypeRefObj_CFShow, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CFPropertyListCreateFromXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateFromXMLData, 1,
-	 "(CFOptionFlags mutabilityOption) -> (CFTypeRefObj)"},
+	 PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRefObj)")},
 	{"toPython", (PyCFunction)CFTypeRefObj_toPython, 1,
-	 "() -> (python_object)"},
+	 PyDoc_STR("() -> (python_object)")},
 	{NULL, NULL, 0}
 };
 
@@ -534,11 +534,11 @@ static PyObject *CFArrayRefObj_CFStringCreateByCombiningStrings(CFArrayRefObject
 
 static PyMethodDef CFArrayRefObj_methods[] = {
 	{"CFArrayCreateCopy", (PyCFunction)CFArrayRefObj_CFArrayCreateCopy, 1,
-	 "() -> (CFArrayRef _rv)"},
+	 PyDoc_STR("() -> (CFArrayRef _rv)")},
 	{"CFArrayGetCount", (PyCFunction)CFArrayRefObj_CFArrayGetCount, 1,
-	 "() -> (CFIndex _rv)"},
+	 PyDoc_STR("() -> (CFIndex _rv)")},
 	{"CFStringCreateByCombiningStrings", (PyCFunction)CFArrayRefObj_CFStringCreateByCombiningStrings, 1,
-	 "(CFStringRef separatorString) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFStringRef separatorString) -> (CFStringRef _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -717,13 +717,13 @@ static PyObject *CFMutableArrayRefObj_CFArrayAppendArray(CFMutableArrayRefObject
 
 static PyMethodDef CFMutableArrayRefObj_methods[] = {
 	{"CFArrayRemoveValueAtIndex", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveValueAtIndex, 1,
-	 "(CFIndex idx) -> None"},
+	 PyDoc_STR("(CFIndex idx) -> None")},
 	{"CFArrayRemoveAllValues", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveAllValues, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CFArrayExchangeValuesAtIndices", (PyCFunction)CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices, 1,
-	 "(CFIndex idx1, CFIndex idx2) -> None"},
+	 PyDoc_STR("(CFIndex idx1, CFIndex idx2) -> None")},
 	{"CFArrayAppendArray", (PyCFunction)CFMutableArrayRefObj_CFArrayAppendArray, 1,
-	 "(CFArrayRef otherArray, CFRange otherRange) -> None"},
+	 PyDoc_STR("(CFArrayRef otherArray, CFRange otherRange) -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -859,9 +859,9 @@ static PyObject *CFDictionaryRefObj_CFDictionaryGetCount(CFDictionaryRefObject *
 
 static PyMethodDef CFDictionaryRefObj_methods[] = {
 	{"CFDictionaryCreateCopy", (PyCFunction)CFDictionaryRefObj_CFDictionaryCreateCopy, 1,
-	 "() -> (CFDictionaryRef _rv)"},
+	 PyDoc_STR("() -> (CFDictionaryRef _rv)")},
 	{"CFDictionaryGetCount", (PyCFunction)CFDictionaryRefObj_CFDictionaryGetCount, 1,
-	 "() -> (CFIndex _rv)"},
+	 PyDoc_STR("() -> (CFIndex _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -983,7 +983,7 @@ static PyObject *CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues(CFMutable
 
 static PyMethodDef CFMutableDictionaryRefObj_methods[] = {
 	{"CFDictionaryRemoveAllValues", (PyCFunction)CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -1153,13 +1153,13 @@ static PyObject *CFDataRefObj_CFDataGetData(CFDataRefObject *_self, PyObject *_a
 
 static PyMethodDef CFDataRefObj_methods[] = {
 	{"CFDataCreateCopy", (PyCFunction)CFDataRefObj_CFDataCreateCopy, 1,
-	 "() -> (CFDataRef _rv)"},
+	 PyDoc_STR("() -> (CFDataRef _rv)")},
 	{"CFDataGetLength", (PyCFunction)CFDataRefObj_CFDataGetLength, 1,
-	 "() -> (CFIndex _rv)"},
+	 PyDoc_STR("() -> (CFIndex _rv)")},
 	{"CFStringCreateFromExternalRepresentation", (PyCFunction)CFDataRefObj_CFStringCreateFromExternalRepresentation, 1,
-	 "(CFStringEncoding encoding) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")},
 	{"CFDataGetData", (PyCFunction)CFDataRefObj_CFDataGetData, 1,
-	 "() -> (string _rv)"},
+	 PyDoc_STR("() -> (string _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -1361,15 +1361,15 @@ static PyObject *CFMutableDataRefObj_CFDataDeleteBytes(CFMutableDataRefObject *_
 
 static PyMethodDef CFMutableDataRefObj_methods[] = {
 	{"CFDataSetLength", (PyCFunction)CFMutableDataRefObj_CFDataSetLength, 1,
-	 "(CFIndex length) -> None"},
+	 PyDoc_STR("(CFIndex length) -> None")},
 	{"CFDataIncreaseLength", (PyCFunction)CFMutableDataRefObj_CFDataIncreaseLength, 1,
-	 "(CFIndex extraLength) -> None"},
+	 PyDoc_STR("(CFIndex extraLength) -> None")},
 	{"CFDataAppendBytes", (PyCFunction)CFMutableDataRefObj_CFDataAppendBytes, 1,
-	 "(Buffer bytes) -> None"},
+	 PyDoc_STR("(Buffer bytes) -> None")},
 	{"CFDataReplaceBytes", (PyCFunction)CFMutableDataRefObj_CFDataReplaceBytes, 1,
-	 "(CFRange range, Buffer newBytes) -> None"},
+	 PyDoc_STR("(CFRange range, Buffer newBytes) -> None")},
 	{"CFDataDeleteBytes", (PyCFunction)CFMutableDataRefObj_CFDataDeleteBytes, 1,
-	 "(CFRange range) -> None"},
+	 PyDoc_STR("(CFRange range) -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -2002,59 +2002,59 @@ static PyObject *CFStringRefObj_CFStringGetUnicode(CFStringRefObject *_self, PyO
 
 static PyMethodDef CFStringRefObj_methods[] = {
 	{"CFStringCreateWithSubstring", (PyCFunction)CFStringRefObj_CFStringCreateWithSubstring, 1,
-	 "(CFRange range) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFRange range) -> (CFStringRef _rv)")},
 	{"CFStringCreateCopy", (PyCFunction)CFStringRefObj_CFStringCreateCopy, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFStringGetLength", (PyCFunction)CFStringRefObj_CFStringGetLength, 1,
-	 "() -> (CFIndex _rv)"},
+	 PyDoc_STR("() -> (CFIndex _rv)")},
 	{"CFStringGetBytes", (PyCFunction)CFStringRefObj_CFStringGetBytes, 1,
-	 "(CFRange range, CFStringEncoding encoding, UInt8 lossByte, Boolean isExternalRepresentation, CFIndex maxBufLen) -> (CFIndex _rv, UInt8 buffer, CFIndex usedBufLen)"},
+	 PyDoc_STR("(CFRange range, CFStringEncoding encoding, UInt8 lossByte, Boolean isExternalRepresentation, CFIndex maxBufLen) -> (CFIndex _rv, UInt8 buffer, CFIndex usedBufLen)")},
 	{"CFStringCreateExternalRepresentation", (PyCFunction)CFStringRefObj_CFStringCreateExternalRepresentation, 1,
-	 "(CFStringEncoding encoding, UInt8 lossByte) -> (CFDataRef _rv)"},
+	 PyDoc_STR("(CFStringEncoding encoding, UInt8 lossByte) -> (CFDataRef _rv)")},
 	{"CFStringGetSmallestEncoding", (PyCFunction)CFStringRefObj_CFStringGetSmallestEncoding, 1,
-	 "() -> (CFStringEncoding _rv)"},
+	 PyDoc_STR("() -> (CFStringEncoding _rv)")},
 	{"CFStringGetFastestEncoding", (PyCFunction)CFStringRefObj_CFStringGetFastestEncoding, 1,
-	 "() -> (CFStringEncoding _rv)"},
+	 PyDoc_STR("() -> (CFStringEncoding _rv)")},
 	{"CFStringCompareWithOptions", (PyCFunction)CFStringRefObj_CFStringCompareWithOptions, 1,
-	 "(CFStringRef theString2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"},
+	 PyDoc_STR("(CFStringRef theString2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")},
 	{"CFStringCompare", (PyCFunction)CFStringRefObj_CFStringCompare, 1,
-	 "(CFStringRef theString2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"},
+	 PyDoc_STR("(CFStringRef theString2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")},
 	{"CFStringFindWithOptions", (PyCFunction)CFStringRefObj_CFStringFindWithOptions, 1,
-	 "(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)"},
+	 PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)")},
 	{"CFStringCreateArrayWithFindResults", (PyCFunction)CFStringRefObj_CFStringCreateArrayWithFindResults, 1,
-	 "(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) -> (CFArrayRef _rv)"},
+	 PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) -> (CFArrayRef _rv)")},
 	{"CFStringFind", (PyCFunction)CFStringRefObj_CFStringFind, 1,
-	 "(CFStringRef stringToFind, CFOptionFlags compareOptions) -> (CFRange _rv)"},
+	 PyDoc_STR("(CFStringRef stringToFind, CFOptionFlags compareOptions) -> (CFRange _rv)")},
 	{"CFStringHasPrefix", (PyCFunction)CFStringRefObj_CFStringHasPrefix, 1,
-	 "(CFStringRef prefix) -> (Boolean _rv)"},
+	 PyDoc_STR("(CFStringRef prefix) -> (Boolean _rv)")},
 	{"CFStringHasSuffix", (PyCFunction)CFStringRefObj_CFStringHasSuffix, 1,
-	 "(CFStringRef suffix) -> (Boolean _rv)"},
+	 PyDoc_STR("(CFStringRef suffix) -> (Boolean _rv)")},
 	{"CFStringGetLineBounds", (PyCFunction)CFStringRefObj_CFStringGetLineBounds, 1,
-	 "(CFRange range) -> (CFIndex lineBeginIndex, CFIndex lineEndIndex, CFIndex contentsEndIndex)"},
+	 PyDoc_STR("(CFRange range) -> (CFIndex lineBeginIndex, CFIndex lineEndIndex, CFIndex contentsEndIndex)")},
 	{"CFStringCreateArrayBySeparatingStrings", (PyCFunction)CFStringRefObj_CFStringCreateArrayBySeparatingStrings, 1,
-	 "(CFStringRef separatorString) -> (CFArrayRef _rv)"},
+	 PyDoc_STR("(CFStringRef separatorString) -> (CFArrayRef _rv)")},
 	{"CFStringGetIntValue", (PyCFunction)CFStringRefObj_CFStringGetIntValue, 1,
-	 "() -> (SInt32 _rv)"},
+	 PyDoc_STR("() -> (SInt32 _rv)")},
 	{"CFStringGetDoubleValue", (PyCFunction)CFStringRefObj_CFStringGetDoubleValue, 1,
-	 "() -> (double _rv)"},
+	 PyDoc_STR("() -> (double _rv)")},
 	{"CFStringConvertIANACharSetNameToEncoding", (PyCFunction)CFStringRefObj_CFStringConvertIANACharSetNameToEncoding, 1,
-	 "() -> (CFStringEncoding _rv)"},
+	 PyDoc_STR("() -> (CFStringEncoding _rv)")},
 	{"CFShowStr", (PyCFunction)CFStringRefObj_CFShowStr, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CFURLCreateWithString", (PyCFunction)CFStringRefObj_CFURLCreateWithString, 1,
-	 "(CFURLRef baseURL) -> (CFURLRef _rv)"},
+	 PyDoc_STR("(CFURLRef baseURL) -> (CFURLRef _rv)")},
 	{"CFURLCreateWithFileSystemPath", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPath, 1,
-	 "(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)"},
+	 PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)")},
 	{"CFURLCreateWithFileSystemPathRelativeToBase", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase, 1,
-	 "(CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)"},
+	 PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")},
 	{"CFURLCreateStringByReplacingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes, 1,
-	 "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
 	{"CFURLCreateStringByAddingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByAddingPercentEscapes, 1,
-	 "(CFStringRef charactersToLeaveUnescaped, CFStringRef legalURLCharactersToBeEscaped, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFStringRef charactersToLeaveUnescaped, CFStringRef legalURLCharactersToBeEscaped, CFStringEncoding encoding) -> (CFStringRef _rv)")},
 	{"CFStringGetString", (PyCFunction)CFStringRefObj_CFStringGetString, 1,
-	 "() -> (string _rv)"},
+	 PyDoc_STR("() -> (string _rv)")},
 	{"CFStringGetUnicode", (PyCFunction)CFStringRefObj_CFStringGetUnicode, 1,
-	 "() -> (unicode _rv)"},
+	 PyDoc_STR("() -> (unicode _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -2367,27 +2367,27 @@ static PyObject *CFMutableStringRefObj_CFStringTrimWhitespace(CFMutableStringRef
 
 static PyMethodDef CFMutableStringRefObj_methods[] = {
 	{"CFStringAppend", (PyCFunction)CFMutableStringRefObj_CFStringAppend, 1,
-	 "(CFStringRef appendedString) -> None"},
+	 PyDoc_STR("(CFStringRef appendedString) -> None")},
 	{"CFStringAppendCharacters", (PyCFunction)CFMutableStringRefObj_CFStringAppendCharacters, 1,
-	 "(Buffer chars) -> None"},
+	 PyDoc_STR("(Buffer chars) -> None")},
 	{"CFStringAppendPascalString", (PyCFunction)CFMutableStringRefObj_CFStringAppendPascalString, 1,
-	 "(Str255 pStr, CFStringEncoding encoding) -> None"},
+	 PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> None")},
 	{"CFStringAppendCString", (PyCFunction)CFMutableStringRefObj_CFStringAppendCString, 1,
-	 "(char* cStr, CFStringEncoding encoding) -> None"},
+	 PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> None")},
 	{"CFStringInsert", (PyCFunction)CFMutableStringRefObj_CFStringInsert, 1,
-	 "(CFIndex idx, CFStringRef insertedStr) -> None"},
+	 PyDoc_STR("(CFIndex idx, CFStringRef insertedStr) -> None")},
 	{"CFStringDelete", (PyCFunction)CFMutableStringRefObj_CFStringDelete, 1,
-	 "(CFRange range) -> None"},
+	 PyDoc_STR("(CFRange range) -> None")},
 	{"CFStringReplace", (PyCFunction)CFMutableStringRefObj_CFStringReplace, 1,
-	 "(CFRange range, CFStringRef replacement) -> None"},
+	 PyDoc_STR("(CFRange range, CFStringRef replacement) -> None")},
 	{"CFStringReplaceAll", (PyCFunction)CFMutableStringRefObj_CFStringReplaceAll, 1,
-	 "(CFStringRef replacement) -> None"},
+	 PyDoc_STR("(CFStringRef replacement) -> None")},
 	{"CFStringPad", (PyCFunction)CFMutableStringRefObj_CFStringPad, 1,
-	 "(CFStringRef padString, CFIndex length, CFIndex indexIntoPad) -> None"},
+	 PyDoc_STR("(CFStringRef padString, CFIndex length, CFIndex indexIntoPad) -> None")},
 	{"CFStringTrim", (PyCFunction)CFMutableStringRefObj_CFStringTrim, 1,
-	 "(CFStringRef trimString) -> None"},
+	 PyDoc_STR("(CFStringRef trimString) -> None")},
 	{"CFStringTrimWhitespace", (PyCFunction)CFMutableStringRefObj_CFStringTrimWhitespace, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -2932,59 +2932,59 @@ static PyObject *CFURLRefObj_CFURLGetFSRef(CFURLRefObject *_self, PyObject *_arg
 
 static PyMethodDef CFURLRefObj_methods[] = {
 	{"CFURLCreateData", (PyCFunction)CFURLRefObj_CFURLCreateData, 1,
-	 "(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)"},
+	 PyDoc_STR("(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)")},
 	{"CFURLGetFileSystemRepresentation", (PyCFunction)CFURLRefObj_CFURLGetFileSystemRepresentation, 1,
-	 "(Boolean resolveAgainstBase, CFIndex maxBufLen) -> (Boolean _rv, UInt8 buffer)"},
+	 PyDoc_STR("(Boolean resolveAgainstBase, CFIndex maxBufLen) -> (Boolean _rv, UInt8 buffer)")},
 	{"CFURLCopyAbsoluteURL", (PyCFunction)CFURLRefObj_CFURLCopyAbsoluteURL, 1,
-	 "() -> (CFURLRef _rv)"},
+	 PyDoc_STR("() -> (CFURLRef _rv)")},
 	{"CFURLGetString", (PyCFunction)CFURLRefObj_CFURLGetString, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFURLGetBaseURL", (PyCFunction)CFURLRefObj_CFURLGetBaseURL, 1,
-	 "() -> (CFURLRef _rv)"},
+	 PyDoc_STR("() -> (CFURLRef _rv)")},
 	{"CFURLCanBeDecomposed", (PyCFunction)CFURLRefObj_CFURLCanBeDecomposed, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"CFURLCopyScheme", (PyCFunction)CFURLRefObj_CFURLCopyScheme, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFURLCopyNetLocation", (PyCFunction)CFURLRefObj_CFURLCopyNetLocation, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFURLCopyPath", (PyCFunction)CFURLRefObj_CFURLCopyPath, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFURLCopyStrictPath", (PyCFunction)CFURLRefObj_CFURLCopyStrictPath, 1,
-	 "() -> (CFStringRef _rv, Boolean isAbsolute)"},
+	 PyDoc_STR("() -> (CFStringRef _rv, Boolean isAbsolute)")},
 	{"CFURLCopyFileSystemPath", (PyCFunction)CFURLRefObj_CFURLCopyFileSystemPath, 1,
-	 "(CFURLPathStyle pathStyle) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFURLPathStyle pathStyle) -> (CFStringRef _rv)")},
 	{"CFURLHasDirectoryPath", (PyCFunction)CFURLRefObj_CFURLHasDirectoryPath, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"CFURLCopyResourceSpecifier", (PyCFunction)CFURLRefObj_CFURLCopyResourceSpecifier, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFURLCopyHostName", (PyCFunction)CFURLRefObj_CFURLCopyHostName, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFURLGetPortNumber", (PyCFunction)CFURLRefObj_CFURLGetPortNumber, 1,
-	 "() -> (SInt32 _rv)"},
+	 PyDoc_STR("() -> (SInt32 _rv)")},
 	{"CFURLCopyUserName", (PyCFunction)CFURLRefObj_CFURLCopyUserName, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFURLCopyPassword", (PyCFunction)CFURLRefObj_CFURLCopyPassword, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFURLCopyParameterString", (PyCFunction)CFURLRefObj_CFURLCopyParameterString, 1,
-	 "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
 	{"CFURLCopyQueryString", (PyCFunction)CFURLRefObj_CFURLCopyQueryString, 1,
-	 "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
 	{"CFURLCopyFragment", (PyCFunction)CFURLRefObj_CFURLCopyFragment, 1,
-	 "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
 	{"CFURLCopyLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCopyLastPathComponent, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFURLCopyPathExtension", (PyCFunction)CFURLRefObj_CFURLCopyPathExtension, 1,
-	 "() -> (CFStringRef _rv)"},
+	 PyDoc_STR("() -> (CFStringRef _rv)")},
 	{"CFURLCreateCopyAppendingPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathComponent, 1,
-	 "(CFStringRef pathComponent, Boolean isDirectory) -> (CFURLRef _rv)"},
+	 PyDoc_STR("(CFStringRef pathComponent, Boolean isDirectory) -> (CFURLRef _rv)")},
 	{"CFURLCreateCopyDeletingLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent, 1,
-	 "() -> (CFURLRef _rv)"},
+	 PyDoc_STR("() -> (CFURLRef _rv)")},
 	{"CFURLCreateCopyAppendingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathExtension, 1,
-	 "(CFStringRef extension) -> (CFURLRef _rv)"},
+	 PyDoc_STR("(CFStringRef extension) -> (CFURLRef _rv)")},
 	{"CFURLCreateCopyDeletingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingPathExtension, 1,
-	 "() -> (CFURLRef _rv)"},
+	 PyDoc_STR("() -> (CFURLRef _rv)")},
 	{"CFURLGetFSRef", (PyCFunction)CFURLRefObj_CFURLGetFSRef, 1,
-	 "() -> (Boolean _rv, FSRef fsRef)"},
+	 PyDoc_STR("() -> (Boolean _rv, FSRef fsRef)")},
 	{NULL, NULL, 0}
 };
 
@@ -4173,117 +4173,117 @@ static PyObject *CF_toCF(PyObject *_self, PyObject *_args)
 
 static PyMethodDef CF_methods[] = {
 	{"__CFRangeMake", (PyCFunction)CF___CFRangeMake, 1,
-	 "(CFIndex loc, CFIndex len) -> (CFRange _rv)"},
+	 PyDoc_STR("(CFIndex loc, CFIndex len) -> (CFRange _rv)")},
 	{"CFAllocatorGetTypeID", (PyCFunction)CF_CFAllocatorGetTypeID, 1,
-	 "() -> (CFTypeID _rv)"},
+	 PyDoc_STR("() -> (CFTypeID _rv)")},
 	{"CFAllocatorGetPreferredSizeForSize", (PyCFunction)CF_CFAllocatorGetPreferredSizeForSize, 1,
-	 "(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)"},
+	 PyDoc_STR("(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)")},
 	{"CFCopyTypeIDDescription", (PyCFunction)CF_CFCopyTypeIDDescription, 1,
-	 "(CFTypeID type_id) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFTypeID type_id) -> (CFStringRef _rv)")},
 	{"CFArrayGetTypeID", (PyCFunction)CF_CFArrayGetTypeID, 1,
-	 "() -> (CFTypeID _rv)"},
+	 PyDoc_STR("() -> (CFTypeID _rv)")},
 	{"CFArrayCreateMutable", (PyCFunction)CF_CFArrayCreateMutable, 1,
-	 "(CFIndex capacity) -> (CFMutableArrayRef _rv)"},
+	 PyDoc_STR("(CFIndex capacity) -> (CFMutableArrayRef _rv)")},
 	{"CFArrayCreateMutableCopy", (PyCFunction)CF_CFArrayCreateMutableCopy, 1,
-	 "(CFIndex capacity, CFArrayRef theArray) -> (CFMutableArrayRef _rv)"},
+	 PyDoc_STR("(CFIndex capacity, CFArrayRef theArray) -> (CFMutableArrayRef _rv)")},
 	{"CFDataGetTypeID", (PyCFunction)CF_CFDataGetTypeID, 1,
-	 "() -> (CFTypeID _rv)"},
+	 PyDoc_STR("() -> (CFTypeID _rv)")},
 	{"CFDataCreate", (PyCFunction)CF_CFDataCreate, 1,
-	 "(Buffer bytes) -> (CFDataRef _rv)"},
+	 PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")},
 	{"CFDataCreateWithBytesNoCopy", (PyCFunction)CF_CFDataCreateWithBytesNoCopy, 1,
-	 "(Buffer bytes) -> (CFDataRef _rv)"},
+	 PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")},
 	{"CFDataCreateMutable", (PyCFunction)CF_CFDataCreateMutable, 1,
-	 "(CFIndex capacity) -> (CFMutableDataRef _rv)"},
+	 PyDoc_STR("(CFIndex capacity) -> (CFMutableDataRef _rv)")},
 	{"CFDataCreateMutableCopy", (PyCFunction)CF_CFDataCreateMutableCopy, 1,
-	 "(CFIndex capacity, CFDataRef theData) -> (CFMutableDataRef _rv)"},
+	 PyDoc_STR("(CFIndex capacity, CFDataRef theData) -> (CFMutableDataRef _rv)")},
 	{"CFDictionaryGetTypeID", (PyCFunction)CF_CFDictionaryGetTypeID, 1,
-	 "() -> (CFTypeID _rv)"},
+	 PyDoc_STR("() -> (CFTypeID _rv)")},
 	{"CFDictionaryCreateMutable", (PyCFunction)CF_CFDictionaryCreateMutable, 1,
-	 "(CFIndex capacity) -> (CFMutableDictionaryRef _rv)"},
+	 PyDoc_STR("(CFIndex capacity) -> (CFMutableDictionaryRef _rv)")},
 	{"CFDictionaryCreateMutableCopy", (PyCFunction)CF_CFDictionaryCreateMutableCopy, 1,
-	 "(CFIndex capacity, CFDictionaryRef theDict) -> (CFMutableDictionaryRef _rv)"},
+	 PyDoc_STR("(CFIndex capacity, CFDictionaryRef theDict) -> (CFMutableDictionaryRef _rv)")},
 	{"CFPreferencesCopyAppValue", (PyCFunction)CF_CFPreferencesCopyAppValue, 1,
-	 "(CFStringRef key, CFStringRef applicationID) -> (CFTypeRef _rv)"},
+	 PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFTypeRef _rv)")},
 	{"CFPreferencesGetAppBooleanValue", (PyCFunction)CF_CFPreferencesGetAppBooleanValue, 1,
-	 "(CFStringRef key, CFStringRef applicationID) -> (Boolean _rv, Boolean keyExistsAndHasValidFormat)"},
+	 PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (Boolean _rv, Boolean keyExistsAndHasValidFormat)")},
 	{"CFPreferencesGetAppIntegerValue", (PyCFunction)CF_CFPreferencesGetAppIntegerValue, 1,
-	 "(CFStringRef key, CFStringRef applicationID) -> (CFIndex _rv, Boolean keyExistsAndHasValidFormat)"},
+	 PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFIndex _rv, Boolean keyExistsAndHasValidFormat)")},
 	{"CFPreferencesSetAppValue", (PyCFunction)CF_CFPreferencesSetAppValue, 1,
-	 "(CFStringRef key, CFTypeRef value, CFStringRef applicationID) -> None"},
+	 PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID) -> None")},
 	{"CFPreferencesAddSuitePreferencesToApp", (PyCFunction)CF_CFPreferencesAddSuitePreferencesToApp, 1,
-	 "(CFStringRef applicationID, CFStringRef suiteID) -> None"},
+	 PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")},
 	{"CFPreferencesRemoveSuitePreferencesFromApp", (PyCFunction)CF_CFPreferencesRemoveSuitePreferencesFromApp, 1,
-	 "(CFStringRef applicationID, CFStringRef suiteID) -> None"},
+	 PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")},
 	{"CFPreferencesAppSynchronize", (PyCFunction)CF_CFPreferencesAppSynchronize, 1,
-	 "(CFStringRef applicationID) -> (Boolean _rv)"},
+	 PyDoc_STR("(CFStringRef applicationID) -> (Boolean _rv)")},
 	{"CFPreferencesCopyValue", (PyCFunction)CF_CFPreferencesCopyValue, 1,
-	 "(CFStringRef key, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFTypeRef _rv)"},
+	 PyDoc_STR("(CFStringRef key, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFTypeRef _rv)")},
 	{"CFPreferencesCopyMultiple", (PyCFunction)CF_CFPreferencesCopyMultiple, 1,
-	 "(CFArrayRef keysToFetch, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFDictionaryRef _rv)"},
+	 PyDoc_STR("(CFArrayRef keysToFetch, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFDictionaryRef _rv)")},
 	{"CFPreferencesSetValue", (PyCFunction)CF_CFPreferencesSetValue, 1,
-	 "(CFStringRef key, CFTypeRef value, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None"},
+	 PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")},
 	{"CFPreferencesSetMultiple", (PyCFunction)CF_CFPreferencesSetMultiple, 1,
-	 "(CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None"},
+	 PyDoc_STR("(CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")},
 	{"CFPreferencesSynchronize", (PyCFunction)CF_CFPreferencesSynchronize, 1,
-	 "(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (Boolean _rv)"},
+	 PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (Boolean _rv)")},
 	{"CFPreferencesCopyApplicationList", (PyCFunction)CF_CFPreferencesCopyApplicationList, 1,
-	 "(CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)"},
+	 PyDoc_STR("(CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")},
 	{"CFPreferencesCopyKeyList", (PyCFunction)CF_CFPreferencesCopyKeyList, 1,
-	 "(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)"},
+	 PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")},
 	{"CFStringGetTypeID", (PyCFunction)CF_CFStringGetTypeID, 1,
-	 "() -> (CFTypeID _rv)"},
+	 PyDoc_STR("() -> (CFTypeID _rv)")},
 	{"CFStringCreateWithPascalString", (PyCFunction)CF_CFStringCreateWithPascalString, 1,
-	 "(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
 	{"CFStringCreateWithCString", (PyCFunction)CF_CFStringCreateWithCString, 1,
-	 "(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
 	{"CFStringCreateWithCharacters", (PyCFunction)CF_CFStringCreateWithCharacters, 1,
-	 "(Buffer chars) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")},
 	{"CFStringCreateWithPascalStringNoCopy", (PyCFunction)CF_CFStringCreateWithPascalStringNoCopy, 1,
-	 "(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
 	{"CFStringCreateWithCStringNoCopy", (PyCFunction)CF_CFStringCreateWithCStringNoCopy, 1,
-	 "(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
 	{"CFStringCreateWithCharactersNoCopy", (PyCFunction)CF_CFStringCreateWithCharactersNoCopy, 1,
-	 "(Buffer chars) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")},
 	{"CFStringCreateMutable", (PyCFunction)CF_CFStringCreateMutable, 1,
-	 "(CFIndex maxLength) -> (CFMutableStringRef _rv)"},
+	 PyDoc_STR("(CFIndex maxLength) -> (CFMutableStringRef _rv)")},
 	{"CFStringCreateMutableCopy", (PyCFunction)CF_CFStringCreateMutableCopy, 1,
-	 "(CFIndex maxLength, CFStringRef theString) -> (CFMutableStringRef _rv)"},
+	 PyDoc_STR("(CFIndex maxLength, CFStringRef theString) -> (CFMutableStringRef _rv)")},
 	{"CFStringCreateWithBytes", (PyCFunction)CF_CFStringCreateWithBytes, 1,
-	 "(Buffer bytes, CFStringEncoding encoding, Boolean isExternalRepresentation) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(Buffer bytes, CFStringEncoding encoding, Boolean isExternalRepresentation) -> (CFStringRef _rv)")},
 	{"CFStringGetSystemEncoding", (PyCFunction)CF_CFStringGetSystemEncoding, 1,
-	 "() -> (CFStringEncoding _rv)"},
+	 PyDoc_STR("() -> (CFStringEncoding _rv)")},
 	{"CFStringGetMaximumSizeForEncoding", (PyCFunction)CF_CFStringGetMaximumSizeForEncoding, 1,
-	 "(CFIndex length, CFStringEncoding encoding) -> (CFIndex _rv)"},
+	 PyDoc_STR("(CFIndex length, CFStringEncoding encoding) -> (CFIndex _rv)")},
 	{"CFStringIsEncodingAvailable", (PyCFunction)CF_CFStringIsEncodingAvailable, 1,
-	 "(CFStringEncoding encoding) -> (Boolean _rv)"},
+	 PyDoc_STR("(CFStringEncoding encoding) -> (Boolean _rv)")},
 	{"CFStringGetNameOfEncoding", (PyCFunction)CF_CFStringGetNameOfEncoding, 1,
-	 "(CFStringEncoding encoding) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")},
 	{"CFStringConvertEncodingToNSStringEncoding", (PyCFunction)CF_CFStringConvertEncodingToNSStringEncoding, 1,
-	 "(CFStringEncoding encoding) -> (UInt32 _rv)"},
+	 PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")},
 	{"CFStringConvertNSStringEncodingToEncoding", (PyCFunction)CF_CFStringConvertNSStringEncodingToEncoding, 1,
-	 "(UInt32 encoding) -> (CFStringEncoding _rv)"},
+	 PyDoc_STR("(UInt32 encoding) -> (CFStringEncoding _rv)")},
 	{"CFStringConvertEncodingToWindowsCodepage", (PyCFunction)CF_CFStringConvertEncodingToWindowsCodepage, 1,
-	 "(CFStringEncoding encoding) -> (UInt32 _rv)"},
+	 PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")},
 	{"CFStringConvertWindowsCodepageToEncoding", (PyCFunction)CF_CFStringConvertWindowsCodepageToEncoding, 1,
-	 "(UInt32 codepage) -> (CFStringEncoding _rv)"},
+	 PyDoc_STR("(UInt32 codepage) -> (CFStringEncoding _rv)")},
 	{"CFStringConvertEncodingToIANACharSetName", (PyCFunction)CF_CFStringConvertEncodingToIANACharSetName, 1,
-	 "(CFStringEncoding encoding) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")},
 	{"CFStringGetMostCompatibleMacStringEncoding", (PyCFunction)CF_CFStringGetMostCompatibleMacStringEncoding, 1,
-	 "(CFStringEncoding encoding) -> (CFStringEncoding _rv)"},
+	 PyDoc_STR("(CFStringEncoding encoding) -> (CFStringEncoding _rv)")},
 	{"__CFStringMakeConstantString", (PyCFunction)CF___CFStringMakeConstantString, 1,
-	 "(char* cStr) -> (CFStringRef _rv)"},
+	 PyDoc_STR("(char* cStr) -> (CFStringRef _rv)")},
 	{"CFURLGetTypeID", (PyCFunction)CF_CFURLGetTypeID, 1,
-	 "() -> (CFTypeID _rv)"},
+	 PyDoc_STR("() -> (CFTypeID _rv)")},
 	{"CFURLCreateWithBytes", (PyCFunction)CF_CFURLCreateWithBytes, 1,
-	 "(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)"},
+	 PyDoc_STR("(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)")},
 	{"CFURLCreateFromFileSystemRepresentation", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentation, 1,
-	 "(Buffer buffer, Boolean isDirectory) -> (CFURLRef _rv)"},
+	 PyDoc_STR("(Buffer buffer, Boolean isDirectory) -> (CFURLRef _rv)")},
 	{"CFURLCreateFromFileSystemRepresentationRelativeToBase", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentationRelativeToBase, 1,
-	 "(Buffer buffer, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)"},
+	 PyDoc_STR("(Buffer buffer, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")},
 	{"CFURLCreateFromFSRef", (PyCFunction)CF_CFURLCreateFromFSRef, 1,
-	 "(FSRef fsRef) -> (CFURLRef _rv)"},
+	 PyDoc_STR("(FSRef fsRef) -> (CFURLRef _rv)")},
 	{"toCF", (PyCFunction)CF_toCF, 1,
-	 "(python_object) -> (CF_object)"},
+	 PyDoc_STR("(python_object) -> (CF_object)")},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/cg/_CGmodule.c b/Mac/Modules/cg/_CGmodule.c
index 69bd77c..069889a 100755
--- a/Mac/Modules/cg/_CGmodule.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/cm/_Cmmodule.c b/Mac/Modules/cm/_Cmmodule.c
index d0da473..8ea72f0 100644
--- a/Mac/Modules/cm/_Cmmodule.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/ctl/_Ctlmodule.c b/Mac/Modules/ctl/_Ctlmodule.c
index cde42b7..0f88370 100644
--- a/Mac/Modules/ctl/_Ctlmodule.c
+++ b/Mac/Modules/ctl/_Ctlmodule.c
@@ -3880,665 +3880,665 @@ static PyObject *CtlObj_SetPopupData(ControlObject *_self, PyObject *_args)
 
 static PyMethodDef CtlObj_methods[] = {
 	{"HiliteControl", (PyCFunction)CtlObj_HiliteControl, 1,
-	 "(ControlPartCode hiliteState) -> None"},
+	 PyDoc_STR("(ControlPartCode hiliteState) -> None")},
 	{"ShowControl", (PyCFunction)CtlObj_ShowControl, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"HideControl", (PyCFunction)CtlObj_HideControl, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"IsControlActive", (PyCFunction)CtlObj_IsControlActive, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"IsControlVisible", (PyCFunction)CtlObj_IsControlVisible, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"ActivateControl", (PyCFunction)CtlObj_ActivateControl, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DeactivateControl", (PyCFunction)CtlObj_DeactivateControl, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetControlVisibility", (PyCFunction)CtlObj_SetControlVisibility, 1,
-	 "(Boolean inIsVisible, Boolean inDoDraw) -> None"},
+	 PyDoc_STR("(Boolean inIsVisible, Boolean inDoDraw) -> None")},
 
 #if TARGET_API_MAC_OSX
 	{"IsControlEnabled", (PyCFunction)CtlObj_IsControlEnabled, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_OSX
 	{"EnableControl", (PyCFunction)CtlObj_EnableControl, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if TARGET_API_MAC_OSX
 	{"DisableControl", (PyCFunction)CtlObj_DisableControl, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 	{"Draw1Control", (PyCFunction)CtlObj_Draw1Control, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetBestControlRect", (PyCFunction)CtlObj_GetBestControlRect, 1,
-	 "() -> (Rect outRect, SInt16 outBaseLineOffset)"},
+	 PyDoc_STR("() -> (Rect outRect, SInt16 outBaseLineOffset)")},
 	{"SetControlFontStyle", (PyCFunction)CtlObj_SetControlFontStyle, 1,
-	 "(ControlFontStyleRec inStyle) -> None"},
+	 PyDoc_STR("(ControlFontStyleRec inStyle) -> None")},
 	{"DrawControlInCurrentPort", (PyCFunction)CtlObj_DrawControlInCurrentPort, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetUpControlBackground", (PyCFunction)CtlObj_SetUpControlBackground, 1,
-	 "(SInt16 inDepth, Boolean inIsColorDevice) -> None"},
+	 PyDoc_STR("(SInt16 inDepth, Boolean inIsColorDevice) -> None")},
 	{"SetUpControlTextColor", (PyCFunction)CtlObj_SetUpControlTextColor, 1,
-	 "(SInt16 inDepth, Boolean inIsColorDevice) -> None"},
+	 PyDoc_STR("(SInt16 inDepth, Boolean inIsColorDevice) -> None")},
 	{"DragControl", (PyCFunction)CtlObj_DragControl, 1,
-	 "(Point startPoint, Rect limitRect, Rect slopRect, DragConstraint axis) -> None"},
+	 PyDoc_STR("(Point startPoint, Rect limitRect, Rect slopRect, DragConstraint axis) -> None")},
 	{"TestControl", (PyCFunction)CtlObj_TestControl, 1,
-	 "(Point testPoint) -> (ControlPartCode _rv)"},
+	 PyDoc_STR("(Point testPoint) -> (ControlPartCode _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"HandleControlContextualMenuClick", (PyCFunction)CtlObj_HandleControlContextualMenuClick, 1,
-	 "(Point inWhere) -> (Boolean menuDisplayed)"},
+	 PyDoc_STR("(Point inWhere) -> (Boolean menuDisplayed)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetControlClickActivation", (PyCFunction)CtlObj_GetControlClickActivation, 1,
-	 "(Point inWhere, EventModifiers inModifiers) -> (ClickActivationResult outResult)"},
+	 PyDoc_STR("(Point inWhere, EventModifiers inModifiers) -> (ClickActivationResult outResult)")},
 #endif
 	{"HandleControlKey", (PyCFunction)CtlObj_HandleControlKey, 1,
-	 "(SInt16 inKeyCode, SInt16 inCharCode, EventModifiers inModifiers) -> (ControlPartCode _rv)"},
+	 PyDoc_STR("(SInt16 inKeyCode, SInt16 inCharCode, EventModifiers inModifiers) -> (ControlPartCode _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"HandleControlSetCursor", (PyCFunction)CtlObj_HandleControlSetCursor, 1,
-	 "(Point localPoint, EventModifiers modifiers) -> (Boolean cursorWasSet)"},
+	 PyDoc_STR("(Point localPoint, EventModifiers modifiers) -> (Boolean cursorWasSet)")},
 #endif
 	{"MoveControl", (PyCFunction)CtlObj_MoveControl, 1,
-	 "(SInt16 h, SInt16 v) -> None"},
+	 PyDoc_STR("(SInt16 h, SInt16 v) -> None")},
 	{"SizeControl", (PyCFunction)CtlObj_SizeControl, 1,
-	 "(SInt16 w, SInt16 h) -> None"},
+	 PyDoc_STR("(SInt16 w, SInt16 h) -> None")},
 	{"SetControlTitle", (PyCFunction)CtlObj_SetControlTitle, 1,
-	 "(Str255 title) -> None"},
+	 PyDoc_STR("(Str255 title) -> None")},
 	{"GetControlTitle", (PyCFunction)CtlObj_GetControlTitle, 1,
-	 "() -> (Str255 title)"},
+	 PyDoc_STR("() -> (Str255 title)")},
 
 #if TARGET_API_MAC_CARBON
 	{"SetControlTitleWithCFString", (PyCFunction)CtlObj_SetControlTitleWithCFString, 1,
-	 "(CFStringRef inString) -> None"},
+	 PyDoc_STR("(CFStringRef inString) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CopyControlTitleAsCFString", (PyCFunction)CtlObj_CopyControlTitleAsCFString, 1,
-	 "() -> (CFStringRef outString)"},
+	 PyDoc_STR("() -> (CFStringRef outString)")},
 #endif
 	{"GetControlValue", (PyCFunction)CtlObj_GetControlValue, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"SetControlValue", (PyCFunction)CtlObj_SetControlValue, 1,
-	 "(SInt16 newValue) -> None"},
+	 PyDoc_STR("(SInt16 newValue) -> None")},
 	{"GetControlMinimum", (PyCFunction)CtlObj_GetControlMinimum, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"SetControlMinimum", (PyCFunction)CtlObj_SetControlMinimum, 1,
-	 "(SInt16 newMinimum) -> None"},
+	 PyDoc_STR("(SInt16 newMinimum) -> None")},
 	{"GetControlMaximum", (PyCFunction)CtlObj_GetControlMaximum, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"SetControlMaximum", (PyCFunction)CtlObj_SetControlMaximum, 1,
-	 "(SInt16 newMaximum) -> None"},
+	 PyDoc_STR("(SInt16 newMaximum) -> None")},
 	{"GetControlViewSize", (PyCFunction)CtlObj_GetControlViewSize, 1,
-	 "() -> (SInt32 _rv)"},
+	 PyDoc_STR("() -> (SInt32 _rv)")},
 	{"SetControlViewSize", (PyCFunction)CtlObj_SetControlViewSize, 1,
-	 "(SInt32 newViewSize) -> None"},
+	 PyDoc_STR("(SInt32 newViewSize) -> None")},
 	{"GetControl32BitValue", (PyCFunction)CtlObj_GetControl32BitValue, 1,
-	 "() -> (SInt32 _rv)"},
+	 PyDoc_STR("() -> (SInt32 _rv)")},
 	{"SetControl32BitValue", (PyCFunction)CtlObj_SetControl32BitValue, 1,
-	 "(SInt32 newValue) -> None"},
+	 PyDoc_STR("(SInt32 newValue) -> None")},
 	{"GetControl32BitMaximum", (PyCFunction)CtlObj_GetControl32BitMaximum, 1,
-	 "() -> (SInt32 _rv)"},
+	 PyDoc_STR("() -> (SInt32 _rv)")},
 	{"SetControl32BitMaximum", (PyCFunction)CtlObj_SetControl32BitMaximum, 1,
-	 "(SInt32 newMaximum) -> None"},
+	 PyDoc_STR("(SInt32 newMaximum) -> None")},
 	{"GetControl32BitMinimum", (PyCFunction)CtlObj_GetControl32BitMinimum, 1,
-	 "() -> (SInt32 _rv)"},
+	 PyDoc_STR("() -> (SInt32 _rv)")},
 	{"SetControl32BitMinimum", (PyCFunction)CtlObj_SetControl32BitMinimum, 1,
-	 "(SInt32 newMinimum) -> None"},
+	 PyDoc_STR("(SInt32 newMinimum) -> None")},
 	{"IsValidControlHandle", (PyCFunction)CtlObj_IsValidControlHandle, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"SetControlID", (PyCFunction)CtlObj_SetControlID, 1,
-	 "(ControlID inID) -> None"},
+	 PyDoc_STR("(ControlID inID) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetControlID", (PyCFunction)CtlObj_GetControlID, 1,
-	 "() -> (ControlID outID)"},
+	 PyDoc_STR("() -> (ControlID outID)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetControlCommandID", (PyCFunction)CtlObj_SetControlCommandID, 1,
-	 "(UInt32 inCommandID) -> None"},
+	 PyDoc_STR("(UInt32 inCommandID) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetControlCommandID", (PyCFunction)CtlObj_GetControlCommandID, 1,
-	 "() -> (UInt32 outCommandID)"},
+	 PyDoc_STR("() -> (UInt32 outCommandID)")},
 #endif
 	{"RemoveControlProperty", (PyCFunction)CtlObj_RemoveControlProperty, 1,
-	 "(OSType propertyCreator, OSType propertyTag) -> None"},
+	 PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"GetControlPropertyAttributes", (PyCFunction)CtlObj_GetControlPropertyAttributes, 1,
-	 "(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
+	 PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"ChangeControlPropertyAttributes", (PyCFunction)CtlObj_ChangeControlPropertyAttributes, 1,
-	 "(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"},
+	 PyDoc_STR("(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")},
 #endif
 	{"GetControlRegion", (PyCFunction)CtlObj_GetControlRegion, 1,
-	 "(ControlPartCode inPart, RgnHandle outRegion) -> None"},
+	 PyDoc_STR("(ControlPartCode inPart, RgnHandle outRegion) -> None")},
 	{"GetControlVariant", (PyCFunction)CtlObj_GetControlVariant, 1,
-	 "() -> (ControlVariant _rv)"},
+	 PyDoc_STR("() -> (ControlVariant _rv)")},
 	{"SetControlAction", (PyCFunction)CtlObj_SetControlAction, 1,
-	 "(PyObject* actionProc) -> None"},
+	 PyDoc_STR("(PyObject* actionProc) -> None")},
 	{"SetControlReference", (PyCFunction)CtlObj_SetControlReference, 1,
-	 "(SInt32 data) -> None"},
+	 PyDoc_STR("(SInt32 data) -> None")},
 	{"GetControlReference", (PyCFunction)CtlObj_GetControlReference, 1,
-	 "() -> (SInt32 _rv)"},
+	 PyDoc_STR("() -> (SInt32 _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"GetAuxiliaryControlRecord", (PyCFunction)CtlObj_GetAuxiliaryControlRecord, 1,
-	 "() -> (Boolean _rv, AuxCtlHandle acHndl)"},
+	 PyDoc_STR("() -> (Boolean _rv, AuxCtlHandle acHndl)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"SetControlColor", (PyCFunction)CtlObj_SetControlColor, 1,
-	 "(CCTabHandle newColorTable) -> None"},
+	 PyDoc_STR("(CCTabHandle newColorTable) -> None")},
 #endif
 	{"EmbedControl", (PyCFunction)CtlObj_EmbedControl, 1,
-	 "(ControlHandle inContainer) -> None"},
+	 PyDoc_STR("(ControlHandle inContainer) -> None")},
 	{"AutoEmbedControl", (PyCFunction)CtlObj_AutoEmbedControl, 1,
-	 "(WindowPtr inWindow) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow) -> None")},
 	{"GetSuperControl", (PyCFunction)CtlObj_GetSuperControl, 1,
-	 "() -> (ControlHandle outParent)"},
+	 PyDoc_STR("() -> (ControlHandle outParent)")},
 	{"CountSubControls", (PyCFunction)CtlObj_CountSubControls, 1,
-	 "() -> (UInt16 outNumChildren)"},
+	 PyDoc_STR("() -> (UInt16 outNumChildren)")},
 	{"GetIndexedSubControl", (PyCFunction)CtlObj_GetIndexedSubControl, 1,
-	 "(UInt16 inIndex) -> (ControlHandle outSubControl)"},
+	 PyDoc_STR("(UInt16 inIndex) -> (ControlHandle outSubControl)")},
 	{"SetControlSupervisor", (PyCFunction)CtlObj_SetControlSupervisor, 1,
-	 "(ControlHandle inBoss) -> None"},
+	 PyDoc_STR("(ControlHandle inBoss) -> None")},
 	{"GetControlFeatures", (PyCFunction)CtlObj_GetControlFeatures, 1,
-	 "() -> (UInt32 outFeatures)"},
+	 PyDoc_STR("() -> (UInt32 outFeatures)")},
 	{"GetControlDataSize", (PyCFunction)CtlObj_GetControlDataSize, 1,
-	 "(ControlPartCode inPart, ResType inTagName) -> (Size outMaxSize)"},
+	 PyDoc_STR("(ControlPartCode inPart, ResType inTagName) -> (Size outMaxSize)")},
 
 #if TARGET_API_MAC_CARBON
 	{"HandleControlDragTracking", (PyCFunction)CtlObj_HandleControlDragTracking, 1,
-	 "(DragTrackingMessage inMessage, DragReference inDrag) -> (Boolean outLikesDrag)"},
+	 PyDoc_STR("(DragTrackingMessage inMessage, DragReference inDrag) -> (Boolean outLikesDrag)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"HandleControlDragReceive", (PyCFunction)CtlObj_HandleControlDragReceive, 1,
-	 "(DragReference inDrag) -> None"},
+	 PyDoc_STR("(DragReference inDrag) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetControlDragTrackingEnabled", (PyCFunction)CtlObj_SetControlDragTrackingEnabled, 1,
-	 "(Boolean tracks) -> None"},
+	 PyDoc_STR("(Boolean tracks) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsControlDragTrackingEnabled", (PyCFunction)CtlObj_IsControlDragTrackingEnabled, 1,
-	 "() -> (Boolean tracks)"},
+	 PyDoc_STR("() -> (Boolean tracks)")},
 #endif
 
 #if ACCESSOR_CALLS_ARE_FUNCTIONS
 	{"GetControlBounds", (PyCFunction)CtlObj_GetControlBounds, 1,
-	 "() -> (Rect bounds)"},
+	 PyDoc_STR("() -> (Rect bounds)")},
 #endif
 
 #if ACCESSOR_CALLS_ARE_FUNCTIONS
 	{"IsControlHilited", (PyCFunction)CtlObj_IsControlHilited, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 
 #if ACCESSOR_CALLS_ARE_FUNCTIONS
 	{"GetControlHilite", (PyCFunction)CtlObj_GetControlHilite, 1,
-	 "() -> (UInt16 _rv)"},
+	 PyDoc_STR("() -> (UInt16 _rv)")},
 #endif
 
 #if ACCESSOR_CALLS_ARE_FUNCTIONS
 	{"GetControlOwner", (PyCFunction)CtlObj_GetControlOwner, 1,
-	 "() -> (WindowPtr _rv)"},
+	 PyDoc_STR("() -> (WindowPtr _rv)")},
 #endif
 
 #if ACCESSOR_CALLS_ARE_FUNCTIONS
 	{"GetControlDataHandle", (PyCFunction)CtlObj_GetControlDataHandle, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 #endif
 
 #if ACCESSOR_CALLS_ARE_FUNCTIONS
 	{"GetControlPopupMenuHandle", (PyCFunction)CtlObj_GetControlPopupMenuHandle, 1,
-	 "() -> (MenuHandle _rv)"},
+	 PyDoc_STR("() -> (MenuHandle _rv)")},
 #endif
 
 #if ACCESSOR_CALLS_ARE_FUNCTIONS
 	{"GetControlPopupMenuID", (PyCFunction)CtlObj_GetControlPopupMenuID, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 #endif
 
 #if ACCESSOR_CALLS_ARE_FUNCTIONS
 	{"SetControlDataHandle", (PyCFunction)CtlObj_SetControlDataHandle, 1,
-	 "(Handle dataHandle) -> None"},
+	 PyDoc_STR("(Handle dataHandle) -> None")},
 #endif
 
 #if ACCESSOR_CALLS_ARE_FUNCTIONS
 	{"SetControlBounds", (PyCFunction)CtlObj_SetControlBounds, 1,
-	 "(Rect bounds) -> None"},
+	 PyDoc_STR("(Rect bounds) -> None")},
 #endif
 
 #if ACCESSOR_CALLS_ARE_FUNCTIONS
 	{"SetControlPopupMenuHandle", (PyCFunction)CtlObj_SetControlPopupMenuHandle, 1,
-	 "(MenuHandle popupMenu) -> None"},
+	 PyDoc_STR("(MenuHandle popupMenu) -> None")},
 #endif
 
 #if ACCESSOR_CALLS_ARE_FUNCTIONS
 	{"SetControlPopupMenuID", (PyCFunction)CtlObj_SetControlPopupMenuID, 1,
-	 "(short menuID) -> None"},
+	 PyDoc_STR("(short menuID) -> None")},
 #endif
 	{"GetBevelButtonMenuValue", (PyCFunction)CtlObj_GetBevelButtonMenuValue, 1,
-	 "() -> (SInt16 outValue)"},
+	 PyDoc_STR("() -> (SInt16 outValue)")},
 	{"SetBevelButtonMenuValue", (PyCFunction)CtlObj_SetBevelButtonMenuValue, 1,
-	 "(SInt16 inValue) -> None"},
+	 PyDoc_STR("(SInt16 inValue) -> None")},
 	{"GetBevelButtonMenuHandle", (PyCFunction)CtlObj_GetBevelButtonMenuHandle, 1,
-	 "() -> (MenuHandle outHandle)"},
+	 PyDoc_STR("() -> (MenuHandle outHandle)")},
 
 #if TARGET_API_MAC_CARBON
 	{"SetBevelButtonContentInfo", (PyCFunction)CtlObj_SetBevelButtonContentInfo, 1,
-	 "(ControlButtonContentInfo inContent) -> None"},
+	 PyDoc_STR("(ControlButtonContentInfo inContent) -> None")},
 #endif
 	{"SetBevelButtonTransform", (PyCFunction)CtlObj_SetBevelButtonTransform, 1,
-	 "(IconTransformType transform) -> None"},
+	 PyDoc_STR("(IconTransformType transform) -> None")},
 	{"SetDisclosureTriangleLastValue", (PyCFunction)CtlObj_SetDisclosureTriangleLastValue, 1,
-	 "(SInt16 inValue) -> None"},
+	 PyDoc_STR("(SInt16 inValue) -> None")},
 	{"GetTabContentRect", (PyCFunction)CtlObj_GetTabContentRect, 1,
-	 "() -> (Rect outContentRect)"},
+	 PyDoc_STR("() -> (Rect outContentRect)")},
 	{"SetTabEnabled", (PyCFunction)CtlObj_SetTabEnabled, 1,
-	 "(SInt16 inTabToHilite, Boolean inEnabled) -> None"},
+	 PyDoc_STR("(SInt16 inTabToHilite, Boolean inEnabled) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"SetImageWellContentInfo", (PyCFunction)CtlObj_SetImageWellContentInfo, 1,
-	 "(ControlButtonContentInfo inContent) -> None"},
+	 PyDoc_STR("(ControlButtonContentInfo inContent) -> None")},
 #endif
 	{"SetImageWellTransform", (PyCFunction)CtlObj_SetImageWellTransform, 1,
-	 "(IconTransformType inTransform) -> None"},
+	 PyDoc_STR("(IconTransformType inTransform) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserViewStyle", (PyCFunction)CtlObj_GetDataBrowserViewStyle, 1,
-	 "() -> (OSType style)"},
+	 PyDoc_STR("() -> (OSType style)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserViewStyle", (PyCFunction)CtlObj_SetDataBrowserViewStyle, 1,
-	 "(OSType style) -> None"},
+	 PyDoc_STR("(OSType style) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"EnableDataBrowserEditCommand", (PyCFunction)CtlObj_EnableDataBrowserEditCommand, 1,
-	 "(UInt32 command) -> (Boolean _rv)"},
+	 PyDoc_STR("(UInt32 command) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"ExecuteDataBrowserEditCommand", (PyCFunction)CtlObj_ExecuteDataBrowserEditCommand, 1,
-	 "(UInt32 command) -> None"},
+	 PyDoc_STR("(UInt32 command) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserSelectionAnchor", (PyCFunction)CtlObj_GetDataBrowserSelectionAnchor, 1,
-	 "() -> (UInt32 first, UInt32 last)"},
+	 PyDoc_STR("() -> (UInt32 first, UInt32 last)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"MoveDataBrowserSelectionAnchor", (PyCFunction)CtlObj_MoveDataBrowserSelectionAnchor, 1,
-	 "(UInt32 direction, Boolean extendSelection) -> None"},
+	 PyDoc_STR("(UInt32 direction, Boolean extendSelection) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"OpenDataBrowserContainer", (PyCFunction)CtlObj_OpenDataBrowserContainer, 1,
-	 "(UInt32 container) -> None"},
+	 PyDoc_STR("(UInt32 container) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CloseDataBrowserContainer", (PyCFunction)CtlObj_CloseDataBrowserContainer, 1,
-	 "(UInt32 container) -> None"},
+	 PyDoc_STR("(UInt32 container) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SortDataBrowserContainer", (PyCFunction)CtlObj_SortDataBrowserContainer, 1,
-	 "(UInt32 container, Boolean sortChildren) -> None"},
+	 PyDoc_STR("(UInt32 container, Boolean sortChildren) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserItems", (PyCFunction)CtlObj_GetDataBrowserItems, 1,
-	 "(UInt32 container, Boolean recurse, UInt32 state, Handle items) -> None"},
+	 PyDoc_STR("(UInt32 container, Boolean recurse, UInt32 state, Handle items) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserItemCount", (PyCFunction)CtlObj_GetDataBrowserItemCount, 1,
-	 "(UInt32 container, Boolean recurse, UInt32 state) -> (UInt32 numItems)"},
+	 PyDoc_STR("(UInt32 container, Boolean recurse, UInt32 state) -> (UInt32 numItems)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsDataBrowserItemSelected", (PyCFunction)CtlObj_IsDataBrowserItemSelected, 1,
-	 "(UInt32 item) -> (Boolean _rv)"},
+	 PyDoc_STR("(UInt32 item) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserItemState", (PyCFunction)CtlObj_GetDataBrowserItemState, 1,
-	 "(UInt32 item) -> (UInt32 state)"},
+	 PyDoc_STR("(UInt32 item) -> (UInt32 state)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"RevealDataBrowserItem", (PyCFunction)CtlObj_RevealDataBrowserItem, 1,
-	 "(UInt32 item, UInt32 propertyID, UInt8 options) -> None"},
+	 PyDoc_STR("(UInt32 item, UInt32 propertyID, UInt8 options) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserActiveItems", (PyCFunction)CtlObj_SetDataBrowserActiveItems, 1,
-	 "(Boolean active) -> None"},
+	 PyDoc_STR("(Boolean active) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserActiveItems", (PyCFunction)CtlObj_GetDataBrowserActiveItems, 1,
-	 "() -> (Boolean active)"},
+	 PyDoc_STR("() -> (Boolean active)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserScrollBarInset", (PyCFunction)CtlObj_SetDataBrowserScrollBarInset, 1,
-	 "() -> (Rect insetRect)"},
+	 PyDoc_STR("() -> (Rect insetRect)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserScrollBarInset", (PyCFunction)CtlObj_GetDataBrowserScrollBarInset, 1,
-	 "() -> (Rect insetRect)"},
+	 PyDoc_STR("() -> (Rect insetRect)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserTarget", (PyCFunction)CtlObj_SetDataBrowserTarget, 1,
-	 "(UInt32 target) -> None"},
+	 PyDoc_STR("(UInt32 target) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTarget", (PyCFunction)CtlObj_GetDataBrowserTarget, 1,
-	 "() -> (UInt32 target)"},
+	 PyDoc_STR("() -> (UInt32 target)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserSortOrder", (PyCFunction)CtlObj_SetDataBrowserSortOrder, 1,
-	 "(UInt16 order) -> None"},
+	 PyDoc_STR("(UInt16 order) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserSortOrder", (PyCFunction)CtlObj_GetDataBrowserSortOrder, 1,
-	 "() -> (UInt16 order)"},
+	 PyDoc_STR("() -> (UInt16 order)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserScrollPosition", (PyCFunction)CtlObj_SetDataBrowserScrollPosition, 1,
-	 "(UInt32 top, UInt32 left) -> None"},
+	 PyDoc_STR("(UInt32 top, UInt32 left) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserScrollPosition", (PyCFunction)CtlObj_GetDataBrowserScrollPosition, 1,
-	 "() -> (UInt32 top, UInt32 left)"},
+	 PyDoc_STR("() -> (UInt32 top, UInt32 left)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserHasScrollBars", (PyCFunction)CtlObj_SetDataBrowserHasScrollBars, 1,
-	 "(Boolean horiz, Boolean vert) -> None"},
+	 PyDoc_STR("(Boolean horiz, Boolean vert) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserHasScrollBars", (PyCFunction)CtlObj_GetDataBrowserHasScrollBars, 1,
-	 "() -> (Boolean horiz, Boolean vert)"},
+	 PyDoc_STR("() -> (Boolean horiz, Boolean vert)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserSortProperty", (PyCFunction)CtlObj_SetDataBrowserSortProperty, 1,
-	 "(UInt32 property) -> None"},
+	 PyDoc_STR("(UInt32 property) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserSortProperty", (PyCFunction)CtlObj_GetDataBrowserSortProperty, 1,
-	 "() -> (UInt32 property)"},
+	 PyDoc_STR("() -> (UInt32 property)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserSelectionFlags", (PyCFunction)CtlObj_SetDataBrowserSelectionFlags, 1,
-	 "(UInt32 selectionFlags) -> None"},
+	 PyDoc_STR("(UInt32 selectionFlags) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserSelectionFlags", (PyCFunction)CtlObj_GetDataBrowserSelectionFlags, 1,
-	 "() -> (UInt32 selectionFlags)"},
+	 PyDoc_STR("() -> (UInt32 selectionFlags)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserPropertyFlags", (PyCFunction)CtlObj_SetDataBrowserPropertyFlags, 1,
-	 "(UInt32 property, UInt32 flags) -> None"},
+	 PyDoc_STR("(UInt32 property, UInt32 flags) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserPropertyFlags", (PyCFunction)CtlObj_GetDataBrowserPropertyFlags, 1,
-	 "(UInt32 property) -> (UInt32 flags)"},
+	 PyDoc_STR("(UInt32 property) -> (UInt32 flags)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserEditText", (PyCFunction)CtlObj_SetDataBrowserEditText, 1,
-	 "(CFStringRef text) -> None"},
+	 PyDoc_STR("(CFStringRef text) -> None")},
 #endif
 
 #if TARGET_API_MAC_OSX
 	{"CopyDataBrowserEditText", (PyCFunction)CtlObj_CopyDataBrowserEditText, 1,
-	 "() -> (CFStringRef text)"},
+	 PyDoc_STR("() -> (CFStringRef text)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserEditText", (PyCFunction)CtlObj_GetDataBrowserEditText, 1,
-	 "(CFMutableStringRef text) -> None"},
+	 PyDoc_STR("(CFMutableStringRef text) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserEditItem", (PyCFunction)CtlObj_SetDataBrowserEditItem, 1,
-	 "(UInt32 item, UInt32 property) -> None"},
+	 PyDoc_STR("(UInt32 item, UInt32 property) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserEditItem", (PyCFunction)CtlObj_GetDataBrowserEditItem, 1,
-	 "() -> (UInt32 item, UInt32 property)"},
+	 PyDoc_STR("() -> (UInt32 item, UInt32 property)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserItemPartBounds", (PyCFunction)CtlObj_GetDataBrowserItemPartBounds, 1,
-	 "(UInt32 item, UInt32 property, OSType part) -> (Rect bounds)"},
+	 PyDoc_STR("(UInt32 item, UInt32 property, OSType part) -> (Rect bounds)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"RemoveDataBrowserTableViewColumn", (PyCFunction)CtlObj_RemoveDataBrowserTableViewColumn, 1,
-	 "(UInt32 column) -> None"},
+	 PyDoc_STR("(UInt32 column) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTableViewColumnCount", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnCount, 1,
-	 "() -> (UInt32 numColumns)"},
+	 PyDoc_STR("() -> (UInt32 numColumns)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserTableViewHiliteStyle", (PyCFunction)CtlObj_SetDataBrowserTableViewHiliteStyle, 1,
-	 "(UInt32 hiliteStyle) -> None"},
+	 PyDoc_STR("(UInt32 hiliteStyle) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTableViewHiliteStyle", (PyCFunction)CtlObj_GetDataBrowserTableViewHiliteStyle, 1,
-	 "() -> (UInt32 hiliteStyle)"},
+	 PyDoc_STR("() -> (UInt32 hiliteStyle)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserTableViewRowHeight", (PyCFunction)CtlObj_SetDataBrowserTableViewRowHeight, 1,
-	 "(UInt16 height) -> None"},
+	 PyDoc_STR("(UInt16 height) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTableViewRowHeight", (PyCFunction)CtlObj_GetDataBrowserTableViewRowHeight, 1,
-	 "() -> (UInt16 height)"},
+	 PyDoc_STR("() -> (UInt16 height)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserTableViewColumnWidth", (PyCFunction)CtlObj_SetDataBrowserTableViewColumnWidth, 1,
-	 "(UInt16 width) -> None"},
+	 PyDoc_STR("(UInt16 width) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTableViewColumnWidth", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnWidth, 1,
-	 "() -> (UInt16 width)"},
+	 PyDoc_STR("() -> (UInt16 width)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserTableViewItemRowHeight", (PyCFunction)CtlObj_SetDataBrowserTableViewItemRowHeight, 1,
-	 "(UInt32 item, UInt16 height) -> None"},
+	 PyDoc_STR("(UInt32 item, UInt16 height) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTableViewItemRowHeight", (PyCFunction)CtlObj_GetDataBrowserTableViewItemRowHeight, 1,
-	 "(UInt32 item) -> (UInt16 height)"},
+	 PyDoc_STR("(UInt32 item) -> (UInt16 height)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserTableViewNamedColumnWidth", (PyCFunction)CtlObj_SetDataBrowserTableViewNamedColumnWidth, 1,
-	 "(UInt32 column, UInt16 width) -> None"},
+	 PyDoc_STR("(UInt32 column, UInt16 width) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTableViewNamedColumnWidth", (PyCFunction)CtlObj_GetDataBrowserTableViewNamedColumnWidth, 1,
-	 "(UInt32 column) -> (UInt16 width)"},
+	 PyDoc_STR("(UInt32 column) -> (UInt16 width)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserTableViewGeometry", (PyCFunction)CtlObj_SetDataBrowserTableViewGeometry, 1,
-	 "(Boolean variableWidthColumns, Boolean variableHeightRows) -> None"},
+	 PyDoc_STR("(Boolean variableWidthColumns, Boolean variableHeightRows) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTableViewGeometry", (PyCFunction)CtlObj_GetDataBrowserTableViewGeometry, 1,
-	 "() -> (Boolean variableWidthColumns, Boolean variableHeightRows)"},
+	 PyDoc_STR("() -> (Boolean variableWidthColumns, Boolean variableHeightRows)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTableViewItemID", (PyCFunction)CtlObj_GetDataBrowserTableViewItemID, 1,
-	 "(UInt32 row) -> (UInt32 item)"},
+	 PyDoc_STR("(UInt32 row) -> (UInt32 item)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserTableViewItemRow", (PyCFunction)CtlObj_SetDataBrowserTableViewItemRow, 1,
-	 "(UInt32 item, UInt32 row) -> None"},
+	 PyDoc_STR("(UInt32 item, UInt32 row) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTableViewItemRow", (PyCFunction)CtlObj_GetDataBrowserTableViewItemRow, 1,
-	 "(UInt32 item) -> (UInt32 row)"},
+	 PyDoc_STR("(UInt32 item) -> (UInt32 row)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserTableViewColumnPosition", (PyCFunction)CtlObj_SetDataBrowserTableViewColumnPosition, 1,
-	 "(UInt32 column, UInt32 position) -> None"},
+	 PyDoc_STR("(UInt32 column, UInt32 position) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTableViewColumnPosition", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnPosition, 1,
-	 "(UInt32 column) -> (UInt32 position)"},
+	 PyDoc_STR("(UInt32 column) -> (UInt32 position)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserTableViewColumnProperty", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnProperty, 1,
-	 "(UInt32 column) -> (UInt32 property)"},
+	 PyDoc_STR("(UInt32 column) -> (UInt32 property)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"AutoSizeDataBrowserListViewColumns", (PyCFunction)CtlObj_AutoSizeDataBrowserListViewColumns, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"AddDataBrowserListViewColumn", (PyCFunction)CtlObj_AddDataBrowserListViewColumn, 1,
-	 "(DataBrowserListViewColumnDesc columnDesc, UInt32 position) -> None"},
+	 PyDoc_STR("(DataBrowserListViewColumnDesc columnDesc, UInt32 position) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserListViewHeaderBtnHeight", (PyCFunction)CtlObj_SetDataBrowserListViewHeaderBtnHeight, 1,
-	 "(UInt16 height) -> None"},
+	 PyDoc_STR("(UInt16 height) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserListViewHeaderBtnHeight", (PyCFunction)CtlObj_GetDataBrowserListViewHeaderBtnHeight, 1,
-	 "() -> (UInt16 height)"},
+	 PyDoc_STR("() -> (UInt16 height)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserListViewUsePlainBackground", (PyCFunction)CtlObj_SetDataBrowserListViewUsePlainBackground, 1,
-	 "(Boolean usePlainBackground) -> None"},
+	 PyDoc_STR("(Boolean usePlainBackground) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserListViewUsePlainBackground", (PyCFunction)CtlObj_GetDataBrowserListViewUsePlainBackground, 1,
-	 "() -> (Boolean usePlainBackground)"},
+	 PyDoc_STR("() -> (Boolean usePlainBackground)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserListViewDisclosureColumn", (PyCFunction)CtlObj_SetDataBrowserListViewDisclosureColumn, 1,
-	 "(UInt32 column, Boolean expandableRows) -> None"},
+	 PyDoc_STR("(UInt32 column, Boolean expandableRows) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserListViewDisclosureColumn", (PyCFunction)CtlObj_GetDataBrowserListViewDisclosureColumn, 1,
-	 "() -> (UInt32 column, Boolean expandableRows)"},
+	 PyDoc_STR("() -> (UInt32 column, Boolean expandableRows)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserColumnViewPath", (PyCFunction)CtlObj_GetDataBrowserColumnViewPath, 1,
-	 "(Handle path) -> None"},
+	 PyDoc_STR("(Handle path) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserColumnViewPathLength", (PyCFunction)CtlObj_GetDataBrowserColumnViewPathLength, 1,
-	 "() -> (UInt32 pathLength)"},
+	 PyDoc_STR("() -> (UInt32 pathLength)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetDataBrowserColumnViewDisplayType", (PyCFunction)CtlObj_SetDataBrowserColumnViewDisplayType, 1,
-	 "(OSType propertyType) -> None"},
+	 PyDoc_STR("(OSType propertyType) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetDataBrowserColumnViewDisplayType", (PyCFunction)CtlObj_GetDataBrowserColumnViewDisplayType, 1,
-	 "() -> (OSType propertyType)"},
+	 PyDoc_STR("() -> (OSType propertyType)")},
 #endif
 	{"as_Resource", (PyCFunction)CtlObj_as_Resource, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"GetControlRect", (PyCFunction)CtlObj_GetControlRect, 1,
-	 "() -> (Rect rect)"},
+	 PyDoc_STR("() -> (Rect rect)")},
 	{"DisposeControl", (PyCFunction)CtlObj_DisposeControl, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"TrackControl", (PyCFunction)CtlObj_TrackControl, 1,
-	 "(Point startPoint [,trackercallback]) -> (ControlPartCode _rv)"},
+	 PyDoc_STR("(Point startPoint [,trackercallback]) -> (ControlPartCode _rv)")},
 	{"HandleControlClick", (PyCFunction)CtlObj_HandleControlClick, 1,
-	 "(Point startPoint, Integer modifiers, [,trackercallback]) -> (ControlPartCode _rv)"},
+	 PyDoc_STR("(Point startPoint, Integer modifiers, [,trackercallback]) -> (ControlPartCode _rv)")},
 	{"SetControlData", (PyCFunction)CtlObj_SetControlData, 1,
-	 "(stuff) -> None"},
+	 PyDoc_STR("(stuff) -> None")},
 	{"GetControlData", (PyCFunction)CtlObj_GetControlData, 1,
-	 "(part, type) -> String"},
+	 PyDoc_STR("(part, type) -> String")},
 	{"SetControlData_Handle", (PyCFunction)CtlObj_SetControlData_Handle, 1,
-	 "(ResObj) -> None"},
+	 PyDoc_STR("(ResObj) -> None")},
 	{"GetControlData_Handle", (PyCFunction)CtlObj_GetControlData_Handle, 1,
-	 "(part, type) -> ResObj"},
+	 PyDoc_STR("(part, type) -> ResObj")},
 	{"SetControlData_Callback", (PyCFunction)CtlObj_SetControlData_Callback, 1,
-	 "(callbackfunc) -> None"},
+	 PyDoc_STR("(callbackfunc) -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"GetPopupData", (PyCFunction)CtlObj_GetPopupData, 1,
-	 NULL},
+	 PyDoc_STR(NULL)},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"SetPopupData", (PyCFunction)CtlObj_SetPopupData, 1,
-	 NULL},
+	 PyDoc_STR(NULL)},
 #endif
 	{NULL, NULL, 0}
 };
@@ -6217,221 +6217,221 @@ static PyObject *Ctl_CreateTabsControl(PyObject *_self, PyObject *_args)
 
 static PyMethodDef Ctl_methods[] = {
 	{"NewControl", (PyCFunction)Ctl_NewControl, 1,
-	 "(WindowPtr owningWindow, Rect boundsRect, Str255 controlTitle, Boolean initiallyVisible, SInt16 initialValue, SInt16 minimumValue, SInt16 maximumValue, SInt16 procID, SInt32 controlReference) -> (ControlHandle _rv)"},
+	 PyDoc_STR("(WindowPtr owningWindow, Rect boundsRect, Str255 controlTitle, Boolean initiallyVisible, SInt16 initialValue, SInt16 minimumValue, SInt16 maximumValue, SInt16 procID, SInt32 controlReference) -> (ControlHandle _rv)")},
 	{"GetNewControl", (PyCFunction)Ctl_GetNewControl, 1,
-	 "(SInt16 resourceID, WindowPtr owningWindow) -> (ControlHandle _rv)"},
+	 PyDoc_STR("(SInt16 resourceID, WindowPtr owningWindow) -> (ControlHandle _rv)")},
 	{"DrawControls", (PyCFunction)Ctl_DrawControls, 1,
-	 "(WindowPtr theWindow) -> None"},
+	 PyDoc_STR("(WindowPtr theWindow) -> None")},
 	{"UpdateControls", (PyCFunction)Ctl_UpdateControls, 1,
-	 "(WindowPtr theWindow, RgnHandle updateRegion) -> None"},
+	 PyDoc_STR("(WindowPtr theWindow, RgnHandle updateRegion) -> None")},
 	{"FindControl", (PyCFunction)Ctl_FindControl, 1,
-	 "(Point testPoint, WindowPtr theWindow) -> (ControlPartCode _rv, ControlHandle theControl)"},
+	 PyDoc_STR("(Point testPoint, WindowPtr theWindow) -> (ControlPartCode _rv, ControlHandle theControl)")},
 	{"IdleControls", (PyCFunction)Ctl_IdleControls, 1,
-	 "(WindowPtr inWindow) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"GetControlByID", (PyCFunction)Ctl_GetControlByID, 1,
-	 "(WindowPtr inWindow, ControlID inID) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr inWindow, ControlID inID) -> (ControlHandle outControl)")},
 #endif
 	{"DumpControlHierarchy", (PyCFunction)Ctl_DumpControlHierarchy, 1,
-	 "(WindowPtr inWindow, FSSpec inDumpFile) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow, FSSpec inDumpFile) -> None")},
 	{"CreateRootControl", (PyCFunction)Ctl_CreateRootControl, 1,
-	 "(WindowPtr inWindow) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
 	{"GetRootControl", (PyCFunction)Ctl_GetRootControl, 1,
-	 "(WindowPtr inWindow) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
 	{"GetKeyboardFocus", (PyCFunction)Ctl_GetKeyboardFocus, 1,
-	 "(WindowPtr inWindow) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
 	{"SetKeyboardFocus", (PyCFunction)Ctl_SetKeyboardFocus, 1,
-	 "(WindowPtr inWindow, ControlHandle inControl, ControlFocusPart inPart) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl, ControlFocusPart inPart) -> None")},
 	{"AdvanceKeyboardFocus", (PyCFunction)Ctl_AdvanceKeyboardFocus, 1,
-	 "(WindowPtr inWindow) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow) -> None")},
 	{"ReverseKeyboardFocus", (PyCFunction)Ctl_ReverseKeyboardFocus, 1,
-	 "(WindowPtr inWindow) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow) -> None")},
 	{"ClearKeyboardFocus", (PyCFunction)Ctl_ClearKeyboardFocus, 1,
-	 "(WindowPtr inWindow) -> None"},
+	 PyDoc_STR("(WindowPtr inWindow) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"SetAutomaticControlDragTrackingEnabledForWindow", (PyCFunction)Ctl_SetAutomaticControlDragTrackingEnabledForWindow, 1,
-	 "(WindowPtr theWindow, Boolean tracks) -> None"},
+	 PyDoc_STR("(WindowPtr theWindow, Boolean tracks) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsAutomaticControlDragTrackingEnabledForWindow", (PyCFunction)Ctl_IsAutomaticControlDragTrackingEnabledForWindow, 1,
-	 "(WindowPtr theWindow) -> (Boolean tracks)"},
+	 PyDoc_STR("(WindowPtr theWindow) -> (Boolean tracks)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateBevelButtonControl", (PyCFunction)Ctl_CreateBevelButtonControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef title, UInt16 thickness, UInt16 behavior, ControlButtonContentInfo info, SInt16 menuID, UInt16 menuBehavior, UInt16 menuPlacement) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, UInt16 thickness, UInt16 behavior, ControlButtonContentInfo info, SInt16 menuID, UInt16 menuBehavior, UInt16 menuPlacement) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateSliderControl", (PyCFunction)Ctl_CreateSliderControl, 1,
-	 "(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, UInt16 orientation, UInt16 numTickMarks, Boolean liveTracking, PyObject* liveTrackingProc) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, UInt16 orientation, UInt16 numTickMarks, Boolean liveTracking, PyObject* liveTrackingProc) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateDisclosureTriangleControl", (PyCFunction)Ctl_CreateDisclosureTriangleControl, 1,
-	 "(WindowPtr window, Rect boundsRect, UInt16 orientation, CFStringRef title, SInt32 initialValue, Boolean drawTitle, Boolean autoToggles) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt16 orientation, CFStringRef title, SInt32 initialValue, Boolean drawTitle, Boolean autoToggles) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateProgressBarControl", (PyCFunction)Ctl_CreateProgressBarControl, 1,
-	 "(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, Boolean indeterminate) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, Boolean indeterminate) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_OSX
 	{"CreateRelevanceBarControl", (PyCFunction)Ctl_CreateRelevanceBarControl, 1,
-	 "(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateLittleArrowsControl", (PyCFunction)Ctl_CreateLittleArrowsControl, 1,
-	 "(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, SInt32 increment) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, SInt32 increment) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateChasingArrowsControl", (PyCFunction)Ctl_CreateChasingArrowsControl, 1,
-	 "(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateSeparatorControl", (PyCFunction)Ctl_CreateSeparatorControl, 1,
-	 "(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateGroupBoxControl", (PyCFunction)Ctl_CreateGroupBoxControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef title, Boolean primary) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, Boolean primary) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateCheckGroupBoxControl", (PyCFunction)Ctl_CreateCheckGroupBoxControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean primary, Boolean autoToggle) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean primary, Boolean autoToggle) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreatePopupGroupBoxControl", (PyCFunction)Ctl_CreatePopupGroupBoxControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef title, Boolean primary, SInt16 menuID, Boolean variableWidth, SInt16 titleWidth, SInt16 titleJustification, Style titleStyle) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, Boolean primary, SInt16 menuID, Boolean variableWidth, SInt16 titleWidth, SInt16 titleJustification, Style titleStyle) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateImageWellControl", (PyCFunction)Ctl_CreateImageWellControl, 1,
-	 "(WindowPtr window, Rect boundsRect, ControlButtonContentInfo info) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, ControlButtonContentInfo info) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreatePopupArrowControl", (PyCFunction)Ctl_CreatePopupArrowControl, 1,
-	 "(WindowPtr window, Rect boundsRect, UInt16 orientation, UInt16 size) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt16 orientation, UInt16 size) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreatePlacardControl", (PyCFunction)Ctl_CreatePlacardControl, 1,
-	 "(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateClockControl", (PyCFunction)Ctl_CreateClockControl, 1,
-	 "(WindowPtr window, Rect boundsRect, UInt16 clockType, UInt32 clockFlags) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt16 clockType, UInt32 clockFlags) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateUserPaneControl", (PyCFunction)Ctl_CreateUserPaneControl, 1,
-	 "(WindowPtr window, Rect boundsRect, UInt32 features) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt32 features) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateEditTextControl", (PyCFunction)Ctl_CreateEditTextControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef text, Boolean isPassword, Boolean useInlineInput, ControlFontStyleRec style) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef text, Boolean isPassword, Boolean useInlineInput, ControlFontStyleRec style) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateStaticTextControl", (PyCFunction)Ctl_CreateStaticTextControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef text, ControlFontStyleRec style) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef text, ControlFontStyleRec style) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreatePictureControl", (PyCFunction)Ctl_CreatePictureControl, 1,
-	 "(WindowPtr window, Rect boundsRect, ControlButtonContentInfo content, Boolean dontTrack) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, ControlButtonContentInfo content, Boolean dontTrack) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateIconControl", (PyCFunction)Ctl_CreateIconControl, 1,
-	 "(WindowPtr window, Rect boundsRect, ControlButtonContentInfo icon, Boolean dontTrack) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, ControlButtonContentInfo icon, Boolean dontTrack) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateWindowHeaderControl", (PyCFunction)Ctl_CreateWindowHeaderControl, 1,
-	 "(WindowPtr window, Rect boundsRect, Boolean isListHeader) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, Boolean isListHeader) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreatePushButtonControl", (PyCFunction)Ctl_CreatePushButtonControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef title) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreatePushButtonWithIconControl", (PyCFunction)Ctl_CreatePushButtonWithIconControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef title, ControlButtonContentInfo icon, UInt16 iconAlignment) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, ControlButtonContentInfo icon, UInt16 iconAlignment) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateRadioButtonControl", (PyCFunction)Ctl_CreateRadioButtonControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean autoToggle) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean autoToggle) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateCheckBoxControl", (PyCFunction)Ctl_CreateCheckBoxControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean autoToggle) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean autoToggle) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateScrollBarControl", (PyCFunction)Ctl_CreateScrollBarControl, 1,
-	 "(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, SInt32 viewSize, Boolean liveTracking, PyObject* liveTrackingProc) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, SInt32 viewSize, Boolean liveTracking, PyObject* liveTrackingProc) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreatePopupButtonControl", (PyCFunction)Ctl_CreatePopupButtonControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef title, SInt16 menuID, Boolean variableWidth, SInt16 titleWidth, SInt16 titleJustification, Style titleStyle) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt16 menuID, Boolean variableWidth, SInt16 titleWidth, SInt16 titleJustification, Style titleStyle) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateRadioGroupControl", (PyCFunction)Ctl_CreateRadioGroupControl, 1,
-	 "(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateScrollingTextBoxControl", (PyCFunction)Ctl_CreateScrollingTextBoxControl, 1,
-	 "(WindowPtr window, Rect boundsRect, SInt16 contentResID, Boolean autoScroll, UInt32 delayBeforeAutoScroll, UInt32 delayBetweenAutoScroll, UInt16 autoScrollAmount) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt16 contentResID, Boolean autoScroll, UInt32 delayBeforeAutoScroll, UInt32 delayBetweenAutoScroll, UInt16 autoScrollAmount) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_OSX
 	{"CreateDisclosureButtonControl", (PyCFunction)Ctl_CreateDisclosureButtonControl, 1,
-	 "(WindowPtr inWindow, Rect inBoundsRect, SInt32 inValue, Boolean inAutoToggles) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr inWindow, Rect inBoundsRect, SInt32 inValue, Boolean inAutoToggles) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_OSX
 	{"CreateRoundButtonControl", (PyCFunction)Ctl_CreateRoundButtonControl, 1,
-	 "(WindowPtr inWindow, Rect inBoundsRect, SInt16 inSize, ControlButtonContentInfo inContent) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr inWindow, Rect inBoundsRect, SInt16 inSize, ControlButtonContentInfo inContent) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateDataBrowserControl", (PyCFunction)Ctl_CreateDataBrowserControl, 1,
-	 "(WindowPtr window, Rect boundsRect, OSType style) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, OSType style) -> (ControlHandle outControl)")},
 #endif
 
 #if TARGET_API_MAC_OSX
 	{"CreateEditUnicodeTextControl", (PyCFunction)Ctl_CreateEditUnicodeTextControl, 1,
-	 "(WindowPtr window, Rect boundsRect, CFStringRef text, Boolean isPassword, ControlFontStyleRec style) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef text, Boolean isPassword, ControlFontStyleRec style) -> (ControlHandle outControl)")},
 #endif
 	{"FindControlUnderMouse", (PyCFunction)Ctl_FindControlUnderMouse, 1,
-	 "(Point inWhere, WindowPtr inWindow) -> (ControlHandle _rv, SInt16 outPart)"},
+	 PyDoc_STR("(Point inWhere, WindowPtr inWindow) -> (ControlHandle _rv, SInt16 outPart)")},
 	{"as_Control", (PyCFunction)Ctl_as_Control, 1,
-	 "(Handle h) -> (ControlHandle _rv)"},
+	 PyDoc_STR("(Handle h) -> (ControlHandle _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"CreateTabsControl", (PyCFunction)Ctl_CreateTabsControl, 1,
-	 "(WindowPtr window, Rect boundsRect, UInt16 size, UInt16 direction, ControlTabEntry tabArray) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt16 size, UInt16 direction, ControlTabEntry tabArray) -> (ControlHandle outControl)")},
 #endif
 	{NULL, NULL, 0}
 };
diff --git a/Mac/Modules/dlg/_Dlgmodule.c b/Mac/Modules/dlg/_Dlgmodule.c
index 4a7e18d..6651622 100644
--- a/Mac/Modules/dlg/_Dlgmodule.c
+++ b/Mac/Modules/dlg/_Dlgmodule.c
@@ -882,85 +882,85 @@ static PyObject *DlgObj_GetDialogPort(DialogObject *_self, PyObject *_args)
 
 static PyMethodDef DlgObj_methods[] = {
 	{"DrawDialog", (PyCFunction)DlgObj_DrawDialog, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"UpdateDialog", (PyCFunction)DlgObj_UpdateDialog, 1,
-	 "(RgnHandle updateRgn) -> None"},
+	 PyDoc_STR("(RgnHandle updateRgn) -> None")},
 	{"HideDialogItem", (PyCFunction)DlgObj_HideDialogItem, 1,
-	 "(DialogItemIndex itemNo) -> None"},
+	 PyDoc_STR("(DialogItemIndex itemNo) -> None")},
 	{"ShowDialogItem", (PyCFunction)DlgObj_ShowDialogItem, 1,
-	 "(DialogItemIndex itemNo) -> None"},
+	 PyDoc_STR("(DialogItemIndex itemNo) -> None")},
 	{"FindDialogItem", (PyCFunction)DlgObj_FindDialogItem, 1,
-	 "(Point thePt) -> (DialogItemIndexZeroBased _rv)"},
+	 PyDoc_STR("(Point thePt) -> (DialogItemIndexZeroBased _rv)")},
 	{"DialogCut", (PyCFunction)DlgObj_DialogCut, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DialogPaste", (PyCFunction)DlgObj_DialogPaste, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DialogCopy", (PyCFunction)DlgObj_DialogCopy, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DialogDelete", (PyCFunction)DlgObj_DialogDelete, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetDialogItem", (PyCFunction)DlgObj_GetDialogItem, 1,
-	 "(DialogItemIndex itemNo) -> (DialogItemType itemType, Handle item, Rect box)"},
+	 PyDoc_STR("(DialogItemIndex itemNo) -> (DialogItemType itemType, Handle item, Rect box)")},
 	{"SetDialogItem", (PyCFunction)DlgObj_SetDialogItem, 1,
-	 "(DialogItemIndex itemNo, DialogItemType itemType, Handle item, Rect box) -> None"},
+	 PyDoc_STR("(DialogItemIndex itemNo, DialogItemType itemType, Handle item, Rect box) -> None")},
 	{"SelectDialogItemText", (PyCFunction)DlgObj_SelectDialogItemText, 1,
-	 "(DialogItemIndex itemNo, SInt16 strtSel, SInt16 endSel) -> None"},
+	 PyDoc_STR("(DialogItemIndex itemNo, SInt16 strtSel, SInt16 endSel) -> None")},
 	{"AppendDITL", (PyCFunction)DlgObj_AppendDITL, 1,
-	 "(Handle theHandle, DITLMethod method) -> None"},
+	 PyDoc_STR("(Handle theHandle, DITLMethod method) -> None")},
 	{"CountDITL", (PyCFunction)DlgObj_CountDITL, 1,
-	 "() -> (DialogItemIndex _rv)"},
+	 PyDoc_STR("() -> (DialogItemIndex _rv)")},
 	{"ShortenDITL", (PyCFunction)DlgObj_ShortenDITL, 1,
-	 "(DialogItemIndex numberItems) -> None"},
+	 PyDoc_STR("(DialogItemIndex numberItems) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"InsertDialogItem", (PyCFunction)DlgObj_InsertDialogItem, 1,
-	 "(DialogItemIndex afterItem, DialogItemType itemType, Handle itemHandle, Rect box) -> None"},
+	 PyDoc_STR("(DialogItemIndex afterItem, DialogItemType itemType, Handle itemHandle, Rect box) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"RemoveDialogItems", (PyCFunction)DlgObj_RemoveDialogItems, 1,
-	 "(DialogItemIndex itemNo, DialogItemIndex amountToRemove, Boolean disposeItemData) -> None"},
+	 PyDoc_STR("(DialogItemIndex itemNo, DialogItemIndex amountToRemove, Boolean disposeItemData) -> None")},
 #endif
 	{"StdFilterProc", (PyCFunction)DlgObj_StdFilterProc, 1,
-	 "() -> (Boolean _rv, EventRecord event, DialogItemIndex itemHit)"},
+	 PyDoc_STR("() -> (Boolean _rv, EventRecord event, DialogItemIndex itemHit)")},
 	{"SetDialogDefaultItem", (PyCFunction)DlgObj_SetDialogDefaultItem, 1,
-	 "(DialogItemIndex newItem) -> None"},
+	 PyDoc_STR("(DialogItemIndex newItem) -> None")},
 	{"SetDialogCancelItem", (PyCFunction)DlgObj_SetDialogCancelItem, 1,
-	 "(DialogItemIndex newItem) -> None"},
+	 PyDoc_STR("(DialogItemIndex newItem) -> None")},
 	{"SetDialogTracksCursor", (PyCFunction)DlgObj_SetDialogTracksCursor, 1,
-	 "(Boolean tracks) -> None"},
+	 PyDoc_STR("(Boolean tracks) -> None")},
 	{"AutoSizeDialog", (PyCFunction)DlgObj_AutoSizeDialog, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetDialogItemAsControl", (PyCFunction)DlgObj_GetDialogItemAsControl, 1,
-	 "(SInt16 inItemNo) -> (ControlHandle outControl)"},
+	 PyDoc_STR("(SInt16 inItemNo) -> (ControlHandle outControl)")},
 	{"MoveDialogItem", (PyCFunction)DlgObj_MoveDialogItem, 1,
-	 "(SInt16 inItemNo, SInt16 inHoriz, SInt16 inVert) -> None"},
+	 PyDoc_STR("(SInt16 inItemNo, SInt16 inHoriz, SInt16 inVert) -> None")},
 	{"SizeDialogItem", (PyCFunction)DlgObj_SizeDialogItem, 1,
-	 "(SInt16 inItemNo, SInt16 inWidth, SInt16 inHeight) -> None"},
+	 PyDoc_STR("(SInt16 inItemNo, SInt16 inWidth, SInt16 inHeight) -> None")},
 	{"AppendDialogItemList", (PyCFunction)DlgObj_AppendDialogItemList, 1,
-	 "(SInt16 ditlID, DITLMethod method) -> None"},
+	 PyDoc_STR("(SInt16 ditlID, DITLMethod method) -> None")},
 	{"SetDialogTimeout", (PyCFunction)DlgObj_SetDialogTimeout, 1,
-	 "(SInt16 inButtonToPress, UInt32 inSecondsToWait) -> None"},
+	 PyDoc_STR("(SInt16 inButtonToPress, UInt32 inSecondsToWait) -> None")},
 	{"GetDialogTimeout", (PyCFunction)DlgObj_GetDialogTimeout, 1,
-	 "() -> (SInt16 outButtonToPress, UInt32 outSecondsToWait, UInt32 outSecondsRemaining)"},
+	 PyDoc_STR("() -> (SInt16 outButtonToPress, UInt32 outSecondsToWait, UInt32 outSecondsRemaining)")},
 	{"SetModalDialogEventMask", (PyCFunction)DlgObj_SetModalDialogEventMask, 1,
-	 "(EventMask inMask) -> None"},
+	 PyDoc_STR("(EventMask inMask) -> None")},
 	{"GetModalDialogEventMask", (PyCFunction)DlgObj_GetModalDialogEventMask, 1,
-	 "() -> (EventMask outMask)"},
+	 PyDoc_STR("() -> (EventMask outMask)")},
 	{"GetDialogWindow", (PyCFunction)DlgObj_GetDialogWindow, 1,
-	 "() -> (WindowPtr _rv)"},
+	 PyDoc_STR("() -> (WindowPtr _rv)")},
 	{"GetDialogTextEditHandle", (PyCFunction)DlgObj_GetDialogTextEditHandle, 1,
-	 "() -> (TEHandle _rv)"},
+	 PyDoc_STR("() -> (TEHandle _rv)")},
 	{"GetDialogDefaultItem", (PyCFunction)DlgObj_GetDialogDefaultItem, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"GetDialogCancelItem", (PyCFunction)DlgObj_GetDialogCancelItem, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"GetDialogKeyboardFocusItem", (PyCFunction)DlgObj_GetDialogKeyboardFocusItem, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"SetPortDialogPort", (PyCFunction)DlgObj_SetPortDialogPort, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetDialogPort", (PyCFunction)DlgObj_GetDialogPort, 1,
-	 "() -> (CGrafPtr _rv)"},
+	 PyDoc_STR("() -> (CGrafPtr _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -1471,48 +1471,48 @@ static PyObject *Dlg_SetUserItemHandler(PyObject *_self, PyObject *_args)
 
 static PyMethodDef Dlg_methods[] = {
 	{"NewDialog", (PyCFunction)Dlg_NewDialog, 1,
-	 "(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)"},
+	 PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)")},
 	{"GetNewDialog", (PyCFunction)Dlg_GetNewDialog, 1,
-	 "(SInt16 dialogID, WindowPtr behind) -> (DialogPtr _rv)"},
+	 PyDoc_STR("(SInt16 dialogID, WindowPtr behind) -> (DialogPtr _rv)")},
 	{"NewColorDialog", (PyCFunction)Dlg_NewColorDialog, 1,
-	 "(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)"},
+	 PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)")},
 	{"ModalDialog", (PyCFunction)Dlg_ModalDialog, 1,
-	 "(PyObject* modalFilter) -> (DialogItemIndex itemHit)"},
+	 PyDoc_STR("(PyObject* modalFilter) -> (DialogItemIndex itemHit)")},
 	{"IsDialogEvent", (PyCFunction)Dlg_IsDialogEvent, 1,
-	 "(EventRecord theEvent) -> (Boolean _rv)"},
+	 PyDoc_STR("(EventRecord theEvent) -> (Boolean _rv)")},
 	{"DialogSelect", (PyCFunction)Dlg_DialogSelect, 1,
-	 "(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, DialogItemIndex itemHit)"},
+	 PyDoc_STR("(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, DialogItemIndex itemHit)")},
 	{"Alert", (PyCFunction)Dlg_Alert, 1,
-	 "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
+	 PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")},
 	{"StopAlert", (PyCFunction)Dlg_StopAlert, 1,
-	 "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
+	 PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")},
 	{"NoteAlert", (PyCFunction)Dlg_NoteAlert, 1,
-	 "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
+	 PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")},
 	{"CautionAlert", (PyCFunction)Dlg_CautionAlert, 1,
-	 "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
+	 PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")},
 	{"ParamText", (PyCFunction)Dlg_ParamText, 1,
-	 "(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"},
+	 PyDoc_STR("(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None")},
 	{"GetDialogItemText", (PyCFunction)Dlg_GetDialogItemText, 1,
-	 "(Handle item) -> (Str255 text)"},
+	 PyDoc_STR("(Handle item) -> (Str255 text)")},
 	{"SetDialogItemText", (PyCFunction)Dlg_SetDialogItemText, 1,
-	 "(Handle item, Str255 text) -> None"},
+	 PyDoc_STR("(Handle item, Str255 text) -> None")},
 	{"GetAlertStage", (PyCFunction)Dlg_GetAlertStage, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"SetDialogFont", (PyCFunction)Dlg_SetDialogFont, 1,
-	 "(SInt16 fontNum) -> None"},
+	 PyDoc_STR("(SInt16 fontNum) -> None")},
 	{"ResetAlertStage", (PyCFunction)Dlg_ResetAlertStage, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"GetParamText", (PyCFunction)Dlg_GetParamText, 1,
-	 "(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"},
+	 PyDoc_STR("(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None")},
 #endif
 	{"NewFeaturesDialog", (PyCFunction)Dlg_NewFeaturesDialog, 1,
-	 "(Rect inBoundsRect, Str255 inTitle, Boolean inIsVisible, SInt16 inProcID, WindowPtr inBehind, Boolean inGoAwayFlag, SInt32 inRefCon, Handle inItemListHandle, UInt32 inFlags) -> (DialogPtr _rv)"},
+	 PyDoc_STR("(Rect inBoundsRect, Str255 inTitle, Boolean inIsVisible, SInt16 inProcID, WindowPtr inBehind, Boolean inGoAwayFlag, SInt32 inRefCon, Handle inItemListHandle, UInt32 inFlags) -> (DialogPtr _rv)")},
 	{"GetDialogFromWindow", (PyCFunction)Dlg_GetDialogFromWindow, 1,
-	 "(WindowPtr window) -> (DialogPtr _rv)"},
+	 PyDoc_STR("(WindowPtr window) -> (DialogPtr _rv)")},
 	{"SetUserItemHandler", (PyCFunction)Dlg_SetUserItemHandler, 1,
-	 NULL},
+	 PyDoc_STR(NULL)},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/drag/_Dragmodule.c b/Mac/Modules/drag/_Dragmodule.c
index 357d7dc..1e1dc8b 100644
--- a/Mac/Modules/drag/_Dragmodule.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/evt/_Evtmodule.c b/Mac/Modules/evt/_Evtmodule.c
index df098fa..ff75403 100644
--- a/Mac/Modules/evt/_Evtmodule.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/fm/_Fmmodule.c b/Mac/Modules/fm/_Fmmodule.c
index e6497f2..245dcb0 100644
--- a/Mac/Modules/fm/_Fmmodule.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/help/_Helpmodule.c b/Mac/Modules/help/_Helpmodule.c
index 46f1a35..66cd7b5 100644
--- a/Mac/Modules/help/_Helpmodule.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/ibcarbon/_IBCarbon.c b/Mac/Modules/ibcarbon/_IBCarbon.c
index e4cd041..fdddd84 100644
--- a/Mac/Modules/ibcarbon/_IBCarbon.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/icn/_Icnmodule.c b/Mac/Modules/icn/_Icnmodule.c
index 19930df..93b96ac 100644
--- a/Mac/Modules/icn/_Icnmodule.c
+++ b/Mac/Modules/icn/_Icnmodule.c
@@ -1442,141 +1442,141 @@ static PyObject *Icn_WriteIconFile(PyObject *_self, PyObject *_args)
 
 static PyMethodDef Icn_methods[] = {
 	{"GetCIcon", (PyCFunction)Icn_GetCIcon, 1,
-	 "(SInt16 iconID) -> (CIconHandle _rv)"},
+	 PyDoc_STR("(SInt16 iconID) -> (CIconHandle _rv)")},
 	{"PlotCIcon", (PyCFunction)Icn_PlotCIcon, 1,
-	 "(Rect theRect, CIconHandle theIcon) -> None"},
+	 PyDoc_STR("(Rect theRect, CIconHandle theIcon) -> None")},
 	{"DisposeCIcon", (PyCFunction)Icn_DisposeCIcon, 1,
-	 "(CIconHandle theIcon) -> None"},
+	 PyDoc_STR("(CIconHandle theIcon) -> None")},
 	{"GetIcon", (PyCFunction)Icn_GetIcon, 1,
-	 "(SInt16 iconID) -> (Handle _rv)"},
+	 PyDoc_STR("(SInt16 iconID) -> (Handle _rv)")},
 	{"PlotIcon", (PyCFunction)Icn_PlotIcon, 1,
-	 "(Rect theRect, Handle theIcon) -> None"},
+	 PyDoc_STR("(Rect theRect, Handle theIcon) -> None")},
 	{"PlotIconID", (PyCFunction)Icn_PlotIconID, 1,
-	 "(Rect theRect, IconAlignmentType align, IconTransformType transform, SInt16 theResID) -> None"},
+	 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, SInt16 theResID) -> None")},
 	{"NewIconSuite", (PyCFunction)Icn_NewIconSuite, 1,
-	 "() -> (IconSuiteRef theIconSuite)"},
+	 PyDoc_STR("() -> (IconSuiteRef theIconSuite)")},
 	{"AddIconToSuite", (PyCFunction)Icn_AddIconToSuite, 1,
-	 "(Handle theIconData, IconSuiteRef theSuite, ResType theType) -> None"},
+	 PyDoc_STR("(Handle theIconData, IconSuiteRef theSuite, ResType theType) -> None")},
 	{"GetIconFromSuite", (PyCFunction)Icn_GetIconFromSuite, 1,
-	 "(IconSuiteRef theSuite, ResType theType) -> (Handle theIconData)"},
+	 PyDoc_STR("(IconSuiteRef theSuite, ResType theType) -> (Handle theIconData)")},
 	{"GetIconSuite", (PyCFunction)Icn_GetIconSuite, 1,
-	 "(SInt16 theResID, IconSelectorValue selector) -> (IconSuiteRef theIconSuite)"},
+	 PyDoc_STR("(SInt16 theResID, IconSelectorValue selector) -> (IconSuiteRef theIconSuite)")},
 	{"DisposeIconSuite", (PyCFunction)Icn_DisposeIconSuite, 1,
-	 "(IconSuiteRef theIconSuite, Boolean disposeData) -> None"},
+	 PyDoc_STR("(IconSuiteRef theIconSuite, Boolean disposeData) -> None")},
 	{"PlotIconSuite", (PyCFunction)Icn_PlotIconSuite, 1,
-	 "(Rect theRect, IconAlignmentType align, IconTransformType transform, IconSuiteRef theIconSuite) -> None"},
+	 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconSuiteRef theIconSuite) -> None")},
 	{"LoadIconCache", (PyCFunction)Icn_LoadIconCache, 1,
-	 "(Rect theRect, IconAlignmentType align, IconTransformType transform, IconCacheRef theIconCache) -> None"},
+	 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconCacheRef theIconCache) -> None")},
 	{"GetLabel", (PyCFunction)Icn_GetLabel, 1,
-	 "(SInt16 labelNumber, Str255 labelString) -> (RGBColor labelColor)"},
+	 PyDoc_STR("(SInt16 labelNumber, Str255 labelString) -> (RGBColor labelColor)")},
 	{"PtInIconID", (PyCFunction)Icn_PtInIconID, 1,
-	 "(Point testPt, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)")},
 	{"PtInIconSuite", (PyCFunction)Icn_PtInIconSuite, 1,
-	 "(Point testPt, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)")},
 	{"RectInIconID", (PyCFunction)Icn_RectInIconID, 1,
-	 "(Rect testRect, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)"},
+	 PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)")},
 	{"RectInIconSuite", (PyCFunction)Icn_RectInIconSuite, 1,
-	 "(Rect testRect, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)"},
+	 PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)")},
 	{"IconIDToRgn", (PyCFunction)Icn_IconIDToRgn, 1,
-	 "(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> None"},
+	 PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> None")},
 	{"IconSuiteToRgn", (PyCFunction)Icn_IconSuiteToRgn, 1,
-	 "(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> None"},
+	 PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> None")},
 	{"SetSuiteLabel", (PyCFunction)Icn_SetSuiteLabel, 1,
-	 "(IconSuiteRef theSuite, SInt16 theLabel) -> None"},
+	 PyDoc_STR("(IconSuiteRef theSuite, SInt16 theLabel) -> None")},
 	{"GetSuiteLabel", (PyCFunction)Icn_GetSuiteLabel, 1,
-	 "(IconSuiteRef theSuite) -> (SInt16 _rv)"},
+	 PyDoc_STR("(IconSuiteRef theSuite) -> (SInt16 _rv)")},
 	{"PlotIconHandle", (PyCFunction)Icn_PlotIconHandle, 1,
-	 "(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theIcon) -> None"},
+	 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theIcon) -> None")},
 	{"PlotSICNHandle", (PyCFunction)Icn_PlotSICNHandle, 1,
-	 "(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theSICN) -> None"},
+	 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theSICN) -> None")},
 	{"PlotCIconHandle", (PyCFunction)Icn_PlotCIconHandle, 1,
-	 "(Rect theRect, IconAlignmentType align, IconTransformType transform, CIconHandle theCIcon) -> None"},
+	 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, CIconHandle theCIcon) -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"IconServicesTerminate", (PyCFunction)Icn_IconServicesTerminate, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 	{"IconRefToIconFamily", (PyCFunction)Icn_IconRefToIconFamily, 1,
-	 "(IconRef theIconRef, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)"},
+	 PyDoc_STR("(IconRef theIconRef, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)")},
 	{"IconFamilyToIconSuite", (PyCFunction)Icn_IconFamilyToIconSuite, 1,
-	 "(IconFamilyHandle iconFamily, IconSelectorValue whichIcons) -> (IconSuiteRef iconSuite)"},
+	 PyDoc_STR("(IconFamilyHandle iconFamily, IconSelectorValue whichIcons) -> (IconSuiteRef iconSuite)")},
 	{"IconSuiteToIconFamily", (PyCFunction)Icn_IconSuiteToIconFamily, 1,
-	 "(IconSuiteRef iconSuite, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)"},
+	 PyDoc_STR("(IconSuiteRef iconSuite, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)")},
 	{"SetIconFamilyData", (PyCFunction)Icn_SetIconFamilyData, 1,
-	 "(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None"},
+	 PyDoc_STR("(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None")},
 	{"GetIconFamilyData", (PyCFunction)Icn_GetIconFamilyData, 1,
-	 "(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None"},
+	 PyDoc_STR("(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None")},
 	{"GetIconRefOwners", (PyCFunction)Icn_GetIconRefOwners, 1,
-	 "(IconRef theIconRef) -> (UInt16 owners)"},
+	 PyDoc_STR("(IconRef theIconRef) -> (UInt16 owners)")},
 	{"AcquireIconRef", (PyCFunction)Icn_AcquireIconRef, 1,
-	 "(IconRef theIconRef) -> None"},
+	 PyDoc_STR("(IconRef theIconRef) -> None")},
 	{"ReleaseIconRef", (PyCFunction)Icn_ReleaseIconRef, 1,
-	 "(IconRef theIconRef) -> None"},
+	 PyDoc_STR("(IconRef theIconRef) -> None")},
 	{"GetIconRefFromFile", (PyCFunction)Icn_GetIconRefFromFile, 1,
-	 "(FSSpec theFile) -> (IconRef theIconRef, SInt16 theLabel)"},
+	 PyDoc_STR("(FSSpec theFile) -> (IconRef theIconRef, SInt16 theLabel)")},
 	{"GetIconRef", (PyCFunction)Icn_GetIconRef, 1,
-	 "(SInt16 vRefNum, OSType creator, OSType iconType) -> (IconRef theIconRef)"},
+	 PyDoc_STR("(SInt16 vRefNum, OSType creator, OSType iconType) -> (IconRef theIconRef)")},
 	{"GetIconRefFromFolder", (PyCFunction)Icn_GetIconRefFromFolder, 1,
-	 "(SInt16 vRefNum, SInt32 parentFolderID, SInt32 folderID, SInt8 attributes, SInt8 accessPrivileges) -> (IconRef theIconRef)"},
+	 PyDoc_STR("(SInt16 vRefNum, SInt32 parentFolderID, SInt32 folderID, SInt8 attributes, SInt8 accessPrivileges) -> (IconRef theIconRef)")},
 	{"RegisterIconRefFromIconFamily", (PyCFunction)Icn_RegisterIconRefFromIconFamily, 1,
-	 "(OSType creator, OSType iconType, IconFamilyHandle iconFamily) -> (IconRef theIconRef)"},
+	 PyDoc_STR("(OSType creator, OSType iconType, IconFamilyHandle iconFamily) -> (IconRef theIconRef)")},
 	{"RegisterIconRefFromResource", (PyCFunction)Icn_RegisterIconRefFromResource, 1,
-	 "(OSType creator, OSType iconType, FSSpec resourceFile, SInt16 resourceID) -> (IconRef theIconRef)"},
+	 PyDoc_STR("(OSType creator, OSType iconType, FSSpec resourceFile, SInt16 resourceID) -> (IconRef theIconRef)")},
 	{"UnregisterIconRef", (PyCFunction)Icn_UnregisterIconRef, 1,
-	 "(OSType creator, OSType iconType) -> None"},
+	 PyDoc_STR("(OSType creator, OSType iconType) -> None")},
 	{"UpdateIconRef", (PyCFunction)Icn_UpdateIconRef, 1,
-	 "(IconRef theIconRef) -> None"},
+	 PyDoc_STR("(IconRef theIconRef) -> None")},
 	{"OverrideIconRefFromResource", (PyCFunction)Icn_OverrideIconRefFromResource, 1,
-	 "(IconRef theIconRef, FSSpec resourceFile, SInt16 resourceID) -> None"},
+	 PyDoc_STR("(IconRef theIconRef, FSSpec resourceFile, SInt16 resourceID) -> None")},
 	{"OverrideIconRef", (PyCFunction)Icn_OverrideIconRef, 1,
-	 "(IconRef oldIconRef, IconRef newIconRef) -> None"},
+	 PyDoc_STR("(IconRef oldIconRef, IconRef newIconRef) -> None")},
 	{"RemoveIconRefOverride", (PyCFunction)Icn_RemoveIconRefOverride, 1,
-	 "(IconRef theIconRef) -> None"},
+	 PyDoc_STR("(IconRef theIconRef) -> None")},
 	{"CompositeIconRef", (PyCFunction)Icn_CompositeIconRef, 1,
-	 "(IconRef backgroundIconRef, IconRef foregroundIconRef) -> (IconRef compositeIconRef)"},
+	 PyDoc_STR("(IconRef backgroundIconRef, IconRef foregroundIconRef) -> (IconRef compositeIconRef)")},
 	{"IsIconRefComposite", (PyCFunction)Icn_IsIconRefComposite, 1,
-	 "(IconRef compositeIconRef) -> (IconRef backgroundIconRef, IconRef foregroundIconRef)"},
+	 PyDoc_STR("(IconRef compositeIconRef) -> (IconRef backgroundIconRef, IconRef foregroundIconRef)")},
 	{"IsValidIconRef", (PyCFunction)Icn_IsValidIconRef, 1,
-	 "(IconRef theIconRef) -> (Boolean _rv)"},
+	 PyDoc_STR("(IconRef theIconRef) -> (Boolean _rv)")},
 	{"PlotIconRef", (PyCFunction)Icn_PlotIconRef, 1,
-	 "(Rect theRect, IconAlignmentType align, IconTransformType transform, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> None"},
+	 PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> None")},
 	{"PtInIconRef", (PyCFunction)Icn_PtInIconRef, 1,
-	 "(Point testPt, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)")},
 	{"RectInIconRef", (PyCFunction)Icn_RectInIconRef, 1,
-	 "(Rect testRect, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)"},
+	 PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)")},
 	{"IconRefToRgn", (PyCFunction)Icn_IconRefToRgn, 1,
-	 "(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> None"},
+	 PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> None")},
 	{"GetIconSizesFromIconRef", (PyCFunction)Icn_GetIconSizesFromIconRef, 1,
-	 "(IconSelectorValue iconSelectorInput, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (IconSelectorValue iconSelectorOutputPtr)"},
+	 PyDoc_STR("(IconSelectorValue iconSelectorInput, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (IconSelectorValue iconSelectorOutputPtr)")},
 	{"FlushIconRefs", (PyCFunction)Icn_FlushIconRefs, 1,
-	 "(OSType creator, OSType iconType) -> None"},
+	 PyDoc_STR("(OSType creator, OSType iconType) -> None")},
 	{"FlushIconRefsByVolume", (PyCFunction)Icn_FlushIconRefsByVolume, 1,
-	 "(SInt16 vRefNum) -> None"},
+	 PyDoc_STR("(SInt16 vRefNum) -> None")},
 	{"SetCustomIconsEnabled", (PyCFunction)Icn_SetCustomIconsEnabled, 1,
-	 "(SInt16 vRefNum, Boolean enableCustomIcons) -> None"},
+	 PyDoc_STR("(SInt16 vRefNum, Boolean enableCustomIcons) -> None")},
 	{"GetCustomIconsEnabled", (PyCFunction)Icn_GetCustomIconsEnabled, 1,
-	 "(SInt16 vRefNum) -> (Boolean customIconsEnabled)"},
+	 PyDoc_STR("(SInt16 vRefNum) -> (Boolean customIconsEnabled)")},
 	{"IsIconRefMaskEmpty", (PyCFunction)Icn_IsIconRefMaskEmpty, 1,
-	 "(IconRef iconRef) -> (Boolean _rv)"},
+	 PyDoc_STR("(IconRef iconRef) -> (Boolean _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"GetIconRefVariant", (PyCFunction)Icn_GetIconRefVariant, 1,
-	 "(IconRef inIconRef, OSType inVariant) -> (IconRef _rv, IconTransformType outTransform)"},
+	 PyDoc_STR("(IconRef inIconRef, OSType inVariant) -> (IconRef _rv, IconTransformType outTransform)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"RegisterIconRefFromIconFile", (PyCFunction)Icn_RegisterIconRefFromIconFile, 1,
-	 "(OSType creator, OSType iconType, FSSpec iconFile) -> (IconRef theIconRef)"},
+	 PyDoc_STR("(OSType creator, OSType iconType, FSSpec iconFile) -> (IconRef theIconRef)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"ReadIconFile", (PyCFunction)Icn_ReadIconFile, 1,
-	 "(FSSpec iconFile) -> (IconFamilyHandle iconFamily)"},
+	 PyDoc_STR("(FSSpec iconFile) -> (IconFamilyHandle iconFamily)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"WriteIconFile", (PyCFunction)Icn_WriteIconFile, 1,
-	 "(IconFamilyHandle iconFamily, FSSpec iconFile) -> None"},
+	 PyDoc_STR("(IconFamilyHandle iconFamily, FSSpec iconFile) -> None")},
 #endif
 	{NULL, NULL, 0}
 };
diff --git a/Mac/Modules/list/_Listmodule.c b/Mac/Modules/list/_Listmodule.c
index 85c4d61..99805b6 100644
--- a/Mac/Modules/list/_Listmodule.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/menu/_Menumodule.c b/Mac/Modules/menu/_Menumodule.c
index dd369c1..bf860fe 100644
--- a/Mac/Modules/menu/_Menumodule.c
+++ b/Mac/Modules/menu/_Menumodule.c
@@ -2597,406 +2597,406 @@ static PyObject *MenuObj_CheckMenuItem(MenuObject *_self, PyObject *_args)
 
 static PyMethodDef MenuObj_methods[] = {
 	{"DisposeMenu", (PyCFunction)MenuObj_DisposeMenu, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"CountMItems", (PyCFunction)MenuObj_CountMItems, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 #endif
 	{"CountMenuItems", (PyCFunction)MenuObj_CountMenuItems, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"GetMenuFont", (PyCFunction)MenuObj_GetMenuFont, 1,
-	 "() -> (SInt16 outFontID, UInt16 outFontSize)"},
+	 PyDoc_STR("() -> (SInt16 outFontID, UInt16 outFontSize)")},
 	{"SetMenuFont", (PyCFunction)MenuObj_SetMenuFont, 1,
-	 "(SInt16 inFontID, UInt16 inFontSize) -> None"},
+	 PyDoc_STR("(SInt16 inFontID, UInt16 inFontSize) -> None")},
 	{"GetMenuExcludesMarkColumn", (PyCFunction)MenuObj_GetMenuExcludesMarkColumn, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"SetMenuExcludesMarkColumn", (PyCFunction)MenuObj_SetMenuExcludesMarkColumn, 1,
-	 "(Boolean excludesMark) -> None"},
+	 PyDoc_STR("(Boolean excludesMark) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"IsValidMenu", (PyCFunction)MenuObj_IsValidMenu, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuRetainCount", (PyCFunction)MenuObj_GetMenuRetainCount, 1,
-	 "() -> (ItemCount _rv)"},
+	 PyDoc_STR("() -> (ItemCount _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"RetainMenu", (PyCFunction)MenuObj_RetainMenu, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"ReleaseMenu", (PyCFunction)MenuObj_ReleaseMenu, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"DuplicateMenu", (PyCFunction)MenuObj_DuplicateMenu, 1,
-	 "() -> (MenuHandle outMenu)"},
+	 PyDoc_STR("() -> (MenuHandle outMenu)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CopyMenuTitleAsCFString", (PyCFunction)MenuObj_CopyMenuTitleAsCFString, 1,
-	 "() -> (CFStringRef outString)"},
+	 PyDoc_STR("() -> (CFStringRef outString)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetMenuTitleWithCFString", (PyCFunction)MenuObj_SetMenuTitleWithCFString, 1,
-	 "(CFStringRef inString) -> None"},
+	 PyDoc_STR("(CFStringRef inString) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"InvalidateMenuSize", (PyCFunction)MenuObj_InvalidateMenuSize, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsMenuSizeInvalid", (PyCFunction)MenuObj_IsMenuSizeInvalid, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 	{"MacAppendMenu", (PyCFunction)MenuObj_MacAppendMenu, 1,
-	 "(Str255 data) -> None"},
+	 PyDoc_STR("(Str255 data) -> None")},
 	{"InsertResMenu", (PyCFunction)MenuObj_InsertResMenu, 1,
-	 "(ResType theType, short afterItem) -> None"},
+	 PyDoc_STR("(ResType theType, short afterItem) -> None")},
 	{"AppendResMenu", (PyCFunction)MenuObj_AppendResMenu, 1,
-	 "(ResType theType) -> None"},
+	 PyDoc_STR("(ResType theType) -> None")},
 	{"MacInsertMenuItem", (PyCFunction)MenuObj_MacInsertMenuItem, 1,
-	 "(Str255 itemString, short afterItem) -> None"},
+	 PyDoc_STR("(Str255 itemString, short afterItem) -> None")},
 	{"DeleteMenuItem", (PyCFunction)MenuObj_DeleteMenuItem, 1,
-	 "(short item) -> None"},
+	 PyDoc_STR("(short item) -> None")},
 	{"InsertFontResMenu", (PyCFunction)MenuObj_InsertFontResMenu, 1,
-	 "(short afterItem, short scriptFilter) -> None"},
+	 PyDoc_STR("(short afterItem, short scriptFilter) -> None")},
 	{"InsertIntlResMenu", (PyCFunction)MenuObj_InsertIntlResMenu, 1,
-	 "(ResType theType, short afterItem, short scriptFilter) -> None"},
+	 PyDoc_STR("(ResType theType, short afterItem, short scriptFilter) -> None")},
 	{"AppendMenuItemText", (PyCFunction)MenuObj_AppendMenuItemText, 1,
-	 "(Str255 inString) -> None"},
+	 PyDoc_STR("(Str255 inString) -> None")},
 	{"InsertMenuItemText", (PyCFunction)MenuObj_InsertMenuItemText, 1,
-	 "(Str255 inString, MenuItemIndex afterItem) -> None"},
+	 PyDoc_STR("(Str255 inString, MenuItemIndex afterItem) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"CopyMenuItems", (PyCFunction)MenuObj_CopyMenuItems, 1,
-	 "(MenuItemIndex inFirstItem, ItemCount inNumItems, MenuHandle inDestMenu, MenuItemIndex inInsertAfter) -> None"},
+	 PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems, MenuHandle inDestMenu, MenuItemIndex inInsertAfter) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"DeleteMenuItems", (PyCFunction)MenuObj_DeleteMenuItems, 1,
-	 "(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None"},
+	 PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"AppendMenuItemTextWithCFString", (PyCFunction)MenuObj_AppendMenuItemTextWithCFString, 1,
-	 "(CFStringRef inString, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> (MenuItemIndex outNewItem)"},
+	 PyDoc_STR("(CFStringRef inString, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> (MenuItemIndex outNewItem)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"InsertMenuItemTextWithCFString", (PyCFunction)MenuObj_InsertMenuItemTextWithCFString, 1,
-	 "(CFStringRef inString, MenuItemIndex inAfterItem, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> None"},
+	 PyDoc_STR("(CFStringRef inString, MenuItemIndex inAfterItem, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> None")},
 #endif
 	{"PopUpMenuSelect", (PyCFunction)MenuObj_PopUpMenuSelect, 1,
-	 "(short top, short left, short popUpItem) -> (long _rv)"},
+	 PyDoc_STR("(short top, short left, short popUpItem) -> (long _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"InvalidateMenuEnabling", (PyCFunction)MenuObj_InvalidateMenuEnabling, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsMenuBarInvalid", (PyCFunction)MenuObj_IsMenuBarInvalid, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 	{"MacInsertMenu", (PyCFunction)MenuObj_MacInsertMenu, 1,
-	 "(MenuID beforeID) -> None"},
+	 PyDoc_STR("(MenuID beforeID) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"SetRootMenu", (PyCFunction)MenuObj_SetRootMenu, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"CheckItem", (PyCFunction)MenuObj_CheckItem, 1,
-	 "(short item, Boolean checked) -> None"},
+	 PyDoc_STR("(short item, Boolean checked) -> None")},
 #endif
 	{"MacCheckMenuItem", (PyCFunction)MenuObj_MacCheckMenuItem, 1,
-	 "(short item, Boolean checked) -> None"},
+	 PyDoc_STR("(short item, Boolean checked) -> None")},
 	{"SetMenuItemText", (PyCFunction)MenuObj_SetMenuItemText, 1,
-	 "(short item, Str255 itemString) -> None"},
+	 PyDoc_STR("(short item, Str255 itemString) -> None")},
 	{"GetMenuItemText", (PyCFunction)MenuObj_GetMenuItemText, 1,
-	 "(short item) -> (Str255 itemString)"},
+	 PyDoc_STR("(short item) -> (Str255 itemString)")},
 	{"SetItemMark", (PyCFunction)MenuObj_SetItemMark, 1,
-	 "(short item, CharParameter markChar) -> None"},
+	 PyDoc_STR("(short item, CharParameter markChar) -> None")},
 	{"GetItemMark", (PyCFunction)MenuObj_GetItemMark, 1,
-	 "(short item) -> (CharParameter markChar)"},
+	 PyDoc_STR("(short item) -> (CharParameter markChar)")},
 	{"SetItemCmd", (PyCFunction)MenuObj_SetItemCmd, 1,
-	 "(short item, CharParameter cmdChar) -> None"},
+	 PyDoc_STR("(short item, CharParameter cmdChar) -> None")},
 	{"GetItemCmd", (PyCFunction)MenuObj_GetItemCmd, 1,
-	 "(short item) -> (CharParameter cmdChar)"},
+	 PyDoc_STR("(short item) -> (CharParameter cmdChar)")},
 	{"SetItemIcon", (PyCFunction)MenuObj_SetItemIcon, 1,
-	 "(short item, short iconIndex) -> None"},
+	 PyDoc_STR("(short item, short iconIndex) -> None")},
 	{"GetItemIcon", (PyCFunction)MenuObj_GetItemIcon, 1,
-	 "(short item) -> (short iconIndex)"},
+	 PyDoc_STR("(short item) -> (short iconIndex)")},
 	{"SetItemStyle", (PyCFunction)MenuObj_SetItemStyle, 1,
-	 "(short item, StyleParameter chStyle) -> None"},
+	 PyDoc_STR("(short item, StyleParameter chStyle) -> None")},
 	{"GetItemStyle", (PyCFunction)MenuObj_GetItemStyle, 1,
-	 "(short item) -> (Style chStyle)"},
+	 PyDoc_STR("(short item) -> (Style chStyle)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"DisableItem", (PyCFunction)MenuObj_DisableItem, 1,
-	 "(short item) -> None"},
+	 PyDoc_STR("(short item) -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"EnableItem", (PyCFunction)MenuObj_EnableItem, 1,
-	 "(short item) -> None"},
+	 PyDoc_STR("(short item) -> None")},
 #endif
 	{"SetMenuItemCommandID", (PyCFunction)MenuObj_SetMenuItemCommandID, 1,
-	 "(SInt16 inItem, MenuCommand inCommandID) -> None"},
+	 PyDoc_STR("(SInt16 inItem, MenuCommand inCommandID) -> None")},
 	{"GetMenuItemCommandID", (PyCFunction)MenuObj_GetMenuItemCommandID, 1,
-	 "(SInt16 inItem) -> (MenuCommand outCommandID)"},
+	 PyDoc_STR("(SInt16 inItem) -> (MenuCommand outCommandID)")},
 	{"SetMenuItemModifiers", (PyCFunction)MenuObj_SetMenuItemModifiers, 1,
-	 "(SInt16 inItem, UInt8 inModifiers) -> None"},
+	 PyDoc_STR("(SInt16 inItem, UInt8 inModifiers) -> None")},
 	{"GetMenuItemModifiers", (PyCFunction)MenuObj_GetMenuItemModifiers, 1,
-	 "(SInt16 inItem) -> (UInt8 outModifiers)"},
+	 PyDoc_STR("(SInt16 inItem) -> (UInt8 outModifiers)")},
 	{"SetMenuItemIconHandle", (PyCFunction)MenuObj_SetMenuItemIconHandle, 1,
-	 "(SInt16 inItem, UInt8 inIconType, Handle inIconHandle) -> None"},
+	 PyDoc_STR("(SInt16 inItem, UInt8 inIconType, Handle inIconHandle) -> None")},
 	{"GetMenuItemIconHandle", (PyCFunction)MenuObj_GetMenuItemIconHandle, 1,
-	 "(SInt16 inItem) -> (UInt8 outIconType, Handle outIconHandle)"},
+	 PyDoc_STR("(SInt16 inItem) -> (UInt8 outIconType, Handle outIconHandle)")},
 	{"SetMenuItemTextEncoding", (PyCFunction)MenuObj_SetMenuItemTextEncoding, 1,
-	 "(SInt16 inItem, TextEncoding inScriptID) -> None"},
+	 PyDoc_STR("(SInt16 inItem, TextEncoding inScriptID) -> None")},
 	{"GetMenuItemTextEncoding", (PyCFunction)MenuObj_GetMenuItemTextEncoding, 1,
-	 "(SInt16 inItem) -> (TextEncoding outScriptID)"},
+	 PyDoc_STR("(SInt16 inItem) -> (TextEncoding outScriptID)")},
 	{"SetMenuItemHierarchicalID", (PyCFunction)MenuObj_SetMenuItemHierarchicalID, 1,
-	 "(SInt16 inItem, MenuID inHierID) -> None"},
+	 PyDoc_STR("(SInt16 inItem, MenuID inHierID) -> None")},
 	{"GetMenuItemHierarchicalID", (PyCFunction)MenuObj_GetMenuItemHierarchicalID, 1,
-	 "(SInt16 inItem) -> (MenuID outHierID)"},
+	 PyDoc_STR("(SInt16 inItem) -> (MenuID outHierID)")},
 	{"SetMenuItemFontID", (PyCFunction)MenuObj_SetMenuItemFontID, 1,
-	 "(SInt16 inItem, SInt16 inFontID) -> None"},
+	 PyDoc_STR("(SInt16 inItem, SInt16 inFontID) -> None")},
 	{"GetMenuItemFontID", (PyCFunction)MenuObj_GetMenuItemFontID, 1,
-	 "(SInt16 inItem) -> (SInt16 outFontID)"},
+	 PyDoc_STR("(SInt16 inItem) -> (SInt16 outFontID)")},
 	{"SetMenuItemRefCon", (PyCFunction)MenuObj_SetMenuItemRefCon, 1,
-	 "(SInt16 inItem, UInt32 inRefCon) -> None"},
+	 PyDoc_STR("(SInt16 inItem, UInt32 inRefCon) -> None")},
 	{"GetMenuItemRefCon", (PyCFunction)MenuObj_GetMenuItemRefCon, 1,
-	 "(SInt16 inItem) -> (UInt32 outRefCon)"},
+	 PyDoc_STR("(SInt16 inItem) -> (UInt32 outRefCon)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SetMenuItemRefCon2", (PyCFunction)MenuObj_SetMenuItemRefCon2, 1,
-	 "(SInt16 inItem, UInt32 inRefCon2) -> None"},
+	 PyDoc_STR("(SInt16 inItem, UInt32 inRefCon2) -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"GetMenuItemRefCon2", (PyCFunction)MenuObj_GetMenuItemRefCon2, 1,
-	 "(SInt16 inItem) -> (UInt32 outRefCon2)"},
+	 PyDoc_STR("(SInt16 inItem) -> (UInt32 outRefCon2)")},
 #endif
 	{"SetMenuItemKeyGlyph", (PyCFunction)MenuObj_SetMenuItemKeyGlyph, 1,
-	 "(SInt16 inItem, SInt16 inGlyph) -> None"},
+	 PyDoc_STR("(SInt16 inItem, SInt16 inGlyph) -> None")},
 	{"GetMenuItemKeyGlyph", (PyCFunction)MenuObj_GetMenuItemKeyGlyph, 1,
-	 "(SInt16 inItem) -> (SInt16 outGlyph)"},
+	 PyDoc_STR("(SInt16 inItem) -> (SInt16 outGlyph)")},
 	{"MacEnableMenuItem", (PyCFunction)MenuObj_MacEnableMenuItem, 1,
-	 "(MenuItemIndex item) -> None"},
+	 PyDoc_STR("(MenuItemIndex item) -> None")},
 	{"DisableMenuItem", (PyCFunction)MenuObj_DisableMenuItem, 1,
-	 "(MenuItemIndex item) -> None"},
+	 PyDoc_STR("(MenuItemIndex item) -> None")},
 	{"IsMenuItemEnabled", (PyCFunction)MenuObj_IsMenuItemEnabled, 1,
-	 "(MenuItemIndex item) -> (Boolean _rv)"},
+	 PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")},
 	{"EnableMenuItemIcon", (PyCFunction)MenuObj_EnableMenuItemIcon, 1,
-	 "(MenuItemIndex item) -> None"},
+	 PyDoc_STR("(MenuItemIndex item) -> None")},
 	{"DisableMenuItemIcon", (PyCFunction)MenuObj_DisableMenuItemIcon, 1,
-	 "(MenuItemIndex item) -> None"},
+	 PyDoc_STR("(MenuItemIndex item) -> None")},
 	{"IsMenuItemIconEnabled", (PyCFunction)MenuObj_IsMenuItemIconEnabled, 1,
-	 "(MenuItemIndex item) -> (Boolean _rv)"},
+	 PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"SetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_SetMenuItemHierarchicalMenu, 1,
-	 "(MenuItemIndex inItem, MenuHandle inHierMenu) -> None"},
+	 PyDoc_STR("(MenuItemIndex inItem, MenuHandle inHierMenu) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_GetMenuItemHierarchicalMenu, 1,
-	 "(MenuItemIndex inItem) -> (MenuHandle outHierMenu)"},
+	 PyDoc_STR("(MenuItemIndex inItem) -> (MenuHandle outHierMenu)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CopyMenuItemTextAsCFString", (PyCFunction)MenuObj_CopyMenuItemTextAsCFString, 1,
-	 "(MenuItemIndex inItem) -> (CFStringRef outString)"},
+	 PyDoc_STR("(MenuItemIndex inItem) -> (CFStringRef outString)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetMenuItemTextWithCFString", (PyCFunction)MenuObj_SetMenuItemTextWithCFString, 1,
-	 "(MenuItemIndex inItem, CFStringRef inString) -> None"},
+	 PyDoc_STR("(MenuItemIndex inItem, CFStringRef inString) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuItemIndent", (PyCFunction)MenuObj_GetMenuItemIndent, 1,
-	 "(MenuItemIndex inItem) -> (UInt32 outIndent)"},
+	 PyDoc_STR("(MenuItemIndex inItem) -> (UInt32 outIndent)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetMenuItemIndent", (PyCFunction)MenuObj_SetMenuItemIndent, 1,
-	 "(MenuItemIndex inItem, UInt32 inIndent) -> None"},
+	 PyDoc_STR("(MenuItemIndex inItem, UInt32 inIndent) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuItemCommandKey", (PyCFunction)MenuObj_GetMenuItemCommandKey, 1,
-	 "(MenuItemIndex inItem, Boolean inGetVirtualKey) -> (UInt16 outKey)"},
+	 PyDoc_STR("(MenuItemIndex inItem, Boolean inGetVirtualKey) -> (UInt16 outKey)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetMenuItemCommandKey", (PyCFunction)MenuObj_SetMenuItemCommandKey, 1,
-	 "(MenuItemIndex inItem, Boolean inSetVirtualKey, UInt16 inKey) -> None"},
+	 PyDoc_STR("(MenuItemIndex inItem, Boolean inSetVirtualKey, UInt16 inKey) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuItemPropertyAttributes", (PyCFunction)MenuObj_GetMenuItemPropertyAttributes, 1,
-	 "(MenuItemIndex item, OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
+	 PyDoc_STR("(MenuItemIndex item, OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"ChangeMenuItemPropertyAttributes", (PyCFunction)MenuObj_ChangeMenuItemPropertyAttributes, 1,
-	 "(MenuItemIndex item, OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"},
+	 PyDoc_STR("(MenuItemIndex item, OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuAttributes", (PyCFunction)MenuObj_GetMenuAttributes, 1,
-	 "() -> (MenuAttributes outAttributes)"},
+	 PyDoc_STR("() -> (MenuAttributes outAttributes)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"ChangeMenuAttributes", (PyCFunction)MenuObj_ChangeMenuAttributes, 1,
-	 "(MenuAttributes setTheseAttributes, MenuAttributes clearTheseAttributes) -> None"},
+	 PyDoc_STR("(MenuAttributes setTheseAttributes, MenuAttributes clearTheseAttributes) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuItemAttributes", (PyCFunction)MenuObj_GetMenuItemAttributes, 1,
-	 "(MenuItemIndex item) -> (MenuItemAttributes outAttributes)"},
+	 PyDoc_STR("(MenuItemIndex item) -> (MenuItemAttributes outAttributes)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"ChangeMenuItemAttributes", (PyCFunction)MenuObj_ChangeMenuItemAttributes, 1,
-	 "(MenuItemIndex item, MenuItemAttributes setTheseAttributes, MenuItemAttributes clearTheseAttributes) -> None"},
+	 PyDoc_STR("(MenuItemIndex item, MenuItemAttributes setTheseAttributes, MenuItemAttributes clearTheseAttributes) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"DisableAllMenuItems", (PyCFunction)MenuObj_DisableAllMenuItems, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"EnableAllMenuItems", (PyCFunction)MenuObj_EnableAllMenuItems, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"MenuHasEnabledItems", (PyCFunction)MenuObj_MenuHasEnabledItems, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuType", (PyCFunction)MenuObj_GetMenuType, 1,
-	 "() -> (UInt16 outType)"},
+	 PyDoc_STR("() -> (UInt16 outType)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CountMenuItemsWithCommandID", (PyCFunction)MenuObj_CountMenuItemsWithCommandID, 1,
-	 "(MenuCommand inCommandID) -> (ItemCount _rv)"},
+	 PyDoc_STR("(MenuCommand inCommandID) -> (ItemCount _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetIndMenuItemWithCommandID", (PyCFunction)MenuObj_GetIndMenuItemWithCommandID, 1,
-	 "(MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)"},
+	 PyDoc_STR("(MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"EnableMenuCommand", (PyCFunction)MenuObj_EnableMenuCommand, 1,
-	 "(MenuCommand inCommandID) -> None"},
+	 PyDoc_STR("(MenuCommand inCommandID) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"DisableMenuCommand", (PyCFunction)MenuObj_DisableMenuCommand, 1,
-	 "(MenuCommand inCommandID) -> None"},
+	 PyDoc_STR("(MenuCommand inCommandID) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsMenuCommandEnabled", (PyCFunction)MenuObj_IsMenuCommandEnabled, 1,
-	 "(MenuCommand inCommandID) -> (Boolean _rv)"},
+	 PyDoc_STR("(MenuCommand inCommandID) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetMenuCommandMark", (PyCFunction)MenuObj_SetMenuCommandMark, 1,
-	 "(MenuCommand inCommandID, UniChar inMark) -> None"},
+	 PyDoc_STR("(MenuCommand inCommandID, UniChar inMark) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuCommandMark", (PyCFunction)MenuObj_GetMenuCommandMark, 1,
-	 "(MenuCommand inCommandID) -> (UniChar outMark)"},
+	 PyDoc_STR("(MenuCommand inCommandID) -> (UniChar outMark)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuCommandPropertySize", (PyCFunction)MenuObj_GetMenuCommandPropertySize, 1,
-	 "(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)"},
+	 PyDoc_STR("(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"RemoveMenuCommandProperty", (PyCFunction)MenuObj_RemoveMenuCommandProperty, 1,
-	 "(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None"},
+	 PyDoc_STR("(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsMenuItemInvalid", (PyCFunction)MenuObj_IsMenuItemInvalid, 1,
-	 "(MenuItemIndex item) -> (Boolean _rv)"},
+	 PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"InvalidateMenuItems", (PyCFunction)MenuObj_InvalidateMenuItems, 1,
-	 "(MenuItemIndex firstItem, ItemCount numItems) -> None"},
+	 PyDoc_STR("(MenuItemIndex firstItem, ItemCount numItems) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"UpdateInvalidMenuItems", (PyCFunction)MenuObj_UpdateInvalidMenuItems, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateStandardFontMenu", (PyCFunction)MenuObj_CreateStandardFontMenu, 1,
-	 "(MenuItemIndex afterItem, MenuID firstHierMenuID, OptionBits options) -> (ItemCount outHierMenuCount)"},
+	 PyDoc_STR("(MenuItemIndex afterItem, MenuID firstHierMenuID, OptionBits options) -> (ItemCount outHierMenuCount)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"UpdateStandardFontMenu", (PyCFunction)MenuObj_UpdateStandardFontMenu, 1,
-	 "() -> (ItemCount outHierMenuCount)"},
+	 PyDoc_STR("() -> (ItemCount outHierMenuCount)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetFontFamilyFromMenuSelection", (PyCFunction)MenuObj_GetFontFamilyFromMenuSelection, 1,
-	 "(MenuItemIndex item) -> (FMFontFamily outFontFamily, FMFontStyle outStyle)"},
+	 PyDoc_STR("(MenuItemIndex item) -> (FMFontFamily outFontFamily, FMFontStyle outStyle)")},
 #endif
 	{"GetMenuID", (PyCFunction)MenuObj_GetMenuID, 1,
-	 "() -> (MenuID _rv)"},
+	 PyDoc_STR("() -> (MenuID _rv)")},
 	{"GetMenuWidth", (PyCFunction)MenuObj_GetMenuWidth, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"GetMenuHeight", (PyCFunction)MenuObj_GetMenuHeight, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"SetMenuID", (PyCFunction)MenuObj_SetMenuID, 1,
-	 "(MenuID menuID) -> None"},
+	 PyDoc_STR("(MenuID menuID) -> None")},
 	{"SetMenuWidth", (PyCFunction)MenuObj_SetMenuWidth, 1,
-	 "(SInt16 width) -> None"},
+	 PyDoc_STR("(SInt16 width) -> None")},
 	{"SetMenuHeight", (PyCFunction)MenuObj_SetMenuHeight, 1,
-	 "(SInt16 height) -> None"},
+	 PyDoc_STR("(SInt16 height) -> None")},
 	{"as_Resource", (PyCFunction)MenuObj_as_Resource, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"AppendMenu", (PyCFunction)MenuObj_AppendMenu, 1,
-	 "(Str255 data) -> None"},
+	 PyDoc_STR("(Str255 data) -> None")},
 	{"InsertMenu", (PyCFunction)MenuObj_InsertMenu, 1,
-	 "(short beforeID) -> None"},
+	 PyDoc_STR("(short beforeID) -> None")},
 	{"InsertMenuItem", (PyCFunction)MenuObj_InsertMenuItem, 1,
-	 "(Str255 itemString, short afterItem) -> None"},
+	 PyDoc_STR("(Str255 itemString, short afterItem) -> None")},
 	{"EnableMenuItem", (PyCFunction)MenuObj_EnableMenuItem, 1,
-	 "(UInt16 item) -> None"},
+	 PyDoc_STR("(UInt16 item) -> None")},
 	{"CheckMenuItem", (PyCFunction)MenuObj_CheckMenuItem, 1,
-	 "(short item, Boolean checked) -> None"},
+	 PyDoc_STR("(short item, Boolean checked) -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -3942,155 +3942,155 @@ static PyMethodDef Menu_methods[] = {
 
 #if !TARGET_API_MAC_CARBON
 	{"InitProcMenu", (PyCFunction)Menu_InitProcMenu, 1,
-	 "(short resID) -> None"},
+	 PyDoc_STR("(short resID) -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"InitMenus", (PyCFunction)Menu_InitMenus, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 	{"NewMenu", (PyCFunction)Menu_NewMenu, 1,
-	 "(MenuID menuID, Str255 menuTitle) -> (MenuHandle _rv)"},
+	 PyDoc_STR("(MenuID menuID, Str255 menuTitle) -> (MenuHandle _rv)")},
 	{"MacGetMenu", (PyCFunction)Menu_MacGetMenu, 1,
-	 "(short resourceID) -> (MenuHandle _rv)"},
+	 PyDoc_STR("(short resourceID) -> (MenuHandle _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"CreateNewMenu", (PyCFunction)Menu_CreateNewMenu, 1,
-	 "(MenuID inMenuID, MenuAttributes inMenuAttributes) -> (MenuHandle outMenuRef)"},
+	 PyDoc_STR("(MenuID inMenuID, MenuAttributes inMenuAttributes) -> (MenuHandle outMenuRef)")},
 #endif
 	{"MenuKey", (PyCFunction)Menu_MenuKey, 1,
-	 "(CharParameter ch) -> (long _rv)"},
+	 PyDoc_STR("(CharParameter ch) -> (long _rv)")},
 	{"MenuSelect", (PyCFunction)Menu_MenuSelect, 1,
-	 "(Point startPt) -> (long _rv)"},
+	 PyDoc_STR("(Point startPt) -> (long _rv)")},
 	{"MenuChoice", (PyCFunction)Menu_MenuChoice, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"MenuEvent", (PyCFunction)Menu_MenuEvent, 1,
-	 "(EventRecord inEvent) -> (UInt32 _rv)"},
+	 PyDoc_STR("(EventRecord inEvent) -> (UInt32 _rv)")},
 	{"GetMBarHeight", (PyCFunction)Menu_GetMBarHeight, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"MacDrawMenuBar", (PyCFunction)Menu_MacDrawMenuBar, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"InvalMenuBar", (PyCFunction)Menu_InvalMenuBar, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"HiliteMenu", (PyCFunction)Menu_HiliteMenu, 1,
-	 "(MenuID menuID) -> None"},
+	 PyDoc_STR("(MenuID menuID) -> None")},
 	{"GetNewMBar", (PyCFunction)Menu_GetNewMBar, 1,
-	 "(short menuBarID) -> (MenuBarHandle _rv)"},
+	 PyDoc_STR("(short menuBarID) -> (MenuBarHandle _rv)")},
 	{"GetMenuBar", (PyCFunction)Menu_GetMenuBar, 1,
-	 "() -> (MenuBarHandle _rv)"},
+	 PyDoc_STR("() -> (MenuBarHandle _rv)")},
 	{"SetMenuBar", (PyCFunction)Menu_SetMenuBar, 1,
-	 "(MenuBarHandle mbar) -> None"},
+	 PyDoc_STR("(MenuBarHandle mbar) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"DuplicateMenuBar", (PyCFunction)Menu_DuplicateMenuBar, 1,
-	 "(MenuBarHandle inMbar) -> (MenuBarHandle outMbar)"},
+	 PyDoc_STR("(MenuBarHandle inMbar) -> (MenuBarHandle outMbar)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"DisposeMenuBar", (PyCFunction)Menu_DisposeMenuBar, 1,
-	 "(MenuBarHandle inMbar) -> None"},
+	 PyDoc_STR("(MenuBarHandle inMbar) -> None")},
 #endif
 	{"GetMenuHandle", (PyCFunction)Menu_GetMenuHandle, 1,
-	 "(MenuID menuID) -> (MenuHandle _rv)"},
+	 PyDoc_STR("(MenuID menuID) -> (MenuHandle _rv)")},
 	{"MacDeleteMenu", (PyCFunction)Menu_MacDeleteMenu, 1,
-	 "(MenuID menuID) -> None"},
+	 PyDoc_STR("(MenuID menuID) -> None")},
 	{"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SetMenuFlash", (PyCFunction)Menu_SetMenuFlash, 1,
-	 "(short count) -> None"},
+	 PyDoc_STR("(short count) -> None")},
 #endif
 	{"SetMenuFlashCount", (PyCFunction)Menu_SetMenuFlashCount, 1,
-	 "(short count) -> None"},
+	 PyDoc_STR("(short count) -> None")},
 	{"FlashMenuBar", (PyCFunction)Menu_FlashMenuBar, 1,
-	 "(MenuID menuID) -> None"},
+	 PyDoc_STR("(MenuID menuID) -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SystemEdit", (PyCFunction)Menu_SystemEdit, 1,
-	 "(short editCmd) -> (Boolean _rv)"},
+	 PyDoc_STR("(short editCmd) -> (Boolean _rv)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"SystemMenu", (PyCFunction)Menu_SystemMenu, 1,
-	 "(long menuResult) -> None"},
+	 PyDoc_STR("(long menuResult) -> None")},
 #endif
 	{"IsMenuBarVisible", (PyCFunction)Menu_IsMenuBarVisible, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"ShowMenuBar", (PyCFunction)Menu_ShowMenuBar, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"HideMenuBar", (PyCFunction)Menu_HideMenuBar, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"AcquireRootMenu", (PyCFunction)Menu_AcquireRootMenu, 1,
-	 "() -> (MenuHandle _rv)"},
+	 PyDoc_STR("() -> (MenuHandle _rv)")},
 #endif
 	{"DeleteMCEntries", (PyCFunction)Menu_DeleteMCEntries, 1,
-	 "(MenuID menuID, short menuItem) -> None"},
+	 PyDoc_STR("(MenuID menuID, short menuItem) -> None")},
 	{"InitContextualMenus", (PyCFunction)Menu_InitContextualMenus, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"IsShowContextualMenuClick", (PyCFunction)Menu_IsShowContextualMenuClick, 1,
-	 "(EventRecord inEvent) -> (Boolean _rv)"},
+	 PyDoc_STR("(EventRecord inEvent) -> (Boolean _rv)")},
 	{"LMGetTheMenu", (PyCFunction)Menu_LMGetTheMenu, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"OpenDeskAcc", (PyCFunction)Menu_OpenDeskAcc, 1,
-	 "(Str255 name) -> None"},
+	 PyDoc_STR("(Str255 name) -> None")},
 #endif
 	{"as_Menu", (PyCFunction)Menu_as_Menu, 1,
-	 "(Handle h) -> (MenuHandle _rv)"},
+	 PyDoc_STR("(Handle h) -> (MenuHandle _rv)")},
 	{"GetMenu", (PyCFunction)Menu_GetMenu, 1,
-	 "(short resourceID) -> (MenuHandle _rv)"},
+	 PyDoc_STR("(short resourceID) -> (MenuHandle _rv)")},
 	{"DeleteMenu", (PyCFunction)Menu_DeleteMenu, 1,
-	 "(short menuID) -> None"},
+	 PyDoc_STR("(short menuID) -> None")},
 	{"DrawMenuBar", (PyCFunction)Menu_DrawMenuBar, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"CountMenuItemsWithCommandID", (PyCFunction)Menu_CountMenuItemsWithCommandID, 1,
-	 "(MenuHandle inMenu, MenuCommand inCommandID) -> (ItemCount _rv)"},
+	 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (ItemCount _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetIndMenuItemWithCommandID", (PyCFunction)Menu_GetIndMenuItemWithCommandID, 1,
-	 "(MenuHandle inMenu, MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)"},
+	 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"EnableMenuCommand", (PyCFunction)Menu_EnableMenuCommand, 1,
-	 "(MenuHandle inMenu, MenuCommand inCommandID) -> None"},
+	 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"DisableMenuCommand", (PyCFunction)Menu_DisableMenuCommand, 1,
-	 "(MenuHandle inMenu, MenuCommand inCommandID) -> None"},
+	 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsMenuCommandEnabled", (PyCFunction)Menu_IsMenuCommandEnabled, 1,
-	 "(MenuHandle inMenu, MenuCommand inCommandID) -> (Boolean _rv)"},
+	 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetMenuCommandMark", (PyCFunction)Menu_SetMenuCommandMark, 1,
-	 "(MenuHandle inMenu, MenuCommand inCommandID, UniChar inMark) -> None"},
+	 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, UniChar inMark) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuCommandMark", (PyCFunction)Menu_GetMenuCommandMark, 1,
-	 "(MenuHandle inMenu, MenuCommand inCommandID) -> (UniChar outMark)"},
+	 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (UniChar outMark)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetMenuCommandPropertySize", (PyCFunction)Menu_GetMenuCommandPropertySize, 1,
-	 "(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)"},
+	 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"RemoveMenuCommandProperty", (PyCFunction)Menu_RemoveMenuCommandProperty, 1,
-	 "(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None"},
+	 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None")},
 #endif
 	{NULL, NULL, 0}
 };
diff --git a/Mac/Modules/qd/_Qdmodule.c b/Mac/Modules/qd/_Qdmodule.c
index f7956b8..1084031 100644
--- a/Mac/Modules/qd/_Qdmodule.c
+++ b/Mac/Modules/qd/_Qdmodule.c
@@ -470,9 +470,9 @@ static PyObject *BMObj_putdata(BitMapObject *_self, PyObject *_args)
 
 static PyMethodDef BMObj_methods[] = {
 	{"getdata", (PyCFunction)BMObj_getdata, 1,
-	 "(int start, int size) -> string. Return bytes from the bitmap"},
+	 PyDoc_STR("(int start, int size) -> string. Return bytes from the bitmap")},
 	{"putdata", (PyCFunction)BMObj_putdata, 1,
-	 "(int start, string data). Store bytes into the bitmap"},
+	 PyDoc_STR("(int start, string data). Store bytes into the bitmap")},
 	{NULL, NULL, 0}
 };
 
@@ -6462,664 +6462,664 @@ static PyObject *Qd_RawBitMap(PyObject *_self, PyObject *_args)
 
 static PyMethodDef Qd_methods[] = {
 	{"MacSetPort", (PyCFunction)Qd_MacSetPort, 1,
-	 "(GrafPtr port) -> None"},
+	 PyDoc_STR("(GrafPtr port) -> None")},
 	{"GetPort", (PyCFunction)Qd_GetPort, 1,
-	 "() -> (GrafPtr port)"},
+	 PyDoc_STR("() -> (GrafPtr port)")},
 	{"GrafDevice", (PyCFunction)Qd_GrafDevice, 1,
-	 "(short device) -> None"},
+	 PyDoc_STR("(short device) -> None")},
 	{"SetPortBits", (PyCFunction)Qd_SetPortBits, 1,
-	 "(BitMapPtr bm) -> None"},
+	 PyDoc_STR("(BitMapPtr bm) -> None")},
 	{"PortSize", (PyCFunction)Qd_PortSize, 1,
-	 "(short width, short height) -> None"},
+	 PyDoc_STR("(short width, short height) -> None")},
 	{"MovePortTo", (PyCFunction)Qd_MovePortTo, 1,
-	 "(short leftGlobal, short topGlobal) -> None"},
+	 PyDoc_STR("(short leftGlobal, short topGlobal) -> None")},
 	{"SetOrigin", (PyCFunction)Qd_SetOrigin, 1,
-	 "(short h, short v) -> None"},
+	 PyDoc_STR("(short h, short v) -> None")},
 	{"SetClip", (PyCFunction)Qd_SetClip, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"GetClip", (PyCFunction)Qd_GetClip, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"ClipRect", (PyCFunction)Qd_ClipRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"BackPat", (PyCFunction)Qd_BackPat, 1,
-	 "(Pattern pat) -> None"},
+	 PyDoc_STR("(Pattern pat) -> None")},
 	{"InitCursor", (PyCFunction)Qd_InitCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"MacSetCursor", (PyCFunction)Qd_MacSetCursor, 1,
-	 "(Cursor crsr) -> None"},
+	 PyDoc_STR("(Cursor crsr) -> None")},
 	{"HideCursor", (PyCFunction)Qd_HideCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"MacShowCursor", (PyCFunction)Qd_MacShowCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"ObscureCursor", (PyCFunction)Qd_ObscureCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"HidePen", (PyCFunction)Qd_HidePen, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"ShowPen", (PyCFunction)Qd_ShowPen, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetPen", (PyCFunction)Qd_GetPen, 1,
-	 "() -> (Point pt)"},
+	 PyDoc_STR("() -> (Point pt)")},
 	{"GetPenState", (PyCFunction)Qd_GetPenState, 1,
-	 "() -> (PenState pnState)"},
+	 PyDoc_STR("() -> (PenState pnState)")},
 	{"SetPenState", (PyCFunction)Qd_SetPenState, 1,
-	 "(PenState pnState) -> None"},
+	 PyDoc_STR("(PenState pnState) -> None")},
 	{"PenSize", (PyCFunction)Qd_PenSize, 1,
-	 "(short width, short height) -> None"},
+	 PyDoc_STR("(short width, short height) -> None")},
 	{"PenMode", (PyCFunction)Qd_PenMode, 1,
-	 "(short mode) -> None"},
+	 PyDoc_STR("(short mode) -> None")},
 	{"PenPat", (PyCFunction)Qd_PenPat, 1,
-	 "(Pattern pat) -> None"},
+	 PyDoc_STR("(Pattern pat) -> None")},
 	{"PenNormal", (PyCFunction)Qd_PenNormal, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"MoveTo", (PyCFunction)Qd_MoveTo, 1,
-	 "(short h, short v) -> None"},
+	 PyDoc_STR("(short h, short v) -> None")},
 	{"Move", (PyCFunction)Qd_Move, 1,
-	 "(short dh, short dv) -> None"},
+	 PyDoc_STR("(short dh, short dv) -> None")},
 	{"MacLineTo", (PyCFunction)Qd_MacLineTo, 1,
-	 "(short h, short v) -> None"},
+	 PyDoc_STR("(short h, short v) -> None")},
 	{"Line", (PyCFunction)Qd_Line, 1,
-	 "(short dh, short dv) -> None"},
+	 PyDoc_STR("(short dh, short dv) -> None")},
 	{"ForeColor", (PyCFunction)Qd_ForeColor, 1,
-	 "(long color) -> None"},
+	 PyDoc_STR("(long color) -> None")},
 	{"BackColor", (PyCFunction)Qd_BackColor, 1,
-	 "(long color) -> None"},
+	 PyDoc_STR("(long color) -> None")},
 	{"ColorBit", (PyCFunction)Qd_ColorBit, 1,
-	 "(short whichBit) -> None"},
+	 PyDoc_STR("(short whichBit) -> None")},
 	{"MacSetRect", (PyCFunction)Qd_MacSetRect, 1,
-	 "(short left, short top, short right, short bottom) -> (Rect r)"},
+	 PyDoc_STR("(short left, short top, short right, short bottom) -> (Rect r)")},
 	{"MacOffsetRect", (PyCFunction)Qd_MacOffsetRect, 1,
-	 "(Rect r, short dh, short dv) -> (Rect r)"},
+	 PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
 	{"MacInsetRect", (PyCFunction)Qd_MacInsetRect, 1,
-	 "(Rect r, short dh, short dv) -> (Rect r)"},
+	 PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
 	{"SectRect", (PyCFunction)Qd_SectRect, 1,
-	 "(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)"},
+	 PyDoc_STR("(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)")},
 	{"MacUnionRect", (PyCFunction)Qd_MacUnionRect, 1,
-	 "(Rect src1, Rect src2) -> (Rect dstRect)"},
+	 PyDoc_STR("(Rect src1, Rect src2) -> (Rect dstRect)")},
 	{"MacEqualRect", (PyCFunction)Qd_MacEqualRect, 1,
-	 "(Rect rect1, Rect rect2) -> (Boolean _rv)"},
+	 PyDoc_STR("(Rect rect1, Rect rect2) -> (Boolean _rv)")},
 	{"EmptyRect", (PyCFunction)Qd_EmptyRect, 1,
-	 "(Rect r) -> (Boolean _rv)"},
+	 PyDoc_STR("(Rect r) -> (Boolean _rv)")},
 	{"MacFrameRect", (PyCFunction)Qd_MacFrameRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"PaintRect", (PyCFunction)Qd_PaintRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"EraseRect", (PyCFunction)Qd_EraseRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"MacInvertRect", (PyCFunction)Qd_MacInvertRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"MacFillRect", (PyCFunction)Qd_MacFillRect, 1,
-	 "(Rect r, Pattern pat) -> None"},
+	 PyDoc_STR("(Rect r, Pattern pat) -> None")},
 	{"FrameOval", (PyCFunction)Qd_FrameOval, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"PaintOval", (PyCFunction)Qd_PaintOval, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"EraseOval", (PyCFunction)Qd_EraseOval, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"InvertOval", (PyCFunction)Qd_InvertOval, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"FillOval", (PyCFunction)Qd_FillOval, 1,
-	 "(Rect r, Pattern pat) -> None"},
+	 PyDoc_STR("(Rect r, Pattern pat) -> None")},
 	{"FrameRoundRect", (PyCFunction)Qd_FrameRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
 	{"PaintRoundRect", (PyCFunction)Qd_PaintRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
 	{"EraseRoundRect", (PyCFunction)Qd_EraseRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
 	{"InvertRoundRect", (PyCFunction)Qd_InvertRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
 	{"FillRoundRect", (PyCFunction)Qd_FillRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight, Pattern pat) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight, Pattern pat) -> None")},
 	{"FrameArc", (PyCFunction)Qd_FrameArc, 1,
-	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
 	{"PaintArc", (PyCFunction)Qd_PaintArc, 1,
-	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
 	{"EraseArc", (PyCFunction)Qd_EraseArc, 1,
-	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
 	{"InvertArc", (PyCFunction)Qd_InvertArc, 1,
-	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
 	{"FillArc", (PyCFunction)Qd_FillArc, 1,
-	 "(Rect r, short startAngle, short arcAngle, Pattern pat) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle, Pattern pat) -> None")},
 	{"NewRgn", (PyCFunction)Qd_NewRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"OpenRgn", (PyCFunction)Qd_OpenRgn, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CloseRgn", (PyCFunction)Qd_CloseRgn, 1,
-	 "(RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle dstRgn) -> None")},
 	{"BitMapToRegion", (PyCFunction)Qd_BitMapToRegion, 1,
-	 "(RgnHandle region, BitMapPtr bMap) -> None"},
+	 PyDoc_STR("(RgnHandle region, BitMapPtr bMap) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"RgnToHandle", (PyCFunction)Qd_RgnToHandle, 1,
-	 "(RgnHandle region, Handle flattenedRgnDataHdl) -> None"},
+	 PyDoc_STR("(RgnHandle region, Handle flattenedRgnDataHdl) -> None")},
 #endif
 	{"DisposeRgn", (PyCFunction)Qd_DisposeRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"MacCopyRgn", (PyCFunction)Qd_MacCopyRgn, 1,
-	 "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgn, RgnHandle dstRgn) -> None")},
 	{"SetEmptyRgn", (PyCFunction)Qd_SetEmptyRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"MacSetRectRgn", (PyCFunction)Qd_MacSetRectRgn, 1,
-	 "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, short left, short top, short right, short bottom) -> None")},
 	{"RectRgn", (PyCFunction)Qd_RectRgn, 1,
-	 "(RgnHandle rgn, Rect r) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, Rect r) -> None")},
 	{"MacOffsetRgn", (PyCFunction)Qd_MacOffsetRgn, 1,
-	 "(RgnHandle rgn, short dh, short dv) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")},
 	{"InsetRgn", (PyCFunction)Qd_InsetRgn, 1,
-	 "(RgnHandle rgn, short dh, short dv) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")},
 	{"SectRgn", (PyCFunction)Qd_SectRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"MacUnionRgn", (PyCFunction)Qd_MacUnionRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"DiffRgn", (PyCFunction)Qd_DiffRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"MacXorRgn", (PyCFunction)Qd_MacXorRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"RectInRgn", (PyCFunction)Qd_RectInRgn, 1,
-	 "(Rect r, RgnHandle rgn) -> (Boolean _rv)"},
+	 PyDoc_STR("(Rect r, RgnHandle rgn) -> (Boolean _rv)")},
 	{"MacEqualRgn", (PyCFunction)Qd_MacEqualRgn, 1,
-	 "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"},
+	 PyDoc_STR("(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)")},
 	{"EmptyRgn", (PyCFunction)Qd_EmptyRgn, 1,
-	 "(RgnHandle rgn) -> (Boolean _rv)"},
+	 PyDoc_STR("(RgnHandle rgn) -> (Boolean _rv)")},
 	{"MacFrameRgn", (PyCFunction)Qd_MacFrameRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"MacPaintRgn", (PyCFunction)Qd_MacPaintRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"EraseRgn", (PyCFunction)Qd_EraseRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"MacInvertRgn", (PyCFunction)Qd_MacInvertRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"MacFillRgn", (PyCFunction)Qd_MacFillRgn, 1,
-	 "(RgnHandle rgn, Pattern pat) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, Pattern pat) -> None")},
 	{"ScrollRect", (PyCFunction)Qd_ScrollRect, 1,
-	 "(Rect r, short dh, short dv, RgnHandle updateRgn) -> None"},
+	 PyDoc_STR("(Rect r, short dh, short dv, RgnHandle updateRgn) -> None")},
 	{"CopyBits", (PyCFunction)Qd_CopyBits, 1,
-	 "(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
+	 PyDoc_STR("(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")},
 	{"CopyMask", (PyCFunction)Qd_CopyMask, 1,
-	 "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> None"},
+	 PyDoc_STR("(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> None")},
 	{"OpenPicture", (PyCFunction)Qd_OpenPicture, 1,
-	 "(Rect picFrame) -> (PicHandle _rv)"},
+	 PyDoc_STR("(Rect picFrame) -> (PicHandle _rv)")},
 	{"PicComment", (PyCFunction)Qd_PicComment, 1,
-	 "(short kind, short dataSize, Handle dataHandle) -> None"},
+	 PyDoc_STR("(short kind, short dataSize, Handle dataHandle) -> None")},
 	{"ClosePicture", (PyCFunction)Qd_ClosePicture, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DrawPicture", (PyCFunction)Qd_DrawPicture, 1,
-	 "(PicHandle myPicture, Rect dstRect) -> None"},
+	 PyDoc_STR("(PicHandle myPicture, Rect dstRect) -> None")},
 	{"KillPicture", (PyCFunction)Qd_KillPicture, 1,
-	 "(PicHandle myPicture) -> None"},
+	 PyDoc_STR("(PicHandle myPicture) -> None")},
 	{"OpenPoly", (PyCFunction)Qd_OpenPoly, 1,
-	 "() -> (PolyHandle _rv)"},
+	 PyDoc_STR("() -> (PolyHandle _rv)")},
 	{"ClosePoly", (PyCFunction)Qd_ClosePoly, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"KillPoly", (PyCFunction)Qd_KillPoly, 1,
-	 "(PolyHandle poly) -> None"},
+	 PyDoc_STR("(PolyHandle poly) -> None")},
 	{"OffsetPoly", (PyCFunction)Qd_OffsetPoly, 1,
-	 "(PolyHandle poly, short dh, short dv) -> None"},
+	 PyDoc_STR("(PolyHandle poly, short dh, short dv) -> None")},
 	{"FramePoly", (PyCFunction)Qd_FramePoly, 1,
-	 "(PolyHandle poly) -> None"},
+	 PyDoc_STR("(PolyHandle poly) -> None")},
 	{"PaintPoly", (PyCFunction)Qd_PaintPoly, 1,
-	 "(PolyHandle poly) -> None"},
+	 PyDoc_STR("(PolyHandle poly) -> None")},
 	{"ErasePoly", (PyCFunction)Qd_ErasePoly, 1,
-	 "(PolyHandle poly) -> None"},
+	 PyDoc_STR("(PolyHandle poly) -> None")},
 	{"InvertPoly", (PyCFunction)Qd_InvertPoly, 1,
-	 "(PolyHandle poly) -> None"},
+	 PyDoc_STR("(PolyHandle poly) -> None")},
 	{"FillPoly", (PyCFunction)Qd_FillPoly, 1,
-	 "(PolyHandle poly, Pattern pat) -> None"},
+	 PyDoc_STR("(PolyHandle poly, Pattern pat) -> None")},
 	{"SetPt", (PyCFunction)Qd_SetPt, 1,
-	 "(short h, short v) -> (Point pt)"},
+	 PyDoc_STR("(short h, short v) -> (Point pt)")},
 	{"LocalToGlobal", (PyCFunction)Qd_LocalToGlobal, 1,
-	 "(Point pt) -> (Point pt)"},
+	 PyDoc_STR("(Point pt) -> (Point pt)")},
 	{"GlobalToLocal", (PyCFunction)Qd_GlobalToLocal, 1,
-	 "(Point pt) -> (Point pt)"},
+	 PyDoc_STR("(Point pt) -> (Point pt)")},
 	{"Random", (PyCFunction)Qd_Random, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"MacGetPixel", (PyCFunction)Qd_MacGetPixel, 1,
-	 "(short h, short v) -> (Boolean _rv)"},
+	 PyDoc_STR("(short h, short v) -> (Boolean _rv)")},
 	{"ScalePt", (PyCFunction)Qd_ScalePt, 1,
-	 "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
+	 PyDoc_STR("(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)")},
 	{"MapPt", (PyCFunction)Qd_MapPt, 1,
-	 "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
+	 PyDoc_STR("(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)")},
 	{"MapRect", (PyCFunction)Qd_MapRect, 1,
-	 "(Rect r, Rect srcRect, Rect dstRect) -> (Rect r)"},
+	 PyDoc_STR("(Rect r, Rect srcRect, Rect dstRect) -> (Rect r)")},
 	{"MapRgn", (PyCFunction)Qd_MapRgn, 1,
-	 "(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None")},
 	{"MapPoly", (PyCFunction)Qd_MapPoly, 1,
-	 "(PolyHandle poly, Rect srcRect, Rect dstRect) -> None"},
+	 PyDoc_STR("(PolyHandle poly, Rect srcRect, Rect dstRect) -> None")},
 	{"StdBits", (PyCFunction)Qd_StdBits, 1,
-	 "(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
+	 PyDoc_STR("(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")},
 	{"AddPt", (PyCFunction)Qd_AddPt, 1,
-	 "(Point src, Point dst) -> (Point dst)"},
+	 PyDoc_STR("(Point src, Point dst) -> (Point dst)")},
 	{"EqualPt", (PyCFunction)Qd_EqualPt, 1,
-	 "(Point pt1, Point pt2) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt1, Point pt2) -> (Boolean _rv)")},
 	{"MacPtInRect", (PyCFunction)Qd_MacPtInRect, 1,
-	 "(Point pt, Rect r) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt, Rect r) -> (Boolean _rv)")},
 	{"Pt2Rect", (PyCFunction)Qd_Pt2Rect, 1,
-	 "(Point pt1, Point pt2) -> (Rect dstRect)"},
+	 PyDoc_STR("(Point pt1, Point pt2) -> (Rect dstRect)")},
 	{"PtToAngle", (PyCFunction)Qd_PtToAngle, 1,
-	 "(Rect r, Point pt) -> (short angle)"},
+	 PyDoc_STR("(Rect r, Point pt) -> (short angle)")},
 	{"SubPt", (PyCFunction)Qd_SubPt, 1,
-	 "(Point src, Point dst) -> (Point dst)"},
+	 PyDoc_STR("(Point src, Point dst) -> (Point dst)")},
 	{"PtInRgn", (PyCFunction)Qd_PtInRgn, 1,
-	 "(Point pt, RgnHandle rgn) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt, RgnHandle rgn) -> (Boolean _rv)")},
 	{"NewPixMap", (PyCFunction)Qd_NewPixMap, 1,
-	 "() -> (PixMapHandle _rv)"},
+	 PyDoc_STR("() -> (PixMapHandle _rv)")},
 	{"DisposePixMap", (PyCFunction)Qd_DisposePixMap, 1,
-	 "(PixMapHandle pm) -> None"},
+	 PyDoc_STR("(PixMapHandle pm) -> None")},
 	{"CopyPixMap", (PyCFunction)Qd_CopyPixMap, 1,
-	 "(PixMapHandle srcPM, PixMapHandle dstPM) -> None"},
+	 PyDoc_STR("(PixMapHandle srcPM, PixMapHandle dstPM) -> None")},
 	{"NewPixPat", (PyCFunction)Qd_NewPixPat, 1,
-	 "() -> (PixPatHandle _rv)"},
+	 PyDoc_STR("() -> (PixPatHandle _rv)")},
 	{"DisposePixPat", (PyCFunction)Qd_DisposePixPat, 1,
-	 "(PixPatHandle pp) -> None"},
+	 PyDoc_STR("(PixPatHandle pp) -> None")},
 	{"CopyPixPat", (PyCFunction)Qd_CopyPixPat, 1,
-	 "(PixPatHandle srcPP, PixPatHandle dstPP) -> None"},
+	 PyDoc_STR("(PixPatHandle srcPP, PixPatHandle dstPP) -> None")},
 	{"PenPixPat", (PyCFunction)Qd_PenPixPat, 1,
-	 "(PixPatHandle pp) -> None"},
+	 PyDoc_STR("(PixPatHandle pp) -> None")},
 	{"BackPixPat", (PyCFunction)Qd_BackPixPat, 1,
-	 "(PixPatHandle pp) -> None"},
+	 PyDoc_STR("(PixPatHandle pp) -> None")},
 	{"GetPixPat", (PyCFunction)Qd_GetPixPat, 1,
-	 "(short patID) -> (PixPatHandle _rv)"},
+	 PyDoc_STR("(short patID) -> (PixPatHandle _rv)")},
 	{"MakeRGBPat", (PyCFunction)Qd_MakeRGBPat, 1,
-	 "(PixPatHandle pp, RGBColor myColor) -> None"},
+	 PyDoc_STR("(PixPatHandle pp, RGBColor myColor) -> None")},
 	{"FillCRect", (PyCFunction)Qd_FillCRect, 1,
-	 "(Rect r, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(Rect r, PixPatHandle pp) -> None")},
 	{"FillCOval", (PyCFunction)Qd_FillCOval, 1,
-	 "(Rect r, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(Rect r, PixPatHandle pp) -> None")},
 	{"FillCRoundRect", (PyCFunction)Qd_FillCRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight, PixPatHandle pp) -> None")},
 	{"FillCArc", (PyCFunction)Qd_FillCArc, 1,
-	 "(Rect r, short startAngle, short arcAngle, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle, PixPatHandle pp) -> None")},
 	{"FillCRgn", (PyCFunction)Qd_FillCRgn, 1,
-	 "(RgnHandle rgn, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, PixPatHandle pp) -> None")},
 	{"FillCPoly", (PyCFunction)Qd_FillCPoly, 1,
-	 "(PolyHandle poly, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(PolyHandle poly, PixPatHandle pp) -> None")},
 	{"RGBForeColor", (PyCFunction)Qd_RGBForeColor, 1,
-	 "(RGBColor color) -> None"},
+	 PyDoc_STR("(RGBColor color) -> None")},
 	{"RGBBackColor", (PyCFunction)Qd_RGBBackColor, 1,
-	 "(RGBColor color) -> None"},
+	 PyDoc_STR("(RGBColor color) -> None")},
 	{"SetCPixel", (PyCFunction)Qd_SetCPixel, 1,
-	 "(short h, short v, RGBColor cPix) -> None"},
+	 PyDoc_STR("(short h, short v, RGBColor cPix) -> None")},
 	{"SetPortPix", (PyCFunction)Qd_SetPortPix, 1,
-	 "(PixMapHandle pm) -> None"},
+	 PyDoc_STR("(PixMapHandle pm) -> None")},
 	{"GetCPixel", (PyCFunction)Qd_GetCPixel, 1,
-	 "(short h, short v) -> (RGBColor cPix)"},
+	 PyDoc_STR("(short h, short v) -> (RGBColor cPix)")},
 	{"GetForeColor", (PyCFunction)Qd_GetForeColor, 1,
-	 "() -> (RGBColor color)"},
+	 PyDoc_STR("() -> (RGBColor color)")},
 	{"GetBackColor", (PyCFunction)Qd_GetBackColor, 1,
-	 "() -> (RGBColor color)"},
+	 PyDoc_STR("() -> (RGBColor color)")},
 	{"OpColor", (PyCFunction)Qd_OpColor, 1,
-	 "(RGBColor color) -> None"},
+	 PyDoc_STR("(RGBColor color) -> None")},
 	{"HiliteColor", (PyCFunction)Qd_HiliteColor, 1,
-	 "(RGBColor color) -> None"},
+	 PyDoc_STR("(RGBColor color) -> None")},
 	{"DisposeCTable", (PyCFunction)Qd_DisposeCTable, 1,
-	 "(CTabHandle cTable) -> None"},
+	 PyDoc_STR("(CTabHandle cTable) -> None")},
 	{"GetCTable", (PyCFunction)Qd_GetCTable, 1,
-	 "(short ctID) -> (CTabHandle _rv)"},
+	 PyDoc_STR("(short ctID) -> (CTabHandle _rv)")},
 	{"GetCCursor", (PyCFunction)Qd_GetCCursor, 1,
-	 "(short crsrID) -> (CCrsrHandle _rv)"},
+	 PyDoc_STR("(short crsrID) -> (CCrsrHandle _rv)")},
 	{"SetCCursor", (PyCFunction)Qd_SetCCursor, 1,
-	 "(CCrsrHandle cCrsr) -> None"},
+	 PyDoc_STR("(CCrsrHandle cCrsr) -> None")},
 	{"AllocCursor", (PyCFunction)Qd_AllocCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DisposeCCursor", (PyCFunction)Qd_DisposeCCursor, 1,
-	 "(CCrsrHandle cCrsr) -> None"},
+	 PyDoc_STR("(CCrsrHandle cCrsr) -> None")},
 	{"GetMaxDevice", (PyCFunction)Qd_GetMaxDevice, 1,
-	 "(Rect globalRect) -> (GDHandle _rv)"},
+	 PyDoc_STR("(Rect globalRect) -> (GDHandle _rv)")},
 	{"GetCTSeed", (PyCFunction)Qd_GetCTSeed, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetDeviceList", (PyCFunction)Qd_GetDeviceList, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"GetMainDevice", (PyCFunction)Qd_GetMainDevice, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"GetNextDevice", (PyCFunction)Qd_GetNextDevice, 1,
-	 "(GDHandle curDevice) -> (GDHandle _rv)"},
+	 PyDoc_STR("(GDHandle curDevice) -> (GDHandle _rv)")},
 	{"TestDeviceAttribute", (PyCFunction)Qd_TestDeviceAttribute, 1,
-	 "(GDHandle gdh, short attribute) -> (Boolean _rv)"},
+	 PyDoc_STR("(GDHandle gdh, short attribute) -> (Boolean _rv)")},
 	{"SetDeviceAttribute", (PyCFunction)Qd_SetDeviceAttribute, 1,
-	 "(GDHandle gdh, short attribute, Boolean value) -> None"},
+	 PyDoc_STR("(GDHandle gdh, short attribute, Boolean value) -> None")},
 	{"InitGDevice", (PyCFunction)Qd_InitGDevice, 1,
-	 "(short qdRefNum, long mode, GDHandle gdh) -> None"},
+	 PyDoc_STR("(short qdRefNum, long mode, GDHandle gdh) -> None")},
 	{"NewGDevice", (PyCFunction)Qd_NewGDevice, 1,
-	 "(short refNum, long mode) -> (GDHandle _rv)"},
+	 PyDoc_STR("(short refNum, long mode) -> (GDHandle _rv)")},
 	{"DisposeGDevice", (PyCFunction)Qd_DisposeGDevice, 1,
-	 "(GDHandle gdh) -> None"},
+	 PyDoc_STR("(GDHandle gdh) -> None")},
 	{"SetGDevice", (PyCFunction)Qd_SetGDevice, 1,
-	 "(GDHandle gd) -> None"},
+	 PyDoc_STR("(GDHandle gd) -> None")},
 	{"GetGDevice", (PyCFunction)Qd_GetGDevice, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"Color2Index", (PyCFunction)Qd_Color2Index, 1,
-	 "(RGBColor myColor) -> (long _rv)"},
+	 PyDoc_STR("(RGBColor myColor) -> (long _rv)")},
 	{"Index2Color", (PyCFunction)Qd_Index2Color, 1,
-	 "(long index) -> (RGBColor aColor)"},
+	 PyDoc_STR("(long index) -> (RGBColor aColor)")},
 	{"InvertColor", (PyCFunction)Qd_InvertColor, 1,
-	 "() -> (RGBColor myColor)"},
+	 PyDoc_STR("() -> (RGBColor myColor)")},
 	{"RealColor", (PyCFunction)Qd_RealColor, 1,
-	 "(RGBColor color) -> (Boolean _rv)"},
+	 PyDoc_STR("(RGBColor color) -> (Boolean _rv)")},
 	{"GetSubTable", (PyCFunction)Qd_GetSubTable, 1,
-	 "(CTabHandle myColors, short iTabRes, CTabHandle targetTbl) -> None"},
+	 PyDoc_STR("(CTabHandle myColors, short iTabRes, CTabHandle targetTbl) -> None")},
 	{"MakeITable", (PyCFunction)Qd_MakeITable, 1,
-	 "(CTabHandle cTabH, ITabHandle iTabH, short res) -> None"},
+	 PyDoc_STR("(CTabHandle cTabH, ITabHandle iTabH, short res) -> None")},
 	{"SetClientID", (PyCFunction)Qd_SetClientID, 1,
-	 "(short id) -> None"},
+	 PyDoc_STR("(short id) -> None")},
 	{"ProtectEntry", (PyCFunction)Qd_ProtectEntry, 1,
-	 "(short index, Boolean protect) -> None"},
+	 PyDoc_STR("(short index, Boolean protect) -> None")},
 	{"ReserveEntry", (PyCFunction)Qd_ReserveEntry, 1,
-	 "(short index, Boolean reserve) -> None"},
+	 PyDoc_STR("(short index, Boolean reserve) -> None")},
 	{"QDError", (PyCFunction)Qd_QDError, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"CopyDeepMask", (PyCFunction)Qd_CopyDeepMask, 1,
-	 "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
+	 PyDoc_STR("(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")},
 	{"GetPattern", (PyCFunction)Qd_GetPattern, 1,
-	 "(short patternID) -> (PatHandle _rv)"},
+	 PyDoc_STR("(short patternID) -> (PatHandle _rv)")},
 	{"MacGetCursor", (PyCFunction)Qd_MacGetCursor, 1,
-	 "(short cursorID) -> (CursHandle _rv)"},
+	 PyDoc_STR("(short cursorID) -> (CursHandle _rv)")},
 	{"GetPicture", (PyCFunction)Qd_GetPicture, 1,
-	 "(short pictureID) -> (PicHandle _rv)"},
+	 PyDoc_STR("(short pictureID) -> (PicHandle _rv)")},
 	{"DeltaPoint", (PyCFunction)Qd_DeltaPoint, 1,
-	 "(Point ptA, Point ptB) -> (long _rv)"},
+	 PyDoc_STR("(Point ptA, Point ptB) -> (long _rv)")},
 	{"ShieldCursor", (PyCFunction)Qd_ShieldCursor, 1,
-	 "(Rect shieldRect, Point offsetPt) -> None"},
+	 PyDoc_STR("(Rect shieldRect, Point offsetPt) -> None")},
 	{"ScreenRes", (PyCFunction)Qd_ScreenRes, 1,
-	 "() -> (short scrnHRes, short scrnVRes)"},
+	 PyDoc_STR("() -> (short scrnHRes, short scrnVRes)")},
 	{"GetIndPattern", (PyCFunction)Qd_GetIndPattern, 1,
-	 "(short patternListID, short index) -> (Pattern thePat)"},
+	 PyDoc_STR("(short patternListID, short index) -> (Pattern thePat)")},
 	{"SlopeFromAngle", (PyCFunction)Qd_SlopeFromAngle, 1,
-	 "(short angle) -> (Fixed _rv)"},
+	 PyDoc_STR("(short angle) -> (Fixed _rv)")},
 	{"AngleFromSlope", (PyCFunction)Qd_AngleFromSlope, 1,
-	 "(Fixed slope) -> (short _rv)"},
+	 PyDoc_STR("(Fixed slope) -> (short _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"IsValidPort", (PyCFunction)Qd_IsValidPort, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 #endif
 	{"GetPortPixMap", (PyCFunction)Qd_GetPortPixMap, 1,
-	 "(CGrafPtr port) -> (PixMapHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (PixMapHandle _rv)")},
 	{"GetPortBitMapForCopyBits", (PyCFunction)Qd_GetPortBitMapForCopyBits, 1,
-	 "(CGrafPtr port) -> (const BitMap * _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (const BitMap * _rv)")},
 	{"GetPortBounds", (PyCFunction)Qd_GetPortBounds, 1,
-	 "(CGrafPtr port) -> (Rect rect)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Rect rect)")},
 	{"GetPortForeColor", (PyCFunction)Qd_GetPortForeColor, 1,
-	 "(CGrafPtr port) -> (RGBColor foreColor)"},
+	 PyDoc_STR("(CGrafPtr port) -> (RGBColor foreColor)")},
 	{"GetPortBackColor", (PyCFunction)Qd_GetPortBackColor, 1,
-	 "(CGrafPtr port) -> (RGBColor backColor)"},
+	 PyDoc_STR("(CGrafPtr port) -> (RGBColor backColor)")},
 	{"GetPortOpColor", (PyCFunction)Qd_GetPortOpColor, 1,
-	 "(CGrafPtr port) -> (RGBColor opColor)"},
+	 PyDoc_STR("(CGrafPtr port) -> (RGBColor opColor)")},
 	{"GetPortHiliteColor", (PyCFunction)Qd_GetPortHiliteColor, 1,
-	 "(CGrafPtr port) -> (RGBColor hiliteColor)"},
+	 PyDoc_STR("(CGrafPtr port) -> (RGBColor hiliteColor)")},
 	{"GetPortTextFont", (PyCFunction)Qd_GetPortTextFont, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortTextFace", (PyCFunction)Qd_GetPortTextFace, 1,
-	 "(CGrafPtr port) -> (Style _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Style _rv)")},
 	{"GetPortTextMode", (PyCFunction)Qd_GetPortTextMode, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortTextSize", (PyCFunction)Qd_GetPortTextSize, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortChExtra", (PyCFunction)Qd_GetPortChExtra, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortFracHPenLocation", (PyCFunction)Qd_GetPortFracHPenLocation, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortSpExtra", (PyCFunction)Qd_GetPortSpExtra, 1,
-	 "(CGrafPtr port) -> (Fixed _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Fixed _rv)")},
 	{"GetPortPenVisibility", (PyCFunction)Qd_GetPortPenVisibility, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortVisibleRegion", (PyCFunction)Qd_GetPortVisibleRegion, 1,
-	 "(CGrafPtr port, RgnHandle visRgn) -> (RgnHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle visRgn) -> (RgnHandle _rv)")},
 	{"GetPortClipRegion", (PyCFunction)Qd_GetPortClipRegion, 1,
-	 "(CGrafPtr port, RgnHandle clipRgn) -> (RgnHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle clipRgn) -> (RgnHandle _rv)")},
 	{"GetPortBackPixPat", (PyCFunction)Qd_GetPortBackPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle backPattern) -> (PixPatHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle backPattern) -> (PixPatHandle _rv)")},
 	{"GetPortPenPixPat", (PyCFunction)Qd_GetPortPenPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle penPattern) -> (PixPatHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> (PixPatHandle _rv)")},
 	{"GetPortFillPixPat", (PyCFunction)Qd_GetPortFillPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle fillPattern) -> (PixPatHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle fillPattern) -> (PixPatHandle _rv)")},
 	{"GetPortPenSize", (PyCFunction)Qd_GetPortPenSize, 1,
-	 "(CGrafPtr port, Point penSize) -> (Point penSize)"},
+	 PyDoc_STR("(CGrafPtr port, Point penSize) -> (Point penSize)")},
 	{"GetPortPenMode", (PyCFunction)Qd_GetPortPenMode, 1,
-	 "(CGrafPtr port) -> (SInt32 _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (SInt32 _rv)")},
 	{"GetPortPenLocation", (PyCFunction)Qd_GetPortPenLocation, 1,
-	 "(CGrafPtr port, Point penLocation) -> (Point penLocation)"},
+	 PyDoc_STR("(CGrafPtr port, Point penLocation) -> (Point penLocation)")},
 	{"IsPortRegionBeingDefined", (PyCFunction)Qd_IsPortRegionBeingDefined, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 	{"IsPortPictureBeingDefined", (PyCFunction)Qd_IsPortPictureBeingDefined, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"IsPortPolyBeingDefined", (PyCFunction)Qd_IsPortPolyBeingDefined, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsPortOffscreen", (PyCFunction)Qd_IsPortOffscreen, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsPortColor", (PyCFunction)Qd_IsPortColor, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 #endif
 	{"SetPortBounds", (PyCFunction)Qd_SetPortBounds, 1,
-	 "(CGrafPtr port, Rect rect) -> None"},
+	 PyDoc_STR("(CGrafPtr port, Rect rect) -> None")},
 	{"SetPortOpColor", (PyCFunction)Qd_SetPortOpColor, 1,
-	 "(CGrafPtr port, RGBColor opColor) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RGBColor opColor) -> None")},
 	{"SetPortVisibleRegion", (PyCFunction)Qd_SetPortVisibleRegion, 1,
-	 "(CGrafPtr port, RgnHandle visRgn) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle visRgn) -> None")},
 	{"SetPortClipRegion", (PyCFunction)Qd_SetPortClipRegion, 1,
-	 "(CGrafPtr port, RgnHandle clipRgn) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle clipRgn) -> None")},
 	{"SetPortPenPixPat", (PyCFunction)Qd_SetPortPenPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle penPattern) -> None"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> None")},
 	{"SetPortFillPixPat", (PyCFunction)Qd_SetPortFillPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle penPattern) -> None"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> None")},
 	{"SetPortBackPixPat", (PyCFunction)Qd_SetPortBackPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle backPattern) -> None"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle backPattern) -> None")},
 	{"SetPortPenSize", (PyCFunction)Qd_SetPortPenSize, 1,
-	 "(CGrafPtr port, Point penSize) -> None"},
+	 PyDoc_STR("(CGrafPtr port, Point penSize) -> None")},
 	{"SetPortPenMode", (PyCFunction)Qd_SetPortPenMode, 1,
-	 "(CGrafPtr port, SInt32 penMode) -> None"},
+	 PyDoc_STR("(CGrafPtr port, SInt32 penMode) -> None")},
 	{"SetPortFracHPenLocation", (PyCFunction)Qd_SetPortFracHPenLocation, 1,
-	 "(CGrafPtr port, short pnLocHFrac) -> None"},
+	 PyDoc_STR("(CGrafPtr port, short pnLocHFrac) -> None")},
 	{"GetPixBounds", (PyCFunction)Qd_GetPixBounds, 1,
-	 "(PixMapHandle pixMap) -> (Rect bounds)"},
+	 PyDoc_STR("(PixMapHandle pixMap) -> (Rect bounds)")},
 	{"GetPixDepth", (PyCFunction)Qd_GetPixDepth, 1,
-	 "(PixMapHandle pixMap) -> (short _rv)"},
+	 PyDoc_STR("(PixMapHandle pixMap) -> (short _rv)")},
 	{"GetQDGlobalsRandomSeed", (PyCFunction)Qd_GetQDGlobalsRandomSeed, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetQDGlobalsScreenBits", (PyCFunction)Qd_GetQDGlobalsScreenBits, 1,
-	 "() -> (BitMap screenBits)"},
+	 PyDoc_STR("() -> (BitMap screenBits)")},
 	{"GetQDGlobalsArrow", (PyCFunction)Qd_GetQDGlobalsArrow, 1,
-	 "() -> (Cursor arrow)"},
+	 PyDoc_STR("() -> (Cursor arrow)")},
 	{"GetQDGlobalsDarkGray", (PyCFunction)Qd_GetQDGlobalsDarkGray, 1,
-	 "() -> (Pattern dkGray)"},
+	 PyDoc_STR("() -> (Pattern dkGray)")},
 	{"GetQDGlobalsLightGray", (PyCFunction)Qd_GetQDGlobalsLightGray, 1,
-	 "() -> (Pattern ltGray)"},
+	 PyDoc_STR("() -> (Pattern ltGray)")},
 	{"GetQDGlobalsGray", (PyCFunction)Qd_GetQDGlobalsGray, 1,
-	 "() -> (Pattern gray)"},
+	 PyDoc_STR("() -> (Pattern gray)")},
 	{"GetQDGlobalsBlack", (PyCFunction)Qd_GetQDGlobalsBlack, 1,
-	 "() -> (Pattern black)"},
+	 PyDoc_STR("() -> (Pattern black)")},
 	{"GetQDGlobalsWhite", (PyCFunction)Qd_GetQDGlobalsWhite, 1,
-	 "() -> (Pattern white)"},
+	 PyDoc_STR("() -> (Pattern white)")},
 	{"GetQDGlobalsThePort", (PyCFunction)Qd_GetQDGlobalsThePort, 1,
-	 "() -> (CGrafPtr _rv)"},
+	 PyDoc_STR("() -> (CGrafPtr _rv)")},
 	{"SetQDGlobalsRandomSeed", (PyCFunction)Qd_SetQDGlobalsRandomSeed, 1,
-	 "(long randomSeed) -> None"},
+	 PyDoc_STR("(long randomSeed) -> None")},
 	{"SetQDGlobalsArrow", (PyCFunction)Qd_SetQDGlobalsArrow, 1,
-	 "(Cursor arrow) -> None"},
+	 PyDoc_STR("(Cursor arrow) -> None")},
 	{"GetRegionBounds", (PyCFunction)Qd_GetRegionBounds, 1,
-	 "(RgnHandle region) -> (Rect bounds)"},
+	 PyDoc_STR("(RgnHandle region) -> (Rect bounds)")},
 
 #if TARGET_API_MAC_CARBON
 	{"IsRegionRectangular", (PyCFunction)Qd_IsRegionRectangular, 1,
-	 "(RgnHandle region) -> (Boolean _rv)"},
+	 PyDoc_STR("(RgnHandle region) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateNewPort", (PyCFunction)Qd_CreateNewPort, 1,
-	 "() -> (CGrafPtr _rv)"},
+	 PyDoc_STR("() -> (CGrafPtr _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"DisposePort", (PyCFunction)Qd_DisposePort, 1,
-	 "(CGrafPtr port) -> None"},
+	 PyDoc_STR("(CGrafPtr port) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetQDError", (PyCFunction)Qd_SetQDError, 1,
-	 "(OSErr err) -> None"},
+	 PyDoc_STR("(OSErr err) -> None")},
 #endif
 	{"QDIsPortBuffered", (PyCFunction)Qd_QDIsPortBuffered, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 	{"QDIsPortBufferDirty", (PyCFunction)Qd_QDIsPortBufferDirty, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 	{"QDFlushPortBuffer", (PyCFunction)Qd_QDFlushPortBuffer, 1,
-	 "(CGrafPtr port, RgnHandle region) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle region) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"QDGetDirtyRegion", (PyCFunction)Qd_QDGetDirtyRegion, 1,
-	 "(CGrafPtr port, RgnHandle rgn) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle rgn) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"QDSetDirtyRegion", (PyCFunction)Qd_QDSetDirtyRegion, 1,
-	 "(CGrafPtr port, RgnHandle rgn) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle rgn) -> None")},
 #endif
 	{"LMGetScrVRes", (PyCFunction)Qd_LMGetScrVRes, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"LMSetScrVRes", (PyCFunction)Qd_LMSetScrVRes, 1,
-	 "(SInt16 value) -> None"},
+	 PyDoc_STR("(SInt16 value) -> None")},
 	{"LMGetScrHRes", (PyCFunction)Qd_LMGetScrHRes, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"LMSetScrHRes", (PyCFunction)Qd_LMSetScrHRes, 1,
-	 "(SInt16 value) -> None"},
+	 PyDoc_STR("(SInt16 value) -> None")},
 	{"LMGetMainDevice", (PyCFunction)Qd_LMGetMainDevice, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"LMSetMainDevice", (PyCFunction)Qd_LMSetMainDevice, 1,
-	 "(GDHandle value) -> None"},
+	 PyDoc_STR("(GDHandle value) -> None")},
 	{"LMGetDeviceList", (PyCFunction)Qd_LMGetDeviceList, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"LMSetDeviceList", (PyCFunction)Qd_LMSetDeviceList, 1,
-	 "(GDHandle value) -> None"},
+	 PyDoc_STR("(GDHandle value) -> None")},
 	{"LMGetQDColors", (PyCFunction)Qd_LMGetQDColors, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"LMSetQDColors", (PyCFunction)Qd_LMSetQDColors, 1,
-	 "(Handle value) -> None"},
+	 PyDoc_STR("(Handle value) -> None")},
 	{"LMGetWidthListHand", (PyCFunction)Qd_LMGetWidthListHand, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"LMSetWidthListHand", (PyCFunction)Qd_LMSetWidthListHand, 1,
-	 "(Handle value) -> None"},
+	 PyDoc_STR("(Handle value) -> None")},
 	{"LMGetHiliteMode", (PyCFunction)Qd_LMGetHiliteMode, 1,
-	 "() -> (UInt8 _rv)"},
+	 PyDoc_STR("() -> (UInt8 _rv)")},
 	{"LMSetHiliteMode", (PyCFunction)Qd_LMSetHiliteMode, 1,
-	 "(UInt8 value) -> None"},
+	 PyDoc_STR("(UInt8 value) -> None")},
 	{"LMGetWidthTabHandle", (PyCFunction)Qd_LMGetWidthTabHandle, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"LMSetWidthTabHandle", (PyCFunction)Qd_LMSetWidthTabHandle, 1,
-	 "(Handle value) -> None"},
+	 PyDoc_STR("(Handle value) -> None")},
 	{"LMGetLastSPExtra", (PyCFunction)Qd_LMGetLastSPExtra, 1,
-	 "() -> (SInt32 _rv)"},
+	 PyDoc_STR("() -> (SInt32 _rv)")},
 	{"LMSetLastSPExtra", (PyCFunction)Qd_LMSetLastSPExtra, 1,
-	 "(SInt32 value) -> None"},
+	 PyDoc_STR("(SInt32 value) -> None")},
 	{"LMGetLastFOND", (PyCFunction)Qd_LMGetLastFOND, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"LMSetLastFOND", (PyCFunction)Qd_LMSetLastFOND, 1,
-	 "(Handle value) -> None"},
+	 PyDoc_STR("(Handle value) -> None")},
 	{"LMGetFractEnable", (PyCFunction)Qd_LMGetFractEnable, 1,
-	 "() -> (UInt8 _rv)"},
+	 PyDoc_STR("() -> (UInt8 _rv)")},
 	{"LMSetFractEnable", (PyCFunction)Qd_LMSetFractEnable, 1,
-	 "(UInt8 value) -> None"},
+	 PyDoc_STR("(UInt8 value) -> None")},
 	{"LMGetTheGDevice", (PyCFunction)Qd_LMGetTheGDevice, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"LMSetTheGDevice", (PyCFunction)Qd_LMSetTheGDevice, 1,
-	 "(GDHandle value) -> None"},
+	 PyDoc_STR("(GDHandle value) -> None")},
 	{"LMGetHiliteRGB", (PyCFunction)Qd_LMGetHiliteRGB, 1,
-	 "() -> (RGBColor hiliteRGBValue)"},
+	 PyDoc_STR("() -> (RGBColor hiliteRGBValue)")},
 	{"LMSetHiliteRGB", (PyCFunction)Qd_LMSetHiliteRGB, 1,
-	 "(RGBColor hiliteRGBValue) -> None"},
+	 PyDoc_STR("(RGBColor hiliteRGBValue) -> None")},
 	{"LMGetCursorNew", (PyCFunction)Qd_LMGetCursorNew, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"LMSetCursorNew", (PyCFunction)Qd_LMSetCursorNew, 1,
-	 "(Boolean value) -> None"},
+	 PyDoc_STR("(Boolean value) -> None")},
 	{"TextFont", (PyCFunction)Qd_TextFont, 1,
-	 "(short font) -> None"},
+	 PyDoc_STR("(short font) -> None")},
 	{"TextFace", (PyCFunction)Qd_TextFace, 1,
-	 "(StyleParameter face) -> None"},
+	 PyDoc_STR("(StyleParameter face) -> None")},
 	{"TextMode", (PyCFunction)Qd_TextMode, 1,
-	 "(short mode) -> None"},
+	 PyDoc_STR("(short mode) -> None")},
 	{"TextSize", (PyCFunction)Qd_TextSize, 1,
-	 "(short size) -> None"},
+	 PyDoc_STR("(short size) -> None")},
 	{"SpaceExtra", (PyCFunction)Qd_SpaceExtra, 1,
-	 "(Fixed extra) -> None"},
+	 PyDoc_STR("(Fixed extra) -> None")},
 	{"DrawChar", (PyCFunction)Qd_DrawChar, 1,
-	 "(CharParameter ch) -> None"},
+	 PyDoc_STR("(CharParameter ch) -> None")},
 	{"DrawString", (PyCFunction)Qd_DrawString, 1,
-	 "(Str255 s) -> None"},
+	 PyDoc_STR("(Str255 s) -> None")},
 	{"MacDrawText", (PyCFunction)Qd_MacDrawText, 1,
-	 "(Buffer textBuf, short firstByte, short byteCount) -> None"},
+	 PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> None")},
 	{"CharWidth", (PyCFunction)Qd_CharWidth, 1,
-	 "(CharParameter ch) -> (short _rv)"},
+	 PyDoc_STR("(CharParameter ch) -> (short _rv)")},
 	{"StringWidth", (PyCFunction)Qd_StringWidth, 1,
-	 "(Str255 s) -> (short _rv)"},
+	 PyDoc_STR("(Str255 s) -> (short _rv)")},
 	{"TextWidth", (PyCFunction)Qd_TextWidth, 1,
-	 "(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)"},
+	 PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)")},
 	{"GetFontInfo", (PyCFunction)Qd_GetFontInfo, 1,
-	 "() -> (FontInfo info)"},
+	 PyDoc_STR("() -> (FontInfo info)")},
 	{"CharExtra", (PyCFunction)Qd_CharExtra, 1,
-	 "(Fixed extra) -> None"},
+	 PyDoc_STR("(Fixed extra) -> None")},
 	{"TruncString", (PyCFunction)Qd_TruncString, 1,
-	 "(short width, Str255 theString, TruncCode truncWhere) -> (short _rv)"},
+	 PyDoc_STR("(short width, Str255 theString, TruncCode truncWhere) -> (short _rv)")},
 	{"SetPort", (PyCFunction)Qd_SetPort, 1,
-	 "(GrafPtr thePort) -> None"},
+	 PyDoc_STR("(GrafPtr thePort) -> None")},
 	{"GetCursor", (PyCFunction)Qd_GetCursor, 1,
-	 "(short cursorID) -> (CursHandle _rv)"},
+	 PyDoc_STR("(short cursorID) -> (CursHandle _rv)")},
 	{"SetCursor", (PyCFunction)Qd_SetCursor, 1,
-	 "(Cursor crsr) -> None"},
+	 PyDoc_STR("(Cursor crsr) -> None")},
 	{"ShowCursor", (PyCFunction)Qd_ShowCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"LineTo", (PyCFunction)Qd_LineTo, 1,
-	 "(short h, short v) -> None"},
+	 PyDoc_STR("(short h, short v) -> None")},
 	{"SetRect", (PyCFunction)Qd_SetRect, 1,
-	 "(short left, short top, short right, short bottom) -> (Rect r)"},
+	 PyDoc_STR("(short left, short top, short right, short bottom) -> (Rect r)")},
 	{"OffsetRect", (PyCFunction)Qd_OffsetRect, 1,
-	 "(Rect r, short dh, short dv) -> (Rect r)"},
+	 PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
 	{"InsetRect", (PyCFunction)Qd_InsetRect, 1,
-	 "(Rect r, short dh, short dv) -> (Rect r)"},
+	 PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
 	{"UnionRect", (PyCFunction)Qd_UnionRect, 1,
-	 "(Rect src1, Rect src2) -> (Rect dstRect)"},
+	 PyDoc_STR("(Rect src1, Rect src2) -> (Rect dstRect)")},
 	{"EqualRect", (PyCFunction)Qd_EqualRect, 1,
-	 "(Rect rect1, Rect rect2) -> (Boolean _rv)"},
+	 PyDoc_STR("(Rect rect1, Rect rect2) -> (Boolean _rv)")},
 	{"FrameRect", (PyCFunction)Qd_FrameRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"InvertRect", (PyCFunction)Qd_InvertRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"FillRect", (PyCFunction)Qd_FillRect, 1,
-	 "(Rect r, Pattern pat) -> None"},
+	 PyDoc_STR("(Rect r, Pattern pat) -> None")},
 	{"CopyRgn", (PyCFunction)Qd_CopyRgn, 1,
-	 "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgn, RgnHandle dstRgn) -> None")},
 	{"SetRectRgn", (PyCFunction)Qd_SetRectRgn, 1,
-	 "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, short left, short top, short right, short bottom) -> None")},
 	{"OffsetRgn", (PyCFunction)Qd_OffsetRgn, 1,
-	 "(RgnHandle rgn, short dh, short dv) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")},
 	{"UnionRgn", (PyCFunction)Qd_UnionRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"XorRgn", (PyCFunction)Qd_XorRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"EqualRgn", (PyCFunction)Qd_EqualRgn, 1,
-	 "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"},
+	 PyDoc_STR("(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)")},
 	{"FrameRgn", (PyCFunction)Qd_FrameRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"PaintRgn", (PyCFunction)Qd_PaintRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"InvertRgn", (PyCFunction)Qd_InvertRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"FillRgn", (PyCFunction)Qd_FillRgn, 1,
-	 "(RgnHandle rgn, Pattern pat) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, Pattern pat) -> None")},
 	{"GetPixel", (PyCFunction)Qd_GetPixel, 1,
-	 "(short h, short v) -> (Boolean _rv)"},
+	 PyDoc_STR("(short h, short v) -> (Boolean _rv)")},
 	{"PtInRect", (PyCFunction)Qd_PtInRect, 1,
-	 "(Point pt, Rect r) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt, Rect r) -> (Boolean _rv)")},
 	{"DrawText", (PyCFunction)Qd_DrawText, 1,
-	 "(Buffer textBuf, short firstByte, short byteCount) -> None"},
+	 PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> None")},
 	{"BitMap", (PyCFunction)Qd_BitMap, 1,
-	 "Take (string, int, Rect) argument and create BitMap"},
+	 PyDoc_STR("Take (string, int, Rect) argument and create BitMap")},
 	{"RawBitMap", (PyCFunction)Qd_RawBitMap, 1,
-	 "Take string BitMap and turn into BitMap object"},
+	 PyDoc_STR("Take string BitMap and turn into BitMap object")},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/qdoffs/_Qdoffsmodule.c b/Mac/Modules/qdoffs/_Qdoffsmodule.c
index 2f951d1..c75daac 100644
--- a/Mac/Modules/qdoffs/_Qdoffsmodule.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/qt/_Qtmodule.c b/Mac/Modules/qt/_Qtmodule.c
index 1f6dbbb..687aaee 100644
--- a/Mac/Modules/qt/_Qtmodule.c
+++ b/Mac/Modules/qt/_Qtmodule.c
@@ -996,97 +996,97 @@ static PyObject *MovieCtlObj_MCTrimMovieSegment(MovieControllerObject *_self, Py
 
 static PyMethodDef MovieCtlObj_methods[] = {
 	{"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
-	 "(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)")},
 	{"MCGetIndMovie", (PyCFunction)MovieCtlObj_MCGetIndMovie, 1,
-	 "(short index) -> (Movie _rv)"},
+	 PyDoc_STR("(short index) -> (Movie _rv)")},
 	{"MCRemoveAllMovies", (PyCFunction)MovieCtlObj_MCRemoveAllMovies, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCRemoveAMovie", (PyCFunction)MovieCtlObj_MCRemoveAMovie, 1,
-	 "(Movie m) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie m) -> (ComponentResult _rv)")},
 	{"MCRemoveMovie", (PyCFunction)MovieCtlObj_MCRemoveMovie, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCIsPlayerEvent", (PyCFunction)MovieCtlObj_MCIsPlayerEvent, 1,
-	 "(EventRecord e) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(EventRecord e) -> (ComponentResult _rv)")},
 	{"MCDoAction", (PyCFunction)MovieCtlObj_MCDoAction, 1,
-	 "(short action, void * params) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(short action, void * params) -> (ComponentResult _rv)")},
 	{"MCSetControllerAttached", (PyCFunction)MovieCtlObj_MCSetControllerAttached, 1,
-	 "(Boolean attach) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Boolean attach) -> (ComponentResult _rv)")},
 	{"MCIsControllerAttached", (PyCFunction)MovieCtlObj_MCIsControllerAttached, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCSetControllerPort", (PyCFunction)MovieCtlObj_MCSetControllerPort, 1,
-	 "(CGrafPtr gp) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(CGrafPtr gp) -> (ComponentResult _rv)")},
 	{"MCGetControllerPort", (PyCFunction)MovieCtlObj_MCGetControllerPort, 1,
-	 "() -> (CGrafPtr _rv)"},
+	 PyDoc_STR("() -> (CGrafPtr _rv)")},
 	{"MCSetVisible", (PyCFunction)MovieCtlObj_MCSetVisible, 1,
-	 "(Boolean visible) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Boolean visible) -> (ComponentResult _rv)")},
 	{"MCGetVisible", (PyCFunction)MovieCtlObj_MCGetVisible, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCGetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRect, 1,
-	 "() -> (ComponentResult _rv, Rect bounds)"},
+	 PyDoc_STR("() -> (ComponentResult _rv, Rect bounds)")},
 	{"MCSetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCSetControllerBoundsRect, 1,
-	 "(Rect bounds) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Rect bounds) -> (ComponentResult _rv)")},
 	{"MCGetControllerBoundsRgn", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"MCGetWindowRgn", (PyCFunction)MovieCtlObj_MCGetWindowRgn, 1,
-	 "(WindowPtr w) -> (RgnHandle _rv)"},
+	 PyDoc_STR("(WindowPtr w) -> (RgnHandle _rv)")},
 	{"MCMovieChanged", (PyCFunction)MovieCtlObj_MCMovieChanged, 1,
-	 "(Movie m) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie m) -> (ComponentResult _rv)")},
 	{"MCSetDuration", (PyCFunction)MovieCtlObj_MCSetDuration, 1,
-	 "(TimeValue duration) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(TimeValue duration) -> (ComponentResult _rv)")},
 	{"MCGetCurrentTime", (PyCFunction)MovieCtlObj_MCGetCurrentTime, 1,
-	 "() -> (TimeValue _rv, TimeScale scale)"},
+	 PyDoc_STR("() -> (TimeValue _rv, TimeScale scale)")},
 	{"MCNewAttachedController", (PyCFunction)MovieCtlObj_MCNewAttachedController, 1,
-	 "(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)")},
 	{"MCDraw", (PyCFunction)MovieCtlObj_MCDraw, 1,
-	 "(WindowPtr w) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(WindowPtr w) -> (ComponentResult _rv)")},
 	{"MCActivate", (PyCFunction)MovieCtlObj_MCActivate, 1,
-	 "(WindowPtr w, Boolean activate) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(WindowPtr w, Boolean activate) -> (ComponentResult _rv)")},
 	{"MCIdle", (PyCFunction)MovieCtlObj_MCIdle, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCKey", (PyCFunction)MovieCtlObj_MCKey, 1,
-	 "(SInt8 key, long modifiers) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(SInt8 key, long modifiers) -> (ComponentResult _rv)")},
 	{"MCClick", (PyCFunction)MovieCtlObj_MCClick, 1,
-	 "(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)")},
 	{"MCEnableEditing", (PyCFunction)MovieCtlObj_MCEnableEditing, 1,
-	 "(Boolean enabled) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Boolean enabled) -> (ComponentResult _rv)")},
 	{"MCIsEditingEnabled", (PyCFunction)MovieCtlObj_MCIsEditingEnabled, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"MCCopy", (PyCFunction)MovieCtlObj_MCCopy, 1,
-	 "() -> (Movie _rv)"},
+	 PyDoc_STR("() -> (Movie _rv)")},
 	{"MCCut", (PyCFunction)MovieCtlObj_MCCut, 1,
-	 "() -> (Movie _rv)"},
+	 PyDoc_STR("() -> (Movie _rv)")},
 	{"MCPaste", (PyCFunction)MovieCtlObj_MCPaste, 1,
-	 "(Movie srcMovie) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie srcMovie) -> (ComponentResult _rv)")},
 	{"MCClear", (PyCFunction)MovieCtlObj_MCClear, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCUndo", (PyCFunction)MovieCtlObj_MCUndo, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCPositionController", (PyCFunction)MovieCtlObj_MCPositionController, 1,
-	 "(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)")},
 	{"MCGetControllerInfo", (PyCFunction)MovieCtlObj_MCGetControllerInfo, 1,
-	 "() -> (ComponentResult _rv, long someFlags)"},
+	 PyDoc_STR("() -> (ComponentResult _rv, long someFlags)")},
 	{"MCSetClip", (PyCFunction)MovieCtlObj_MCSetClip, 1,
-	 "(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)")},
 	{"MCGetClip", (PyCFunction)MovieCtlObj_MCGetClip, 1,
-	 "() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)"},
+	 PyDoc_STR("() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)")},
 	{"MCDrawBadge", (PyCFunction)MovieCtlObj_MCDrawBadge, 1,
-	 "(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)"},
+	 PyDoc_STR("(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)")},
 	{"MCSetUpEditMenu", (PyCFunction)MovieCtlObj_MCSetUpEditMenu, 1,
-	 "(long modifiers, MenuHandle mh) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(long modifiers, MenuHandle mh) -> (ComponentResult _rv)")},
 	{"MCGetMenuString", (PyCFunction)MovieCtlObj_MCGetMenuString, 1,
-	 "(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)")},
 	{"MCPtInController", (PyCFunction)MovieCtlObj_MCPtInController, 1,
-	 "(Point thePt) -> (ComponentResult _rv, Boolean inController)"},
+	 PyDoc_STR("(Point thePt) -> (ComponentResult _rv, Boolean inController)")},
 	{"MCInvalidate", (PyCFunction)MovieCtlObj_MCInvalidate, 1,
-	 "(WindowPtr w, RgnHandle invalidRgn) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(WindowPtr w, RgnHandle invalidRgn) -> (ComponentResult _rv)")},
 	{"MCAdjustCursor", (PyCFunction)MovieCtlObj_MCAdjustCursor, 1,
-	 "(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)")},
 	{"MCGetInterfaceElement", (PyCFunction)MovieCtlObj_MCGetInterfaceElement, 1,
-	 "(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)")},
 	{"MCAddMovieSegment", (PyCFunction)MovieCtlObj_MCAddMovieSegment, 1,
-	 "(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)")},
 	{"MCTrimMovieSegment", (PyCFunction)MovieCtlObj_MCTrimMovieSegment, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -1501,43 +1501,43 @@ static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(TimeBaseObject *_self, PyO
 
 static PyMethodDef TimeBaseObj_methods[] = {
 	{"DisposeTimeBase", (PyCFunction)TimeBaseObj_DisposeTimeBase, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetTimeBaseTime", (PyCFunction)TimeBaseObj_GetTimeBaseTime, 1,
-	 "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
+	 PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
 	{"SetTimeBaseTime", (PyCFunction)TimeBaseObj_SetTimeBaseTime, 1,
-	 "(TimeRecord tr) -> None"},
+	 PyDoc_STR("(TimeRecord tr) -> None")},
 	{"SetTimeBaseValue", (PyCFunction)TimeBaseObj_SetTimeBaseValue, 1,
-	 "(TimeValue t, TimeScale s) -> None"},
+	 PyDoc_STR("(TimeValue t, TimeScale s) -> None")},
 	{"GetTimeBaseRate", (PyCFunction)TimeBaseObj_GetTimeBaseRate, 1,
-	 "() -> (Fixed _rv)"},
+	 PyDoc_STR("() -> (Fixed _rv)")},
 	{"SetTimeBaseRate", (PyCFunction)TimeBaseObj_SetTimeBaseRate, 1,
-	 "(Fixed r) -> None"},
+	 PyDoc_STR("(Fixed r) -> None")},
 	{"GetTimeBaseStartTime", (PyCFunction)TimeBaseObj_GetTimeBaseStartTime, 1,
-	 "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
+	 PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
 	{"SetTimeBaseStartTime", (PyCFunction)TimeBaseObj_SetTimeBaseStartTime, 1,
-	 "(TimeRecord tr) -> None"},
+	 PyDoc_STR("(TimeRecord tr) -> None")},
 	{"GetTimeBaseStopTime", (PyCFunction)TimeBaseObj_GetTimeBaseStopTime, 1,
-	 "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
+	 PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
 	{"SetTimeBaseStopTime", (PyCFunction)TimeBaseObj_SetTimeBaseStopTime, 1,
-	 "(TimeRecord tr) -> None"},
+	 PyDoc_STR("(TimeRecord tr) -> None")},
 	{"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1,
-	 "(long timeBaseFlags) -> None"},
+	 PyDoc_STR("(long timeBaseFlags) -> None")},
 	{"SetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_SetTimeBaseMasterTimeBase, 1,
-	 "(TimeBase master, TimeRecord slaveZero) -> None"},
+	 PyDoc_STR("(TimeBase master, TimeRecord slaveZero) -> None")},
 	{"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1,
-	 "() -> (TimeBase _rv)"},
+	 PyDoc_STR("() -> (TimeBase _rv)")},
 	{"SetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_SetTimeBaseMasterClock, 1,
-	 "(Component clockMeister, TimeRecord slaveZero) -> None"},
+	 PyDoc_STR("(Component clockMeister, TimeRecord slaveZero) -> None")},
 	{"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1,
-	 "() -> (ComponentInstance _rv)"},
+	 PyDoc_STR("() -> (ComponentInstance _rv)")},
 	{"GetTimeBaseStatus", (PyCFunction)TimeBaseObj_GetTimeBaseStatus, 1,
-	 "() -> (long _rv, TimeRecord unpinnedTime)"},
+	 PyDoc_STR("() -> (long _rv, TimeRecord unpinnedTime)")},
 	{"SetTimeBaseZero", (PyCFunction)TimeBaseObj_SetTimeBaseZero, 1,
-	 "(TimeRecord zero) -> None"},
+	 PyDoc_STR("(TimeRecord zero) -> None")},
 	{"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1,
-	 "() -> (Fixed _rv)"},
+	 PyDoc_STR("() -> (Fixed _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -1825,23 +1825,23 @@ static PyObject *UserDataObj_PutUserDataIntoHandle(UserDataObject *_self, PyObje
 
 static PyMethodDef UserDataObj_methods[] = {
 	{"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1,
-	 "(Handle data, OSType udType, long index) -> None"},
+	 PyDoc_STR("(Handle data, OSType udType, long index) -> None")},
 	{"AddUserData", (PyCFunction)UserDataObj_AddUserData, 1,
-	 "(Handle data, OSType udType) -> None"},
+	 PyDoc_STR("(Handle data, OSType udType) -> None")},
 	{"RemoveUserData", (PyCFunction)UserDataObj_RemoveUserData, 1,
-	 "(OSType udType, long index) -> None"},
+	 PyDoc_STR("(OSType udType, long index) -> None")},
 	{"CountUserDataType", (PyCFunction)UserDataObj_CountUserDataType, 1,
-	 "(OSType udType) -> (short _rv)"},
+	 PyDoc_STR("(OSType udType) -> (short _rv)")},
 	{"GetNextUserDataType", (PyCFunction)UserDataObj_GetNextUserDataType, 1,
-	 "(OSType udType) -> (long _rv)"},
+	 PyDoc_STR("(OSType udType) -> (long _rv)")},
 	{"AddUserDataText", (PyCFunction)UserDataObj_AddUserDataText, 1,
-	 "(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
+	 PyDoc_STR("(Handle data, OSType udType, long index, short itlRegionTag) -> None")},
 	{"GetUserDataText", (PyCFunction)UserDataObj_GetUserDataText, 1,
-	 "(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
+	 PyDoc_STR("(Handle data, OSType udType, long index, short itlRegionTag) -> None")},
 	{"RemoveUserDataText", (PyCFunction)UserDataObj_RemoveUserDataText, 1,
-	 "(OSType udType, long index, short itlRegionTag) -> None"},
+	 PyDoc_STR("(OSType udType, long index, short itlRegionTag) -> None")},
 	{"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1,
-	 "(Handle h) -> None"},
+	 PyDoc_STR("(Handle h) -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -2924,99 +2924,99 @@ static PyObject *MediaObj_GetMediaNextInterestingTimeOnly(MediaObject *_self, Py
 
 static PyMethodDef MediaObj_methods[] = {
 	{"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1,
-	 "(TimeValue time, TimeValue duration, long flags) -> None"},
+	 PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
 	{"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1,
-	 "() -> (Track _rv)"},
+	 PyDoc_STR("() -> (Track _rv)")},
 	{"GetMediaCreationTime", (PyCFunction)MediaObj_GetMediaCreationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetMediaModificationTime", (PyCFunction)MediaObj_GetMediaModificationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetMediaTimeScale", (PyCFunction)MediaObj_GetMediaTimeScale, 1,
-	 "() -> (TimeScale _rv)"},
+	 PyDoc_STR("() -> (TimeScale _rv)")},
 	{"SetMediaTimeScale", (PyCFunction)MediaObj_SetMediaTimeScale, 1,
-	 "(TimeScale timeScale) -> None"},
+	 PyDoc_STR("(TimeScale timeScale) -> None")},
 	{"GetMediaDuration", (PyCFunction)MediaObj_GetMediaDuration, 1,
-	 "() -> (TimeValue _rv)"},
+	 PyDoc_STR("() -> (TimeValue _rv)")},
 	{"GetMediaLanguage", (PyCFunction)MediaObj_GetMediaLanguage, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetMediaLanguage", (PyCFunction)MediaObj_SetMediaLanguage, 1,
-	 "(short language) -> None"},
+	 PyDoc_STR("(short language) -> None")},
 	{"GetMediaQuality", (PyCFunction)MediaObj_GetMediaQuality, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetMediaQuality", (PyCFunction)MediaObj_SetMediaQuality, 1,
-	 "(short quality) -> None"},
+	 PyDoc_STR("(short quality) -> None")},
 	{"GetMediaHandlerDescription", (PyCFunction)MediaObj_GetMediaHandlerDescription, 1,
-	 "(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)"},
+	 PyDoc_STR("(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)")},
 	{"GetMediaUserData", (PyCFunction)MediaObj_GetMediaUserData, 1,
-	 "() -> (UserData _rv)"},
+	 PyDoc_STR("() -> (UserData _rv)")},
 	{"GetMediaHandler", (PyCFunction)MediaObj_GetMediaHandler, 1,
-	 "() -> (MediaHandler _rv)"},
+	 PyDoc_STR("() -> (MediaHandler _rv)")},
 	{"SetMediaHandler", (PyCFunction)MediaObj_SetMediaHandler, 1,
-	 "(MediaHandlerComponent mH) -> None"},
+	 PyDoc_STR("(MediaHandlerComponent mH) -> None")},
 	{"BeginMediaEdits", (PyCFunction)MediaObj_BeginMediaEdits, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"EndMediaEdits", (PyCFunction)MediaObj_EndMediaEdits, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetMediaDefaultDataRefIndex", (PyCFunction)MediaObj_SetMediaDefaultDataRefIndex, 1,
-	 "(short index) -> None"},
+	 PyDoc_STR("(short index) -> None")},
 	{"GetMediaDataHandlerDescription", (PyCFunction)MediaObj_GetMediaDataHandlerDescription, 1,
-	 "(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)"},
+	 PyDoc_STR("(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)")},
 	{"GetMediaDataHandler", (PyCFunction)MediaObj_GetMediaDataHandler, 1,
-	 "(short index) -> (DataHandler _rv)"},
+	 PyDoc_STR("(short index) -> (DataHandler _rv)")},
 	{"SetMediaDataHandler", (PyCFunction)MediaObj_SetMediaDataHandler, 1,
-	 "(short index, DataHandlerComponent dataHandler) -> None"},
+	 PyDoc_STR("(short index, DataHandlerComponent dataHandler) -> None")},
 	{"GetMediaSampleDescriptionCount", (PyCFunction)MediaObj_GetMediaSampleDescriptionCount, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetMediaSampleDescription", (PyCFunction)MediaObj_GetMediaSampleDescription, 1,
-	 "(long index, SampleDescriptionHandle descH) -> None"},
+	 PyDoc_STR("(long index, SampleDescriptionHandle descH) -> None")},
 	{"SetMediaSampleDescription", (PyCFunction)MediaObj_SetMediaSampleDescription, 1,
-	 "(long index, SampleDescriptionHandle descH) -> None"},
+	 PyDoc_STR("(long index, SampleDescriptionHandle descH) -> None")},
 	{"GetMediaSampleCount", (PyCFunction)MediaObj_GetMediaSampleCount, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetMediaSyncSampleCount", (PyCFunction)MediaObj_GetMediaSyncSampleCount, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"SampleNumToMediaTime", (PyCFunction)MediaObj_SampleNumToMediaTime, 1,
-	 "(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)"},
+	 PyDoc_STR("(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)")},
 	{"MediaTimeToSampleNum", (PyCFunction)MediaObj_MediaTimeToSampleNum, 1,
-	 "(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)"},
+	 PyDoc_STR("(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)")},
 	{"AddMediaSample", (PyCFunction)MediaObj_AddMediaSample, 1,
-	 "(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
+	 PyDoc_STR("(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)")},
 	{"AddMediaSampleReference", (PyCFunction)MediaObj_AddMediaSampleReference, 1,
-	 "(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
+	 PyDoc_STR("(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)")},
 	{"GetMediaSample", (PyCFunction)MediaObj_GetMediaSample, 1,
-	 "(Handle dataOut, long maxSizeToGrow, TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"},
+	 PyDoc_STR("(Handle dataOut, long maxSizeToGrow, TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)")},
 	{"GetMediaSampleReference", (PyCFunction)MediaObj_GetMediaSampleReference, 1,
-	 "(TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long dataOffset, long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"},
+	 PyDoc_STR("(TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long dataOffset, long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)")},
 	{"SetMediaPreferredChunkSize", (PyCFunction)MediaObj_SetMediaPreferredChunkSize, 1,
-	 "(long maxChunkSize) -> None"},
+	 PyDoc_STR("(long maxChunkSize) -> None")},
 	{"GetMediaPreferredChunkSize", (PyCFunction)MediaObj_GetMediaPreferredChunkSize, 1,
-	 "() -> (long maxChunkSize)"},
+	 PyDoc_STR("() -> (long maxChunkSize)")},
 	{"SetMediaShadowSync", (PyCFunction)MediaObj_SetMediaShadowSync, 1,
-	 "(long frameDiffSampleNum, long syncSampleNum) -> None"},
+	 PyDoc_STR("(long frameDiffSampleNum, long syncSampleNum) -> None")},
 	{"GetMediaShadowSync", (PyCFunction)MediaObj_GetMediaShadowSync, 1,
-	 "(long frameDiffSampleNum) -> (long syncSampleNum)"},
+	 PyDoc_STR("(long frameDiffSampleNum) -> (long syncSampleNum)")},
 	{"GetMediaDataSize", (PyCFunction)MediaObj_GetMediaDataSize, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
 	{"GetMediaDataSize64", (PyCFunction)MediaObj_GetMediaDataSize64, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
 	{"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1,
-	 "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
+	 PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
 	{"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1,
-	 "(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)"},
+	 PyDoc_STR("(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)")},
 	{"SetMediaDataRef", (PyCFunction)MediaObj_SetMediaDataRef, 1,
-	 "(short index, Handle dataRef, OSType dataRefType) -> None"},
+	 PyDoc_STR("(short index, Handle dataRef, OSType dataRefType) -> None")},
 	{"SetMediaDataRefAttributes", (PyCFunction)MediaObj_SetMediaDataRefAttributes, 1,
-	 "(short index, long dataRefAttributes) -> None"},
+	 PyDoc_STR("(short index, long dataRefAttributes) -> None")},
 	{"AddMediaDataRef", (PyCFunction)MediaObj_AddMediaDataRef, 1,
-	 "(Handle dataRef, OSType dataRefType) -> (short index)"},
+	 PyDoc_STR("(Handle dataRef, OSType dataRefType) -> (short index)")},
 	{"GetMediaDataRefCount", (PyCFunction)MediaObj_GetMediaDataRefCount, 1,
-	 "() -> (short count)"},
+	 PyDoc_STR("() -> (short count)")},
 	{"SetMediaPlayHints", (PyCFunction)MediaObj_SetMediaPlayHints, 1,
-	 "(long flags, long flagsMask) -> None"},
+	 PyDoc_STR("(long flags, long flagsMask) -> None")},
 	{"GetMediaPlayHints", (PyCFunction)MediaObj_GetMediaPlayHints, 1,
-	 "() -> (long flags)"},
+	 PyDoc_STR("() -> (long flags)")},
 	{"GetMediaNextInterestingTimeOnly", (PyCFunction)MediaObj_GetMediaNextInterestingTimeOnly, 1,
-	 "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime)"},
+	 PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime)")},
 	{NULL, NULL, 0}
 };
 
@@ -4185,119 +4185,119 @@ static PyObject *TrackObj_GetTrackLoadSettings(TrackObject *_self, PyObject *_ar
 
 static PyMethodDef TrackObj_methods[] = {
 	{"LoadTrackIntoRam", (PyCFunction)TrackObj_LoadTrackIntoRam, 1,
-	 "(TimeValue time, TimeValue duration, long flags) -> None"},
+	 PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
 	{"GetTrackPict", (PyCFunction)TrackObj_GetTrackPict, 1,
-	 "(TimeValue time) -> (PicHandle _rv)"},
+	 PyDoc_STR("(TimeValue time) -> (PicHandle _rv)")},
 	{"GetTrackClipRgn", (PyCFunction)TrackObj_GetTrackClipRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"SetTrackClipRgn", (PyCFunction)TrackObj_SetTrackClipRgn, 1,
-	 "(RgnHandle theClip) -> None"},
+	 PyDoc_STR("(RgnHandle theClip) -> None")},
 	{"GetTrackDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackDisplayBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"GetTrackMovieBoundsRgn", (PyCFunction)TrackObj_GetTrackMovieBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"GetTrackBoundsRgn", (PyCFunction)TrackObj_GetTrackBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"GetTrackMatte", (PyCFunction)TrackObj_GetTrackMatte, 1,
-	 "() -> (PixMapHandle _rv)"},
+	 PyDoc_STR("() -> (PixMapHandle _rv)")},
 	{"SetTrackMatte", (PyCFunction)TrackObj_SetTrackMatte, 1,
-	 "(PixMapHandle theMatte) -> None"},
+	 PyDoc_STR("(PixMapHandle theMatte) -> None")},
 	{"GetTrackID", (PyCFunction)TrackObj_GetTrackID, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetTrackMovie", (PyCFunction)TrackObj_GetTrackMovie, 1,
-	 "() -> (Movie _rv)"},
+	 PyDoc_STR("() -> (Movie _rv)")},
 	{"GetTrackCreationTime", (PyCFunction)TrackObj_GetTrackCreationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetTrackModificationTime", (PyCFunction)TrackObj_GetTrackModificationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetTrackEnabled", (PyCFunction)TrackObj_GetTrackEnabled, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"SetTrackEnabled", (PyCFunction)TrackObj_SetTrackEnabled, 1,
-	 "(Boolean isEnabled) -> None"},
+	 PyDoc_STR("(Boolean isEnabled) -> None")},
 	{"GetTrackUsage", (PyCFunction)TrackObj_GetTrackUsage, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"SetTrackUsage", (PyCFunction)TrackObj_SetTrackUsage, 1,
-	 "(long usage) -> None"},
+	 PyDoc_STR("(long usage) -> None")},
 	{"GetTrackDuration", (PyCFunction)TrackObj_GetTrackDuration, 1,
-	 "() -> (TimeValue _rv)"},
+	 PyDoc_STR("() -> (TimeValue _rv)")},
 	{"GetTrackOffset", (PyCFunction)TrackObj_GetTrackOffset, 1,
-	 "() -> (TimeValue _rv)"},
+	 PyDoc_STR("() -> (TimeValue _rv)")},
 	{"SetTrackOffset", (PyCFunction)TrackObj_SetTrackOffset, 1,
-	 "(TimeValue movieOffsetTime) -> None"},
+	 PyDoc_STR("(TimeValue movieOffsetTime) -> None")},
 	{"GetTrackLayer", (PyCFunction)TrackObj_GetTrackLayer, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetTrackLayer", (PyCFunction)TrackObj_SetTrackLayer, 1,
-	 "(short layer) -> None"},
+	 PyDoc_STR("(short layer) -> None")},
 	{"GetTrackAlternate", (PyCFunction)TrackObj_GetTrackAlternate, 1,
-	 "() -> (Track _rv)"},
+	 PyDoc_STR("() -> (Track _rv)")},
 	{"SetTrackAlternate", (PyCFunction)TrackObj_SetTrackAlternate, 1,
-	 "(Track alternateT) -> None"},
+	 PyDoc_STR("(Track alternateT) -> None")},
 	{"GetTrackVolume", (PyCFunction)TrackObj_GetTrackVolume, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetTrackVolume", (PyCFunction)TrackObj_SetTrackVolume, 1,
-	 "(short volume) -> None"},
+	 PyDoc_STR("(short volume) -> None")},
 	{"GetTrackDimensions", (PyCFunction)TrackObj_GetTrackDimensions, 1,
-	 "() -> (Fixed width, Fixed height)"},
+	 PyDoc_STR("() -> (Fixed width, Fixed height)")},
 	{"SetTrackDimensions", (PyCFunction)TrackObj_SetTrackDimensions, 1,
-	 "(Fixed width, Fixed height) -> None"},
+	 PyDoc_STR("(Fixed width, Fixed height) -> None")},
 	{"GetTrackUserData", (PyCFunction)TrackObj_GetTrackUserData, 1,
-	 "() -> (UserData _rv)"},
+	 PyDoc_STR("() -> (UserData _rv)")},
 	{"GetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_GetTrackSoundLocalizationSettings, 1,
-	 "() -> (Handle settings)"},
+	 PyDoc_STR("() -> (Handle settings)")},
 	{"SetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_SetTrackSoundLocalizationSettings, 1,
-	 "(Handle settings) -> None"},
+	 PyDoc_STR("(Handle settings) -> None")},
 	{"NewTrackMedia", (PyCFunction)TrackObj_NewTrackMedia, 1,
-	 "(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)"},
+	 PyDoc_STR("(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)")},
 	{"GetTrackMedia", (PyCFunction)TrackObj_GetTrackMedia, 1,
-	 "() -> (Media _rv)"},
+	 PyDoc_STR("() -> (Media _rv)")},
 	{"InsertMediaIntoTrack", (PyCFunction)TrackObj_InsertMediaIntoTrack, 1,
-	 "(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None"},
+	 PyDoc_STR("(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None")},
 	{"InsertTrackSegment", (PyCFunction)TrackObj_InsertTrackSegment, 1,
-	 "(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
+	 PyDoc_STR("(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None")},
 	{"InsertEmptyTrackSegment", (PyCFunction)TrackObj_InsertEmptyTrackSegment, 1,
-	 "(TimeValue dstIn, TimeValue dstDuration) -> None"},
+	 PyDoc_STR("(TimeValue dstIn, TimeValue dstDuration) -> None")},
 	{"DeleteTrackSegment", (PyCFunction)TrackObj_DeleteTrackSegment, 1,
-	 "(TimeValue startTime, TimeValue duration) -> None"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
 	{"ScaleTrackSegment", (PyCFunction)TrackObj_ScaleTrackSegment, 1,
-	 "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None")},
 	{"IsScrapMovie", (PyCFunction)TrackObj_IsScrapMovie, 1,
-	 "() -> (Component _rv)"},
+	 PyDoc_STR("() -> (Component _rv)")},
 	{"CopyTrackSettings", (PyCFunction)TrackObj_CopyTrackSettings, 1,
-	 "(Track dstTrack) -> None"},
+	 PyDoc_STR("(Track dstTrack) -> None")},
 	{"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1,
-	 "(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)"},
+	 PyDoc_STR("(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)")},
 	{"AddClonedTrackToMovie", (PyCFunction)TrackObj_AddClonedTrackToMovie, 1,
-	 "(Movie dstMovie, long flags) -> (Track dstTrack)"},
+	 PyDoc_STR("(Movie dstMovie, long flags) -> (Track dstTrack)")},
 	{"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1,
-	 "(Track refTrack, OSType refType) -> (long addedIndex)"},
+	 PyDoc_STR("(Track refTrack, OSType refType) -> (long addedIndex)")},
 	{"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1,
-	 "(OSType refType, long index) -> None"},
+	 PyDoc_STR("(OSType refType, long index) -> None")},
 	{"SetTrackReference", (PyCFunction)TrackObj_SetTrackReference, 1,
-	 "(Track refTrack, OSType refType, long index) -> None"},
+	 PyDoc_STR("(Track refTrack, OSType refType, long index) -> None")},
 	{"GetTrackReference", (PyCFunction)TrackObj_GetTrackReference, 1,
-	 "(OSType refType, long index) -> (Track _rv)"},
+	 PyDoc_STR("(OSType refType, long index) -> (Track _rv)")},
 	{"GetNextTrackReferenceType", (PyCFunction)TrackObj_GetNextTrackReferenceType, 1,
-	 "(OSType refType) -> (OSType _rv)"},
+	 PyDoc_STR("(OSType refType) -> (OSType _rv)")},
 	{"GetTrackReferenceCount", (PyCFunction)TrackObj_GetTrackReferenceCount, 1,
-	 "(OSType refType) -> (long _rv)"},
+	 PyDoc_STR("(OSType refType) -> (long _rv)")},
 	{"GetTrackEditRate", (PyCFunction)TrackObj_GetTrackEditRate, 1,
-	 "(TimeValue atTime) -> (Fixed _rv)"},
+	 PyDoc_STR("(TimeValue atTime) -> (Fixed _rv)")},
 	{"GetTrackDataSize", (PyCFunction)TrackObj_GetTrackDataSize, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
 	{"GetTrackDataSize64", (PyCFunction)TrackObj_GetTrackDataSize64, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
 	{"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1,
-	 "(Point pt) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt) -> (Boolean _rv)")},
 	{"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1,
-	 "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
+	 PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
 	{"GetTrackSegmentDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackSegmentDisplayBoundsRgn, 1,
-	 "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
+	 PyDoc_STR("(TimeValue time, TimeValue duration) -> (RgnHandle _rv)")},
 	{"GetTrackStatus", (PyCFunction)TrackObj_GetTrackStatus, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"SetTrackLoadSettings", (PyCFunction)TrackObj_SetTrackLoadSettings, 1,
-	 "(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None"},
+	 PyDoc_STR("(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None")},
 	{"GetTrackLoadSettings", (PyCFunction)TrackObj_GetTrackLoadSettings, 1,
-	 "() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)"},
+	 PyDoc_STR("() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)")},
 	{NULL, NULL, 0}
 };
 
@@ -6489,236 +6489,236 @@ static PyObject *MovieObj_QTGetDataRefMaxFileOffset(MovieObject *_self, PyObject
 
 static PyMethodDef MovieObj_methods[] = {
 	{"MoviesTask", (PyCFunction)MovieObj_MoviesTask, 1,
-	 "(long maxMilliSecToUse) -> None"},
+	 PyDoc_STR("(long maxMilliSecToUse) -> None")},
 	{"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1,
-	 "(TimeValue time, Fixed Rate) -> None"},
+	 PyDoc_STR("(TimeValue time, Fixed Rate) -> None")},
 	{"AbortPrePrerollMovie", (PyCFunction)MovieObj_AbortPrePrerollMovie, 1,
-	 "(OSErr err) -> None"},
+	 PyDoc_STR("(OSErr err) -> None")},
 	{"LoadMovieIntoRam", (PyCFunction)MovieObj_LoadMovieIntoRam, 1,
-	 "(TimeValue time, TimeValue duration, long flags) -> None"},
+	 PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
 	{"SetMovieActive", (PyCFunction)MovieObj_SetMovieActive, 1,
-	 "(Boolean active) -> None"},
+	 PyDoc_STR("(Boolean active) -> None")},
 	{"GetMovieActive", (PyCFunction)MovieObj_GetMovieActive, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"StartMovie", (PyCFunction)MovieObj_StartMovie, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"StopMovie", (PyCFunction)MovieObj_StopMovie, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GoToBeginningOfMovie", (PyCFunction)MovieObj_GoToBeginningOfMovie, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GoToEndOfMovie", (PyCFunction)MovieObj_GoToEndOfMovie, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"IsMovieDone", (PyCFunction)MovieObj_IsMovieDone, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"GetMoviePreviewMode", (PyCFunction)MovieObj_GetMoviePreviewMode, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"SetMoviePreviewMode", (PyCFunction)MovieObj_SetMoviePreviewMode, 1,
-	 "(Boolean usePreview) -> None"},
+	 PyDoc_STR("(Boolean usePreview) -> None")},
 	{"ShowMoviePoster", (PyCFunction)MovieObj_ShowMoviePoster, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetMovieTimeBase", (PyCFunction)MovieObj_GetMovieTimeBase, 1,
-	 "() -> (TimeBase _rv)"},
+	 PyDoc_STR("() -> (TimeBase _rv)")},
 	{"SetMovieMasterTimeBase", (PyCFunction)MovieObj_SetMovieMasterTimeBase, 1,
-	 "(TimeBase tb, TimeRecord slaveZero) -> None"},
+	 PyDoc_STR("(TimeBase tb, TimeRecord slaveZero) -> None")},
 	{"SetMovieMasterClock", (PyCFunction)MovieObj_SetMovieMasterClock, 1,
-	 "(Component clockMeister, TimeRecord slaveZero) -> None"},
+	 PyDoc_STR("(Component clockMeister, TimeRecord slaveZero) -> None")},
 	{"GetMovieGWorld", (PyCFunction)MovieObj_GetMovieGWorld, 1,
-	 "() -> (CGrafPtr port, GDHandle gdh)"},
+	 PyDoc_STR("() -> (CGrafPtr port, GDHandle gdh)")},
 	{"SetMovieGWorld", (PyCFunction)MovieObj_SetMovieGWorld, 1,
-	 "(CGrafPtr port, GDHandle gdh) -> None"},
+	 PyDoc_STR("(CGrafPtr port, GDHandle gdh) -> None")},
 	{"GetMovieNaturalBoundsRect", (PyCFunction)MovieObj_GetMovieNaturalBoundsRect, 1,
-	 "() -> (Rect naturalBounds)"},
+	 PyDoc_STR("() -> (Rect naturalBounds)")},
 	{"GetNextTrackForCompositing", (PyCFunction)MovieObj_GetNextTrackForCompositing, 1,
-	 "(Track theTrack) -> (Track _rv)"},
+	 PyDoc_STR("(Track theTrack) -> (Track _rv)")},
 	{"GetPrevTrackForCompositing", (PyCFunction)MovieObj_GetPrevTrackForCompositing, 1,
-	 "(Track theTrack) -> (Track _rv)"},
+	 PyDoc_STR("(Track theTrack) -> (Track _rv)")},
 	{"GetMoviePict", (PyCFunction)MovieObj_GetMoviePict, 1,
-	 "(TimeValue time) -> (PicHandle _rv)"},
+	 PyDoc_STR("(TimeValue time) -> (PicHandle _rv)")},
 	{"GetMoviePosterPict", (PyCFunction)MovieObj_GetMoviePosterPict, 1,
-	 "() -> (PicHandle _rv)"},
+	 PyDoc_STR("() -> (PicHandle _rv)")},
 	{"UpdateMovie", (PyCFunction)MovieObj_UpdateMovie, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"InvalidateMovieRegion", (PyCFunction)MovieObj_InvalidateMovieRegion, 1,
-	 "(RgnHandle invalidRgn) -> None"},
+	 PyDoc_STR("(RgnHandle invalidRgn) -> None")},
 	{"GetMovieBox", (PyCFunction)MovieObj_GetMovieBox, 1,
-	 "() -> (Rect boxRect)"},
+	 PyDoc_STR("() -> (Rect boxRect)")},
 	{"SetMovieBox", (PyCFunction)MovieObj_SetMovieBox, 1,
-	 "(Rect boxRect) -> None"},
+	 PyDoc_STR("(Rect boxRect) -> None")},
 	{"GetMovieDisplayClipRgn", (PyCFunction)MovieObj_GetMovieDisplayClipRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"SetMovieDisplayClipRgn", (PyCFunction)MovieObj_SetMovieDisplayClipRgn, 1,
-	 "(RgnHandle theClip) -> None"},
+	 PyDoc_STR("(RgnHandle theClip) -> None")},
 	{"GetMovieClipRgn", (PyCFunction)MovieObj_GetMovieClipRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"SetMovieClipRgn", (PyCFunction)MovieObj_SetMovieClipRgn, 1,
-	 "(RgnHandle theClip) -> None"},
+	 PyDoc_STR("(RgnHandle theClip) -> None")},
 	{"GetMovieDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieDisplayBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"SetMovieVideoOutput", (PyCFunction)MovieObj_SetMovieVideoOutput, 1,
-	 "(ComponentInstance vout) -> None"},
+	 PyDoc_STR("(ComponentInstance vout) -> None")},
 	{"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
-	 "(Handle publicMovie) -> None"},
+	 PyDoc_STR("(Handle publicMovie) -> None")},
 	{"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
-	 "(short fRefNum, long offset, long maxSize) -> None"},
+	 PyDoc_STR("(short fRefNum, long offset, long maxSize) -> None")},
 	{"PutMovieIntoDataFork64", (PyCFunction)MovieObj_PutMovieIntoDataFork64, 1,
-	 "(long fRefNum, wide offset, unsigned long maxSize) -> None"},
+	 PyDoc_STR("(long fRefNum, wide offset, unsigned long maxSize) -> None")},
 	{"GetMovieCreationTime", (PyCFunction)MovieObj_GetMovieCreationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetMovieModificationTime", (PyCFunction)MovieObj_GetMovieModificationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetMovieTimeScale", (PyCFunction)MovieObj_GetMovieTimeScale, 1,
-	 "() -> (TimeScale _rv)"},
+	 PyDoc_STR("() -> (TimeScale _rv)")},
 	{"SetMovieTimeScale", (PyCFunction)MovieObj_SetMovieTimeScale, 1,
-	 "(TimeScale timeScale) -> None"},
+	 PyDoc_STR("(TimeScale timeScale) -> None")},
 	{"GetMovieDuration", (PyCFunction)MovieObj_GetMovieDuration, 1,
-	 "() -> (TimeValue _rv)"},
+	 PyDoc_STR("() -> (TimeValue _rv)")},
 	{"GetMovieRate", (PyCFunction)MovieObj_GetMovieRate, 1,
-	 "() -> (Fixed _rv)"},
+	 PyDoc_STR("() -> (Fixed _rv)")},
 	{"SetMovieRate", (PyCFunction)MovieObj_SetMovieRate, 1,
-	 "(Fixed rate) -> None"},
+	 PyDoc_STR("(Fixed rate) -> None")},
 	{"GetMoviePreferredRate", (PyCFunction)MovieObj_GetMoviePreferredRate, 1,
-	 "() -> (Fixed _rv)"},
+	 PyDoc_STR("() -> (Fixed _rv)")},
 	{"SetMoviePreferredRate", (PyCFunction)MovieObj_SetMoviePreferredRate, 1,
-	 "(Fixed rate) -> None"},
+	 PyDoc_STR("(Fixed rate) -> None")},
 	{"GetMoviePreferredVolume", (PyCFunction)MovieObj_GetMoviePreferredVolume, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetMoviePreferredVolume", (PyCFunction)MovieObj_SetMoviePreferredVolume, 1,
-	 "(short volume) -> None"},
+	 PyDoc_STR("(short volume) -> None")},
 	{"GetMovieVolume", (PyCFunction)MovieObj_GetMovieVolume, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetMovieVolume", (PyCFunction)MovieObj_SetMovieVolume, 1,
-	 "(short volume) -> None"},
+	 PyDoc_STR("(short volume) -> None")},
 	{"GetMoviePreviewTime", (PyCFunction)MovieObj_GetMoviePreviewTime, 1,
-	 "() -> (TimeValue previewTime, TimeValue previewDuration)"},
+	 PyDoc_STR("() -> (TimeValue previewTime, TimeValue previewDuration)")},
 	{"SetMoviePreviewTime", (PyCFunction)MovieObj_SetMoviePreviewTime, 1,
-	 "(TimeValue previewTime, TimeValue previewDuration) -> None"},
+	 PyDoc_STR("(TimeValue previewTime, TimeValue previewDuration) -> None")},
 	{"GetMoviePosterTime", (PyCFunction)MovieObj_GetMoviePosterTime, 1,
-	 "() -> (TimeValue _rv)"},
+	 PyDoc_STR("() -> (TimeValue _rv)")},
 	{"SetMoviePosterTime", (PyCFunction)MovieObj_SetMoviePosterTime, 1,
-	 "(TimeValue posterTime) -> None"},
+	 PyDoc_STR("(TimeValue posterTime) -> None")},
 	{"GetMovieSelection", (PyCFunction)MovieObj_GetMovieSelection, 1,
-	 "() -> (TimeValue selectionTime, TimeValue selectionDuration)"},
+	 PyDoc_STR("() -> (TimeValue selectionTime, TimeValue selectionDuration)")},
 	{"SetMovieSelection", (PyCFunction)MovieObj_SetMovieSelection, 1,
-	 "(TimeValue selectionTime, TimeValue selectionDuration) -> None"},
+	 PyDoc_STR("(TimeValue selectionTime, TimeValue selectionDuration) -> None")},
 	{"SetMovieActiveSegment", (PyCFunction)MovieObj_SetMovieActiveSegment, 1,
-	 "(TimeValue startTime, TimeValue duration) -> None"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
 	{"GetMovieActiveSegment", (PyCFunction)MovieObj_GetMovieActiveSegment, 1,
-	 "() -> (TimeValue startTime, TimeValue duration)"},
+	 PyDoc_STR("() -> (TimeValue startTime, TimeValue duration)")},
 	{"GetMovieTime", (PyCFunction)MovieObj_GetMovieTime, 1,
-	 "() -> (TimeValue _rv, TimeRecord currentTime)"},
+	 PyDoc_STR("() -> (TimeValue _rv, TimeRecord currentTime)")},
 	{"SetMovieTime", (PyCFunction)MovieObj_SetMovieTime, 1,
-	 "(TimeRecord newtime) -> None"},
+	 PyDoc_STR("(TimeRecord newtime) -> None")},
 	{"SetMovieTimeValue", (PyCFunction)MovieObj_SetMovieTimeValue, 1,
-	 "(TimeValue newtime) -> None"},
+	 PyDoc_STR("(TimeValue newtime) -> None")},
 	{"GetMovieUserData", (PyCFunction)MovieObj_GetMovieUserData, 1,
-	 "() -> (UserData _rv)"},
+	 PyDoc_STR("() -> (UserData _rv)")},
 	{"GetMovieTrackCount", (PyCFunction)MovieObj_GetMovieTrackCount, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetMovieTrack", (PyCFunction)MovieObj_GetMovieTrack, 1,
-	 "(long trackID) -> (Track _rv)"},
+	 PyDoc_STR("(long trackID) -> (Track _rv)")},
 	{"GetMovieIndTrack", (PyCFunction)MovieObj_GetMovieIndTrack, 1,
-	 "(long index) -> (Track _rv)"},
+	 PyDoc_STR("(long index) -> (Track _rv)")},
 	{"GetMovieIndTrackType", (PyCFunction)MovieObj_GetMovieIndTrackType, 1,
-	 "(long index, OSType trackType, long flags) -> (Track _rv)"},
+	 PyDoc_STR("(long index, OSType trackType, long flags) -> (Track _rv)")},
 	{"NewMovieTrack", (PyCFunction)MovieObj_NewMovieTrack, 1,
-	 "(Fixed width, Fixed height, short trackVolume) -> (Track _rv)"},
+	 PyDoc_STR("(Fixed width, Fixed height, short trackVolume) -> (Track _rv)")},
 	{"SetAutoTrackAlternatesEnabled", (PyCFunction)MovieObj_SetAutoTrackAlternatesEnabled, 1,
-	 "(Boolean enable) -> None"},
+	 PyDoc_STR("(Boolean enable) -> None")},
 	{"SelectMovieAlternates", (PyCFunction)MovieObj_SelectMovieAlternates, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"InsertMovieSegment", (PyCFunction)MovieObj_InsertMovieSegment, 1,
-	 "(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
+	 PyDoc_STR("(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None")},
 	{"InsertEmptyMovieSegment", (PyCFunction)MovieObj_InsertEmptyMovieSegment, 1,
-	 "(TimeValue dstIn, TimeValue dstDuration) -> None"},
+	 PyDoc_STR("(TimeValue dstIn, TimeValue dstDuration) -> None")},
 	{"DeleteMovieSegment", (PyCFunction)MovieObj_DeleteMovieSegment, 1,
-	 "(TimeValue startTime, TimeValue duration) -> None"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
 	{"ScaleMovieSegment", (PyCFunction)MovieObj_ScaleMovieSegment, 1,
-	 "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None")},
 	{"CutMovieSelection", (PyCFunction)MovieObj_CutMovieSelection, 1,
-	 "() -> (Movie _rv)"},
+	 PyDoc_STR("() -> (Movie _rv)")},
 	{"CopyMovieSelection", (PyCFunction)MovieObj_CopyMovieSelection, 1,
-	 "() -> (Movie _rv)"},
+	 PyDoc_STR("() -> (Movie _rv)")},
 	{"PasteMovieSelection", (PyCFunction)MovieObj_PasteMovieSelection, 1,
-	 "(Movie src) -> None"},
+	 PyDoc_STR("(Movie src) -> None")},
 	{"AddMovieSelection", (PyCFunction)MovieObj_AddMovieSelection, 1,
-	 "(Movie src) -> None"},
+	 PyDoc_STR("(Movie src) -> None")},
 	{"ClearMovieSelection", (PyCFunction)MovieObj_ClearMovieSelection, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"PutMovieIntoTypedHandle", (PyCFunction)MovieObj_PutMovieIntoTypedHandle, 1,
-	 "(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None"},
+	 PyDoc_STR("(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None")},
 	{"CopyMovieSettings", (PyCFunction)MovieObj_CopyMovieSettings, 1,
-	 "(Movie dstMovie) -> None"},
+	 PyDoc_STR("(Movie dstMovie) -> None")},
 	{"ConvertMovieToFile", (PyCFunction)MovieObj_ConvertMovieToFile, 1,
-	 "(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)"},
+	 PyDoc_STR("(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)")},
 	{"GetMovieDataSize", (PyCFunction)MovieObj_GetMovieDataSize, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
 	{"GetMovieDataSize64", (PyCFunction)MovieObj_GetMovieDataSize64, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
 	{"PtInMovie", (PyCFunction)MovieObj_PtInMovie, 1,
-	 "(Point pt) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt) -> (Boolean _rv)")},
 	{"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1,
-	 "(long language) -> None"},
+	 PyDoc_STR("(long language) -> None")},
 	{"GetMovieNextInterestingTime", (PyCFunction)MovieObj_GetMovieNextInterestingTime, 1,
-	 "(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
+	 PyDoc_STR("(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
 	{"AddMovieResource", (PyCFunction)MovieObj_AddMovieResource, 1,
-	 "(short resRefNum, Str255 resName) -> (short resId)"},
+	 PyDoc_STR("(short resRefNum, Str255 resName) -> (short resId)")},
 	{"UpdateMovieResource", (PyCFunction)MovieObj_UpdateMovieResource, 1,
-	 "(short resRefNum, short resId, Str255 resName) -> None"},
+	 PyDoc_STR("(short resRefNum, short resId, Str255 resName) -> None")},
 	{"HasMovieChanged", (PyCFunction)MovieObj_HasMovieChanged, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"ClearMovieChanged", (PyCFunction)MovieObj_ClearMovieChanged, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetMovieDefaultDataRef", (PyCFunction)MovieObj_SetMovieDefaultDataRef, 1,
-	 "(Handle dataRef, OSType dataRefType) -> None"},
+	 PyDoc_STR("(Handle dataRef, OSType dataRefType) -> None")},
 	{"GetMovieDefaultDataRef", (PyCFunction)MovieObj_GetMovieDefaultDataRef, 1,
-	 "() -> (Handle dataRef, OSType dataRefType)"},
+	 PyDoc_STR("() -> (Handle dataRef, OSType dataRefType)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SetMovieAnchorDataRef", (PyCFunction)MovieObj_SetMovieAnchorDataRef, 1,
-	 "(Handle dataRef, OSType dataRefType) -> None"},
+	 PyDoc_STR("(Handle dataRef, OSType dataRefType) -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"GetMovieAnchorDataRef", (PyCFunction)MovieObj_GetMovieAnchorDataRef, 1,
-	 "() -> (Handle dataRef, OSType dataRefType, long outFlags)"},
+	 PyDoc_STR("() -> (Handle dataRef, OSType dataRefType, long outFlags)")},
 #endif
 	{"SetMovieColorTable", (PyCFunction)MovieObj_SetMovieColorTable, 1,
-	 "(CTabHandle ctab) -> None"},
+	 PyDoc_STR("(CTabHandle ctab) -> None")},
 	{"GetMovieColorTable", (PyCFunction)MovieObj_GetMovieColorTable, 1,
-	 "() -> (CTabHandle ctab)"},
+	 PyDoc_STR("() -> (CTabHandle ctab)")},
 	{"FlattenMovie", (PyCFunction)MovieObj_FlattenMovie, 1,
-	 "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)"},
+	 PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)")},
 	{"FlattenMovieData", (PyCFunction)MovieObj_FlattenMovieData, 1,
-	 "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)"},
+	 PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)")},
 	{"MovieSearchText", (PyCFunction)MovieObj_MovieSearchText, 1,
-	 "(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)"},
+	 PyDoc_STR("(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)")},
 	{"GetPosterBox", (PyCFunction)MovieObj_GetPosterBox, 1,
-	 "() -> (Rect boxRect)"},
+	 PyDoc_STR("() -> (Rect boxRect)")},
 	{"SetPosterBox", (PyCFunction)MovieObj_SetPosterBox, 1,
-	 "(Rect boxRect) -> None"},
+	 PyDoc_STR("(Rect boxRect) -> None")},
 	{"GetMovieSegmentDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieSegmentDisplayBoundsRgn, 1,
-	 "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
+	 PyDoc_STR("(TimeValue time, TimeValue duration) -> (RgnHandle _rv)")},
 	{"GetMovieStatus", (PyCFunction)MovieObj_GetMovieStatus, 1,
-	 "() -> (ComponentResult _rv, Track firstProblemTrack)"},
+	 PyDoc_STR("() -> (ComponentResult _rv, Track firstProblemTrack)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"GetMovieLoadState", (PyCFunction)MovieObj_GetMovieLoadState, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 #endif
 	{"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1,
-	 "(Rect movieRect, long someFlags) -> (MovieController _rv)"},
+	 PyDoc_STR("(Rect movieRect, long someFlags) -> (MovieController _rv)")},
 	{"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1,
-	 "(long movieScrapFlags) -> None"},
+	 PyDoc_STR("(long movieScrapFlags) -> None")},
 	{"SetMoviePlayHints", (PyCFunction)MovieObj_SetMoviePlayHints, 1,
-	 "(long flags, long flagsMask) -> None"},
+	 PyDoc_STR("(long flags, long flagsMask) -> None")},
 	{"GetMaxLoadedTimeInMovie", (PyCFunction)MovieObj_GetMaxLoadedTimeInMovie, 1,
-	 "() -> (TimeValue time)"},
+	 PyDoc_STR("() -> (TimeValue time)")},
 	{"QTMovieNeedsTimeTable", (PyCFunction)MovieObj_QTMovieNeedsTimeTable, 1,
-	 "() -> (Boolean needsTimeTable)"},
+	 PyDoc_STR("() -> (Boolean needsTimeTable)")},
 	{"QTGetDataRefMaxFileOffset", (PyCFunction)MovieObj_QTGetDataRefMaxFileOffset, 1,
-	 "(OSType dataRefType, Handle dataRef) -> (long offset)"},
+	 PyDoc_STR("(OSType dataRefType, Handle dataRef) -> (long offset)")},
 	{NULL, NULL, 0}
 };
 
@@ -9615,262 +9615,262 @@ static PyMethodDef Qt_methods[] = {
 
 #if !TARGET_API_MAC_CARBON
 	{"CheckQuickTimeRegistration", (PyCFunction)Qt_CheckQuickTimeRegistration, 1,
-	 "(void * registrationKey, long flags) -> None"},
+	 PyDoc_STR("(void * registrationKey, long flags) -> None")},
 #endif
 	{"EnterMovies", (PyCFunction)Qt_EnterMovies, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"ExitMovies", (PyCFunction)Qt_ExitMovies, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1,
-	 "(PixMapHandle theMatte) -> None"},
+	 PyDoc_STR("(PixMapHandle theMatte) -> None")},
 	{"NewMovie", (PyCFunction)Qt_NewMovie, 1,
-	 "(long flags) -> (Movie _rv)"},
+	 PyDoc_STR("(long flags) -> (Movie _rv)")},
 	{"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1,
-	 "(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)"},
+	 PyDoc_STR("(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"OpenADataHandler", (PyCFunction)Qt_OpenADataHandler, 1,
-	 "(Handle dataRef, OSType dataHandlerSubType, Handle anchorDataRef, OSType anchorDataRefType, TimeBase tb, long flags) -> (ComponentInstance dh)"},
+	 PyDoc_STR("(Handle dataRef, OSType dataHandlerSubType, Handle anchorDataRef, OSType anchorDataRefType, TimeBase tb, long flags) -> (ComponentInstance dh)")},
 #endif
 	{"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1,
-	 "(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None"},
+	 PyDoc_STR("(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None")},
 	{"GetMovieImporterForDataRef", (PyCFunction)Qt_GetMovieImporterForDataRef, 1,
-	 "(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)"},
+	 PyDoc_STR("(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)")},
 	{"QTGetMIMETypeInfo", (PyCFunction)Qt_QTGetMIMETypeInfo, 1,
-	 "(char* mimeStringStart, short mimeStringLength, OSType infoSelector, void * infoDataPtr) -> (long infoDataSize)"},
+	 PyDoc_STR("(char* mimeStringStart, short mimeStringLength, OSType infoSelector, void * infoDataPtr) -> (long infoDataSize)")},
 	{"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1,
-	 "(TimeValue value, Track theTrack) -> (TimeValue _rv)"},
+	 PyDoc_STR("(TimeValue value, Track theTrack) -> (TimeValue _rv)")},
 	{"NewUserData", (PyCFunction)Qt_NewUserData, 1,
-	 "() -> (UserData theUserData)"},
+	 PyDoc_STR("() -> (UserData theUserData)")},
 	{"NewUserDataFromHandle", (PyCFunction)Qt_NewUserDataFromHandle, 1,
-	 "(Handle h) -> (UserData theUserData)"},
+	 PyDoc_STR("(Handle h) -> (UserData theUserData)")},
 	{"CreateMovieFile", (PyCFunction)Qt_CreateMovieFile, 1,
-	 "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)"},
+	 PyDoc_STR("(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)")},
 	{"OpenMovieFile", (PyCFunction)Qt_OpenMovieFile, 1,
-	 "(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)"},
+	 PyDoc_STR("(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)")},
 	{"CloseMovieFile", (PyCFunction)Qt_CloseMovieFile, 1,
-	 "(short resRefNum) -> None"},
+	 PyDoc_STR("(short resRefNum) -> None")},
 	{"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1,
-	 "(FSSpec fileSpec) -> None"},
+	 PyDoc_STR("(FSSpec fileSpec) -> None")},
 	{"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1,
-	 "(short resRefNum, short resId, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)"},
+	 PyDoc_STR("(short resRefNum, short resId, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)")},
 	{"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1,
-	 "(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
+	 PyDoc_STR("(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
 	{"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1,
-	 "(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
+	 PyDoc_STR("(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
 	{"NewMovieFromDataFork64", (PyCFunction)Qt_NewMovieFromDataFork64, 1,
-	 "(long fRefNum, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
+	 PyDoc_STR("(long fRefNum, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
 	{"NewMovieFromDataRef", (PyCFunction)Qt_NewMovieFromDataRef, 1,
-	 "(short flags, Handle dataRef, OSType dataRefType) -> (Movie m, short id)"},
+	 PyDoc_STR("(short flags, Handle dataRef, OSType dataRefType) -> (Movie m, short id)")},
 	{"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1,
-	 "(short resRefNum, short resId) -> None"},
+	 PyDoc_STR("(short resRefNum, short resId) -> None")},
 	{"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1,
-	 "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None"},
+	 PyDoc_STR("(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None")},
 	{"CanQuickTimeOpenFile", (PyCFunction)Qt_CanQuickTimeOpenFile, 1,
-	 "(FSSpec fileSpec, OSType fileType, OSType fileNameExtension, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)"},
+	 PyDoc_STR("(FSSpec fileSpec, OSType fileType, OSType fileNameExtension, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)")},
 	{"CanQuickTimeOpenDataRef", (PyCFunction)Qt_CanQuickTimeOpenDataRef, 1,
-	 "(Handle dataRef, OSType dataRefType, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)"},
+	 PyDoc_STR("(Handle dataRef, OSType dataRefType, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)")},
 	{"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
-	 "(long newMovieFlags) -> (Movie _rv)"},
+	 PyDoc_STR("(long newMovieFlags) -> (Movie _rv)")},
 	{"QTNewAlias", (PyCFunction)Qt_QTNewAlias, 1,
-	 "(FSSpec fss, Boolean minimal) -> (AliasHandle alias)"},
+	 PyDoc_STR("(FSSpec fss, Boolean minimal) -> (AliasHandle alias)")},
 	{"EndFullScreen", (PyCFunction)Qt_EndFullScreen, 1,
-	 "(Ptr fullState, long flags) -> None"},
+	 PyDoc_STR("(Ptr fullState, long flags) -> None")},
 	{"AddSoundDescriptionExtension", (PyCFunction)Qt_AddSoundDescriptionExtension, 1,
-	 "(SoundDescriptionHandle desc, Handle extension, OSType idType) -> None"},
+	 PyDoc_STR("(SoundDescriptionHandle desc, Handle extension, OSType idType) -> None")},
 	{"GetSoundDescriptionExtension", (PyCFunction)Qt_GetSoundDescriptionExtension, 1,
-	 "(SoundDescriptionHandle desc, OSType idType) -> (Handle extension)"},
+	 PyDoc_STR("(SoundDescriptionHandle desc, OSType idType) -> (Handle extension)")},
 	{"RemoveSoundDescriptionExtension", (PyCFunction)Qt_RemoveSoundDescriptionExtension, 1,
-	 "(SoundDescriptionHandle desc, OSType idType) -> None"},
+	 PyDoc_STR("(SoundDescriptionHandle desc, OSType idType) -> None")},
 	{"QTIsStandardParameterDialogEvent", (PyCFunction)Qt_QTIsStandardParameterDialogEvent, 1,
-	 "(QTParameterDialog createdDialog) -> (EventRecord pEvent)"},
+	 PyDoc_STR("(QTParameterDialog createdDialog) -> (EventRecord pEvent)")},
 	{"QTDismissStandardParameterDialog", (PyCFunction)Qt_QTDismissStandardParameterDialog, 1,
-	 "(QTParameterDialog createdDialog) -> None"},
+	 PyDoc_STR("(QTParameterDialog createdDialog) -> None")},
 	{"QTStandardParameterDialogDoAction", (PyCFunction)Qt_QTStandardParameterDialogDoAction, 1,
-	 "(QTParameterDialog createdDialog, long action, void * params) -> None"},
+	 PyDoc_STR("(QTParameterDialog createdDialog, long action, void * params) -> None")},
 	{"QTRegisterAccessKey", (PyCFunction)Qt_QTRegisterAccessKey, 1,
-	 "(Str255 accessKeyType, long flags, Handle accessKey) -> None"},
+	 PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")},
 	{"QTUnregisterAccessKey", (PyCFunction)Qt_QTUnregisterAccessKey, 1,
-	 "(Str255 accessKeyType, long flags, Handle accessKey) -> None"},
+	 PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")},
 	{"QTTextToNativeText", (PyCFunction)Qt_QTTextToNativeText, 1,
-	 "(Handle theText, long encoding, long flags) -> None"},
+	 PyDoc_STR("(Handle theText, long encoding, long flags) -> None")},
 	{"VideoMediaResetStatistics", (PyCFunction)Qt_VideoMediaResetStatistics, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
 	{"VideoMediaGetStatistics", (PyCFunction)Qt_VideoMediaGetStatistics, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
 	{"VideoMediaGetStallCount", (PyCFunction)Qt_VideoMediaGetStallCount, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, unsigned long stalls)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, unsigned long stalls)")},
 	{"VideoMediaSetCodecParameter", (PyCFunction)Qt_VideoMediaSetCodecParameter, 1,
-	 "(MediaHandler mh, CodecType cType, OSType parameterID, long parameterChangeSeed, void * dataPtr, long dataSize) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, CodecType cType, OSType parameterID, long parameterChangeSeed, void * dataPtr, long dataSize) -> (ComponentResult _rv)")},
 	{"VideoMediaGetCodecParameter", (PyCFunction)Qt_VideoMediaGetCodecParameter, 1,
-	 "(MediaHandler mh, CodecType cType, OSType parameterID, Handle outParameterData) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, CodecType cType, OSType parameterID, Handle outParameterData) -> (ComponentResult _rv)")},
 	{"TextMediaAddTextSample", (PyCFunction)Qt_TextMediaAddTextSample, 1,
-	 "(MediaHandler mh, Ptr text, unsigned long size, short fontNumber, short fontSize, Style textFace, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor textColor, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)"},
+	 PyDoc_STR("(MediaHandler mh, Ptr text, unsigned long size, short fontNumber, short fontSize, Style textFace, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor textColor, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)")},
 	{"TextMediaAddTESample", (PyCFunction)Qt_TextMediaAddTESample, 1,
-	 "(MediaHandler mh, TEHandle hTE, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)"},
+	 PyDoc_STR("(MediaHandler mh, TEHandle hTE, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)")},
 	{"TextMediaAddHiliteSample", (PyCFunction)Qt_TextMediaAddHiliteSample, 1,
-	 "(MediaHandler mh, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor rgbHiliteColor, TimeValue sampleTime)"},
+	 PyDoc_STR("(MediaHandler mh, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor rgbHiliteColor, TimeValue sampleTime)")},
 	{"TextMediaDrawRaw", (PyCFunction)Qt_TextMediaDrawRaw, 1,
-	 "(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh) -> (ComponentResult _rv)")},
 	{"TextMediaSetTextProperty", (PyCFunction)Qt_TextMediaSetTextProperty, 1,
-	 "(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)")},
 	{"TextMediaRawSetup", (PyCFunction)Qt_TextMediaRawSetup, 1,
-	 "(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)")},
 	{"TextMediaRawIdle", (PyCFunction)Qt_TextMediaRawIdle, 1,
-	 "(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)"},
+	 PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)")},
 	{"TextMediaGetTextProperty", (PyCFunction)Qt_TextMediaGetTextProperty, 1,
-	 "(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)")},
 	{"TextMediaFindNextText", (PyCFunction)Qt_TextMediaFindNextText, 1,
-	 "(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)"},
+	 PyDoc_STR("(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)")},
 	{"TextMediaHiliteTextSample", (PyCFunction)Qt_TextMediaHiliteTextSample, 1,
-	 "(MediaHandler mh, TimeValue sampleTime, short hiliteStart, short hiliteEnd) -> (ComponentResult _rv, RGBColor rgbHiliteColor)"},
+	 PyDoc_STR("(MediaHandler mh, TimeValue sampleTime, short hiliteStart, short hiliteEnd) -> (ComponentResult _rv, RGBColor rgbHiliteColor)")},
 	{"TextMediaSetTextSampleData", (PyCFunction)Qt_TextMediaSetTextSampleData, 1,
-	 "(MediaHandler mh, void * data, OSType dataType) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * data, OSType dataType) -> (ComponentResult _rv)")},
 	{"SpriteMediaSetProperty", (PyCFunction)Qt_SpriteMediaSetProperty, 1,
-	 "(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetProperty", (PyCFunction)Qt_SpriteMediaGetProperty, 1,
-	 "(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
 	{"SpriteMediaHitTestSprites", (PyCFunction)Qt_SpriteMediaHitTestSprites, 1,
-	 "(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, short spriteHitIndex)"},
+	 PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, short spriteHitIndex)")},
 	{"SpriteMediaCountSprites", (PyCFunction)Qt_SpriteMediaCountSprites, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, short numSprites)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short numSprites)")},
 	{"SpriteMediaCountImages", (PyCFunction)Qt_SpriteMediaCountImages, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, short numImages)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short numImages)")},
 	{"SpriteMediaGetIndImageDescription", (PyCFunction)Qt_SpriteMediaGetIndImageDescription, 1,
-	 "(MediaHandler mh, short imageIndex, ImageDescriptionHandle imageDescription) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short imageIndex, ImageDescriptionHandle imageDescription) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetDisplayedSampleNumber", (PyCFunction)Qt_SpriteMediaGetDisplayedSampleNumber, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, long sampleNum)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long sampleNum)")},
 	{"SpriteMediaGetSpriteName", (PyCFunction)Qt_SpriteMediaGetSpriteName, 1,
-	 "(MediaHandler mh, QTAtomID spriteID, Str255 spriteName) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, Str255 spriteName) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetImageName", (PyCFunction)Qt_SpriteMediaGetImageName, 1,
-	 "(MediaHandler mh, short imageIndex, Str255 imageName) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short imageIndex, Str255 imageName) -> (ComponentResult _rv)")},
 	{"SpriteMediaSetSpriteProperty", (PyCFunction)Qt_SpriteMediaSetSpriteProperty, 1,
-	 "(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetSpriteProperty", (PyCFunction)Qt_SpriteMediaGetSpriteProperty, 1,
-	 "(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
 	{"SpriteMediaHitTestAllSprites", (PyCFunction)Qt_SpriteMediaHitTestAllSprites, 1,
-	 "(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, QTAtomID spriteHitID)"},
+	 PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, QTAtomID spriteHitID)")},
 	{"SpriteMediaHitTestOneSprite", (PyCFunction)Qt_SpriteMediaHitTestOneSprite, 1,
-	 "(MediaHandler mh, QTAtomID spriteID, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)")},
 	{"SpriteMediaSpriteIndexToID", (PyCFunction)Qt_SpriteMediaSpriteIndexToID, 1,
-	 "(MediaHandler mh, short spriteIndex) -> (ComponentResult _rv, QTAtomID spriteID)"},
+	 PyDoc_STR("(MediaHandler mh, short spriteIndex) -> (ComponentResult _rv, QTAtomID spriteID)")},
 	{"SpriteMediaSpriteIDToIndex", (PyCFunction)Qt_SpriteMediaSpriteIDToIndex, 1,
-	 "(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv, short spriteIndex)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv, short spriteIndex)")},
 	{"SpriteMediaSetActionVariable", (PyCFunction)Qt_SpriteMediaSetActionVariable, 1,
-	 "(MediaHandler mh, QTAtomID variableID, float value) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID variableID, float value) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetActionVariable", (PyCFunction)Qt_SpriteMediaGetActionVariable, 1,
-	 "(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, float value)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, float value)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SpriteMediaGetIndImageProperty", (PyCFunction)Qt_SpriteMediaGetIndImageProperty, 1,
-	 "(MediaHandler mh, short imageIndex, long imagePropertyType, void * imagePropertyValue) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short imageIndex, long imagePropertyType, void * imagePropertyValue) -> (ComponentResult _rv)")},
 #endif
 	{"SpriteMediaDisposeSprite", (PyCFunction)Qt_SpriteMediaDisposeSprite, 1,
-	 "(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv)")},
 	{"SpriteMediaSetActionVariableToString", (PyCFunction)Qt_SpriteMediaSetActionVariableToString, 1,
-	 "(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetActionVariableAsString", (PyCFunction)Qt_SpriteMediaGetActionVariableAsString, 1,
-	 "(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)")},
 	{"FlashMediaSetPan", (PyCFunction)Qt_FlashMediaSetPan, 1,
-	 "(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)")},
 	{"FlashMediaSetZoom", (PyCFunction)Qt_FlashMediaSetZoom, 1,
-	 "(MediaHandler mh, short factor) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short factor) -> (ComponentResult _rv)")},
 	{"FlashMediaSetZoomRect", (PyCFunction)Qt_FlashMediaSetZoomRect, 1,
-	 "(MediaHandler mh, long left, long top, long right, long bottom) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, long left, long top, long right, long bottom) -> (ComponentResult _rv)")},
 	{"FlashMediaGetRefConBounds", (PyCFunction)Qt_FlashMediaGetRefConBounds, 1,
-	 "(MediaHandler mh, long refCon) -> (ComponentResult _rv, long left, long top, long right, long bottom)"},
+	 PyDoc_STR("(MediaHandler mh, long refCon) -> (ComponentResult _rv, long left, long top, long right, long bottom)")},
 	{"FlashMediaGetRefConID", (PyCFunction)Qt_FlashMediaGetRefConID, 1,
-	 "(MediaHandler mh, long refCon) -> (ComponentResult _rv, long refConID)"},
+	 PyDoc_STR("(MediaHandler mh, long refCon) -> (ComponentResult _rv, long refConID)")},
 	{"FlashMediaIDToRefCon", (PyCFunction)Qt_FlashMediaIDToRefCon, 1,
-	 "(MediaHandler mh, long refConID) -> (ComponentResult _rv, long refCon)"},
+	 PyDoc_STR("(MediaHandler mh, long refConID) -> (ComponentResult _rv, long refCon)")},
 	{"FlashMediaGetDisplayedFrameNumber", (PyCFunction)Qt_FlashMediaGetDisplayedFrameNumber, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, long flashFrameNumber)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long flashFrameNumber)")},
 	{"FlashMediaFrameNumberToMovieTime", (PyCFunction)Qt_FlashMediaFrameNumberToMovieTime, 1,
-	 "(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)"},
+	 PyDoc_STR("(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)")},
 	{"FlashMediaFrameLabelToMovieTime", (PyCFunction)Qt_FlashMediaFrameLabelToMovieTime, 1,
-	 "(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)"},
+	 PyDoc_STR("(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)")},
 	{"FlashMediaGetFlashVariable", (PyCFunction)Qt_FlashMediaGetFlashVariable, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, char path, char name, Handle theVariableCStringOut)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, char path, char name, Handle theVariableCStringOut)")},
 	{"FlashMediaSetFlashVariable", (PyCFunction)Qt_FlashMediaSetFlashVariable, 1,
-	 "(MediaHandler mh, Boolean updateFocus) -> (ComponentResult _rv, char path, char name, char value)"},
+	 PyDoc_STR("(MediaHandler mh, Boolean updateFocus) -> (ComponentResult _rv, char path, char name, char value)")},
 	{"FlashMediaDoButtonActions", (PyCFunction)Qt_FlashMediaDoButtonActions, 1,
-	 "(MediaHandler mh, long buttonID, long transition) -> (ComponentResult _rv, char path)"},
+	 PyDoc_STR("(MediaHandler mh, long buttonID, long transition) -> (ComponentResult _rv, char path)")},
 	{"FlashMediaGetSupportedSwfVersion", (PyCFunction)Qt_FlashMediaGetSupportedSwfVersion, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, UInt8 swfVersion)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, UInt8 swfVersion)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"MovieMediaGetCurrentMovieProperty", (PyCFunction)Qt_MovieMediaGetCurrentMovieProperty, 1,
-	 "(MediaHandler mh, OSType whichProperty, void * value) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, OSType whichProperty, void * value) -> (ComponentResult _rv)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"MovieMediaGetCurrentTrackProperty", (PyCFunction)Qt_MovieMediaGetCurrentTrackProperty, 1,
-	 "(MediaHandler mh, long trackID, OSType whichProperty, void * value) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, long trackID, OSType whichProperty, void * value) -> (ComponentResult _rv)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"MovieMediaGetChildMovieDataReference", (PyCFunction)Qt_MovieMediaGetChildMovieDataReference, 1,
-	 "(MediaHandler mh, QTAtomID dataRefID, short dataRefIndex) -> (ComponentResult _rv, OSType dataRefType, Handle dataRef, QTAtomID dataRefIDOut, short dataRefIndexOut)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID dataRefID, short dataRefIndex) -> (ComponentResult _rv, OSType dataRefType, Handle dataRef, QTAtomID dataRefIDOut, short dataRefIndexOut)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"MovieMediaSetChildMovieDataReference", (PyCFunction)Qt_MovieMediaSetChildMovieDataReference, 1,
-	 "(MediaHandler mh, QTAtomID dataRefID, OSType dataRefType, Handle dataRef) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID dataRefID, OSType dataRefType, Handle dataRef) -> (ComponentResult _rv)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"MovieMediaLoadChildMovieFromDataReference", (PyCFunction)Qt_MovieMediaLoadChildMovieFromDataReference, 1,
-	 "(MediaHandler mh, QTAtomID dataRefID) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID dataRefID) -> (ComponentResult _rv)")},
 #endif
 	{"Media3DGetCurrentGroup", (PyCFunction)Qt_Media3DGetCurrentGroup, 1,
-	 "(MediaHandler mh, void * group) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * group) -> (ComponentResult _rv)")},
 	{"Media3DTranslateNamedObjectTo", (PyCFunction)Qt_Media3DTranslateNamedObjectTo, 1,
-	 "(MediaHandler mh, Fixed x, Fixed y, Fixed z) -> (ComponentResult _rv, char objectName)"},
+	 PyDoc_STR("(MediaHandler mh, Fixed x, Fixed y, Fixed z) -> (ComponentResult _rv, char objectName)")},
 	{"Media3DScaleNamedObjectTo", (PyCFunction)Qt_Media3DScaleNamedObjectTo, 1,
-	 "(MediaHandler mh, Fixed xScale, Fixed yScale, Fixed zScale) -> (ComponentResult _rv, char objectName)"},
+	 PyDoc_STR("(MediaHandler mh, Fixed xScale, Fixed yScale, Fixed zScale) -> (ComponentResult _rv, char objectName)")},
 	{"Media3DRotateNamedObjectTo", (PyCFunction)Qt_Media3DRotateNamedObjectTo, 1,
-	 "(MediaHandler mh, Fixed xDegrees, Fixed yDegrees, Fixed zDegrees) -> (ComponentResult _rv, char objectName)"},
+	 PyDoc_STR("(MediaHandler mh, Fixed xDegrees, Fixed yDegrees, Fixed zDegrees) -> (ComponentResult _rv, char objectName)")},
 	{"Media3DSetCameraData", (PyCFunction)Qt_Media3DSetCameraData, 1,
-	 "(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)")},
 	{"Media3DGetCameraData", (PyCFunction)Qt_Media3DGetCameraData, 1,
-	 "(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)")},
 	{"Media3DSetCameraAngleAspect", (PyCFunction)Qt_Media3DSetCameraAngleAspect, 1,
-	 "(MediaHandler mh, QTFloatSingle fov, QTFloatSingle aspectRatioXToY) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTFloatSingle fov, QTFloatSingle aspectRatioXToY) -> (ComponentResult _rv)")},
 	{"Media3DGetCameraAngleAspect", (PyCFunction)Qt_Media3DGetCameraAngleAspect, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, QTFloatSingle fov, QTFloatSingle aspectRatioXToY)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, QTFloatSingle fov, QTFloatSingle aspectRatioXToY)")},
 	{"Media3DSetCameraRange", (PyCFunction)Qt_Media3DSetCameraRange, 1,
-	 "(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)")},
 	{"Media3DGetCameraRange", (PyCFunction)Qt_Media3DGetCameraRange, 1,
-	 "(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"Media3DGetViewObject", (PyCFunction)Qt_Media3DGetViewObject, 1,
-	 "(MediaHandler mh, void * tq3viewObject) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * tq3viewObject) -> (ComponentResult _rv)")},
 #endif
 	{"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
-	 "() -> (TimeBase _rv)"},
+	 PyDoc_STR("() -> (TimeBase _rv)")},
 	{"ConvertTime", (PyCFunction)Qt_ConvertTime, 1,
-	 "(TimeBase newBase) -> (TimeRecord theTime)"},
+	 PyDoc_STR("(TimeBase newBase) -> (TimeRecord theTime)")},
 	{"ConvertTimeScale", (PyCFunction)Qt_ConvertTimeScale, 1,
-	 "(TimeScale newScale) -> (TimeRecord theTime)"},
+	 PyDoc_STR("(TimeScale newScale) -> (TimeRecord theTime)")},
 	{"AddTime", (PyCFunction)Qt_AddTime, 1,
-	 "(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"},
+	 PyDoc_STR("(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)")},
 	{"SubtractTime", (PyCFunction)Qt_SubtractTime, 1,
-	 "(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"},
+	 PyDoc_STR("(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)")},
 	{"MusicMediaGetIndexedTunePlayer", (PyCFunction)Qt_MusicMediaGetIndexedTunePlayer, 1,
-	 "(ComponentInstance ti, long sampleDescIndex) -> (ComponentResult _rv, ComponentInstance tp)"},
+	 PyDoc_STR("(ComponentInstance ti, long sampleDescIndex) -> (ComponentResult _rv, ComponentInstance tp)")},
 	{"AlignWindow", (PyCFunction)Qt_AlignWindow, 1,
-	 "(WindowPtr wp, Boolean front) -> None"},
+	 PyDoc_STR("(WindowPtr wp, Boolean front) -> None")},
 	{"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1,
-	 "(WindowPtr wp, Point startPt, Rect boundsRect) -> None"},
+	 PyDoc_STR("(WindowPtr wp, Point startPt, Rect boundsRect) -> None")},
 	{"MoviesTask", (PyCFunction)Qt_MoviesTask, 1,
-	 "(long maxMilliSecToUse) -> None"},
+	 PyDoc_STR("(long maxMilliSecToUse) -> None")},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/res/_Resmodule.c b/Mac/Modules/res/_Resmodule.c
index 2dbea6d..5665c47 100644
--- a/Mac/Modules/res/_Resmodule.c
+++ b/Mac/Modules/res/_Resmodule.c
@@ -501,50 +501,50 @@ static PyObject *ResObj_AutoDispose(ResourceObject *_self, PyObject *_args)
 
 static PyMethodDef ResObj_methods[] = {
 	{"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"MacLoadResource", (PyCFunction)ResObj_MacLoadResource, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DetachResource", (PyCFunction)ResObj_DetachResource, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1,
-	 "() -> (short theID, ResType theType, Str255 name)"},
+	 PyDoc_STR("() -> (short theID, ResType theType, Str255 name)")},
 	{"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1,
-	 "(short theID, Str255 name) -> None"},
+	 PyDoc_STR("(short theID, Str255 name) -> None")},
 	{"AddResource", (PyCFunction)ResObj_AddResource, 1,
-	 "(ResType theType, short theID, Str255 name) -> None"},
+	 PyDoc_STR("(ResType theType, short theID, Str255 name) -> None")},
 	{"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 
 #if TARGET_API_MAC_OS8
 	{"RsrcMapEntry", (PyCFunction)ResObj_RsrcMapEntry, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 #endif
 	{"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1,
-	 "(short attrs) -> None"},
+	 PyDoc_STR("(short attrs) -> None")},
 	{"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"WriteResource", (PyCFunction)ResObj_WriteResource, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1,
-	 "(long newSize) -> None"},
+	 PyDoc_STR("(long newSize) -> None")},
 	{"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"as_Control", (PyCFunction)ResObj_as_Control, 1,
-	 "Return this resource/handle as a Control"},
+	 PyDoc_STR("Return this resource/handle as a Control")},
 	{"as_Menu", (PyCFunction)ResObj_as_Menu, 1,
-	 "Return this resource/handle as a Menu"},
+	 PyDoc_STR("Return this resource/handle as a Menu")},
 	{"LoadResource", (PyCFunction)ResObj_LoadResource, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"AutoDispose", (PyCFunction)ResObj_AutoDispose, 1,
-	 "(int)->int. Automatically DisposeHandle the object on Python object cleanup"},
+	 PyDoc_STR("(int)->int. Automatically DisposeHandle the object on Python object cleanup")},
 	{NULL, NULL, 0}
 };
 
@@ -1720,134 +1720,134 @@ static PyMethodDef Res_methods[] = {
 
 #if TARGET_API_MAC_OS8
 	{"InitResources", (PyCFunction)Res_InitResources, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 #endif
 
 #if TARGET_API_MAC_OS8
 	{"RsrcZoneInit", (PyCFunction)Res_RsrcZoneInit, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 	{"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
-	 "(short refNum) -> None"},
+	 PyDoc_STR("(short refNum) -> None")},
 	{"ResError", (PyCFunction)Res_ResError, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CurResFile", (PyCFunction)Res_CurResFile, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 
 #if TARGET_API_MAC_OS8
 	{"CreateResFile", (PyCFunction)Res_CreateResFile, 1,
-	 "(Str255 fileName) -> None"},
+	 PyDoc_STR("(Str255 fileName) -> None")},
 #endif
 
 #if TARGET_API_MAC_OS8
 	{"OpenResFile", (PyCFunction)Res_OpenResFile, 1,
-	 "(Str255 fileName) -> (short _rv)"},
+	 PyDoc_STR("(Str255 fileName) -> (short _rv)")},
 #endif
 	{"UseResFile", (PyCFunction)Res_UseResFile, 1,
-	 "(short refNum) -> None"},
+	 PyDoc_STR("(short refNum) -> None")},
 	{"CountTypes", (PyCFunction)Res_CountTypes, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"Count1Types", (PyCFunction)Res_Count1Types, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"GetIndType", (PyCFunction)Res_GetIndType, 1,
-	 "(short index) -> (ResType theType)"},
+	 PyDoc_STR("(short index) -> (ResType theType)")},
 	{"Get1IndType", (PyCFunction)Res_Get1IndType, 1,
-	 "(short index) -> (ResType theType)"},
+	 PyDoc_STR("(short index) -> (ResType theType)")},
 	{"SetResLoad", (PyCFunction)Res_SetResLoad, 1,
-	 "(Boolean load) -> None"},
+	 PyDoc_STR("(Boolean load) -> None")},
 	{"CountResources", (PyCFunction)Res_CountResources, 1,
-	 "(ResType theType) -> (short _rv)"},
+	 PyDoc_STR("(ResType theType) -> (short _rv)")},
 	{"Count1Resources", (PyCFunction)Res_Count1Resources, 1,
-	 "(ResType theType) -> (short _rv)"},
+	 PyDoc_STR("(ResType theType) -> (short _rv)")},
 	{"GetIndResource", (PyCFunction)Res_GetIndResource, 1,
-	 "(ResType theType, short index) -> (Handle _rv)"},
+	 PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")},
 	{"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1,
-	 "(ResType theType, short index) -> (Handle _rv)"},
+	 PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")},
 	{"GetResource", (PyCFunction)Res_GetResource, 1,
-	 "(ResType theType, short theID) -> (Handle _rv)"},
+	 PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")},
 	{"Get1Resource", (PyCFunction)Res_Get1Resource, 1,
-	 "(ResType theType, short theID) -> (Handle _rv)"},
+	 PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")},
 	{"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1,
-	 "(ResType theType, Str255 name) -> (Handle _rv)"},
+	 PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")},
 	{"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1,
-	 "(ResType theType, Str255 name) -> (Handle _rv)"},
+	 PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")},
 	{"UniqueID", (PyCFunction)Res_UniqueID, 1,
-	 "(ResType theType) -> (short _rv)"},
+	 PyDoc_STR("(ResType theType) -> (short _rv)")},
 	{"Unique1ID", (PyCFunction)Res_Unique1ID, 1,
-	 "(ResType theType) -> (short _rv)"},
+	 PyDoc_STR("(ResType theType) -> (short _rv)")},
 	{"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1,
-	 "(short refNum) -> None"},
+	 PyDoc_STR("(short refNum) -> None")},
 	{"SetResPurge", (PyCFunction)Res_SetResPurge, 1,
-	 "(Boolean install) -> None"},
+	 PyDoc_STR("(Boolean install) -> None")},
 	{"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1,
-	 "(short refNum) -> (short _rv)"},
+	 PyDoc_STR("(short refNum) -> (short _rv)")},
 	{"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1,
-	 "(short refNum, short attrs) -> None"},
+	 PyDoc_STR("(short refNum, short attrs) -> None")},
 	{"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1,
-	 "(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)"},
+	 PyDoc_STR("(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)")},
 
 #if TARGET_API_MAC_OS8
 	{"RGetResource", (PyCFunction)Res_RGetResource, 1,
-	 "(ResType theType, short theID) -> (Handle _rv)"},
+	 PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")},
 #endif
 	{"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1,
-	 "(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)"},
+	 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)")},
 	{"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1,
-	 "(short vRefNum, long dirID, Str255 fileName) -> None"},
+	 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")},
 	{"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1,
-	 "(FSSpec spec, SignedByte permission) -> (short _rv)"},
+	 PyDoc_STR("(FSSpec spec, SignedByte permission) -> (short _rv)")},
 	{"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
-	 "(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"},
+	 PyDoc_STR("(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"InsertResourceFile", (PyCFunction)Res_InsertResourceFile, 1,
-	 "(SInt16 refNum, RsrcChainLocation where) -> None"},
+	 PyDoc_STR("(SInt16 refNum, RsrcChainLocation where) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"DetachResourceFile", (PyCFunction)Res_DetachResourceFile, 1,
-	 "(SInt16 refNum) -> None"},
+	 PyDoc_STR("(SInt16 refNum) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"FSpResourceFileAlreadyOpen", (PyCFunction)Res_FSpResourceFileAlreadyOpen, 1,
-	 "(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"},
+	 PyDoc_STR("(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"FSpOpenOrphanResFile", (PyCFunction)Res_FSpOpenOrphanResFile, 1,
-	 "(FSSpec spec, SignedByte permission) -> (SInt16 refNum)"},
+	 PyDoc_STR("(FSSpec spec, SignedByte permission) -> (SInt16 refNum)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetTopResourceFile", (PyCFunction)Res_GetTopResourceFile, 1,
-	 "() -> (SInt16 refNum)"},
+	 PyDoc_STR("() -> (SInt16 refNum)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"GetNextResourceFile", (PyCFunction)Res_GetNextResourceFile, 1,
-	 "(SInt16 curRefNum) -> (SInt16 nextRefNum)"},
+	 PyDoc_STR("(SInt16 curRefNum) -> (SInt16 nextRefNum)")},
 #endif
 	{"FSOpenResFile", (PyCFunction)Res_FSOpenResFile, 1,
-	 "(FSRef ref, SignedByte permission) -> (short _rv)"},
+	 PyDoc_STR("(FSRef ref, SignedByte permission) -> (short _rv)")},
 	{"FSCreateResFile", (PyCFunction)Res_FSCreateResFile, 1,
-	 "(FSRef parentRef, Buffer nameLength) -> (FSRef newRef, FSSpec newSpec)"},
+	 PyDoc_STR("(FSRef parentRef, Buffer nameLength) -> (FSRef newRef, FSSpec newSpec)")},
 	{"FSResourceFileAlreadyOpen", (PyCFunction)Res_FSResourceFileAlreadyOpen, 1,
-	 "(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"},
+	 PyDoc_STR("(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")},
 
 #if TARGET_API_MAC_CARBON
 	{"FSCreateResourceFile", (PyCFunction)Res_FSCreateResourceFile, 1,
-	 "(FSRef parentRef, Buffer nameLength, Buffer forkNameLength) -> (FSRef newRef, FSSpec newSpec)"},
+	 PyDoc_STR("(FSRef parentRef, Buffer nameLength, Buffer forkNameLength) -> (FSRef newRef, FSSpec newSpec)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"FSOpenResourceFile", (PyCFunction)Res_FSOpenResourceFile, 1,
-	 "(FSRef ref, Buffer forkNameLength, SignedByte permissions) -> (SInt16 refNum)"},
+	 PyDoc_STR("(FSRef ref, Buffer forkNameLength, SignedByte permissions) -> (SInt16 refNum)")},
 #endif
 	{"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"},
+	 PyDoc_STR("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,
-	 "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"},
+	 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}
 };
 
diff --git a/Mac/Modules/snd/_Sndmodule.c b/Mac/Modules/snd/_Sndmodule.c
index 7a8f9fd..7ce4799 100644
--- a/Mac/Modules/snd/_Sndmodule.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/te/_TEmodule.c b/Mac/Modules/te/_TEmodule.c
index c83eb84..1788620 100644
--- a/Mac/Modules/te/_TEmodule.c
+++ b/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}
 };
 
diff --git a/Mac/Modules/win/_Winmodule.c b/Mac/Modules/win/_Winmodule.c
index 30301e0..0685c26 100644
--- a/Mac/Modules/win/_Winmodule.c
+++ b/Mac/Modules/win/_Winmodule.c
@@ -2566,363 +2566,363 @@ static PyObject *WinObj_ShowWindow(WindowObject *_self, PyObject *_args)
 
 static PyMethodDef WinObj_methods[] = {
 	{"GetWindowOwnerCount", (PyCFunction)WinObj_GetWindowOwnerCount, 1,
-	 "() -> (UInt32 outCount)"},
+	 PyDoc_STR("() -> (UInt32 outCount)")},
 	{"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 
 #if !TARGET_API_MAC_OS8
 	{"GetWindowRetainCount", (PyCFunction)WinObj_GetWindowRetainCount, 1,
-	 "() -> (ItemCount _rv)"},
+	 PyDoc_STR("() -> (ItemCount _rv)")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"RetainWindow", (PyCFunction)WinObj_RetainWindow, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"ReleaseWindow", (PyCFunction)WinObj_ReleaseWindow, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"ReshapeCustomWindow", (PyCFunction)WinObj_ReshapeCustomWindow, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 	{"GetWindowWidgetHilite", (PyCFunction)WinObj_GetWindowWidgetHilite, 1,
-	 "() -> (WindowDefPartCode outHilite)"},
+	 PyDoc_STR("() -> (WindowDefPartCode outHilite)")},
 	{"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1,
-	 "() -> (WindowClass outClass)"},
+	 PyDoc_STR("() -> (WindowClass outClass)")},
 	{"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1,
-	 "() -> (WindowAttributes outAttributes)"},
+	 PyDoc_STR("() -> (WindowAttributes outAttributes)")},
 
 #if !TARGET_API_MAC_OS8
 	{"ChangeWindowAttributes", (PyCFunction)WinObj_ChangeWindowAttributes, 1,
-	 "(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None"},
+	 PyDoc_STR("(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"SetWindowClass", (PyCFunction)WinObj_SetWindowClass, 1,
-	 "(WindowClass inWindowClass) -> None"},
+	 PyDoc_STR("(WindowClass inWindowClass) -> None")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"SetWindowModality", (PyCFunction)WinObj_SetWindowModality, 1,
-	 "(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None"},
+	 PyDoc_STR("(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"GetWindowModality", (PyCFunction)WinObj_GetWindowModality, 1,
-	 "() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)"},
+	 PyDoc_STR("() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"SetWinColor", (PyCFunction)WinObj_SetWinColor, 1,
-	 "(WCTabHandle newColorTable) -> None"},
+	 PyDoc_STR("(WCTabHandle newColorTable) -> None")},
 #endif
 	{"SetWindowContentColor", (PyCFunction)WinObj_SetWindowContentColor, 1,
-	 "(RGBColor color) -> None"},
+	 PyDoc_STR("(RGBColor color) -> None")},
 	{"GetWindowContentColor", (PyCFunction)WinObj_GetWindowContentColor, 1,
-	 "() -> (RGBColor color)"},
+	 PyDoc_STR("() -> (RGBColor color)")},
 	{"GetWindowContentPattern", (PyCFunction)WinObj_GetWindowContentPattern, 1,
-	 "(PixPatHandle outPixPat) -> None"},
+	 PyDoc_STR("(PixPatHandle outPixPat) -> None")},
 	{"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1,
-	 "(PixPatHandle pixPat) -> None"},
+	 PyDoc_STR("(PixPatHandle pixPat) -> None")},
 
 #if !TARGET_API_MAC_OS8
 	{"ScrollWindowRect", (PyCFunction)WinObj_ScrollWindowRect, 1,
-	 "(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
+	 PyDoc_STR("(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"ScrollWindowRegion", (PyCFunction)WinObj_ScrollWindowRegion, 1,
-	 "(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
+	 PyDoc_STR("(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")},
 #endif
 	{"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SaveOld", (PyCFunction)WinObj_SaveOld, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"DrawNew", (PyCFunction)WinObj_DrawNew, 1,
-	 "(Boolean update) -> None"},
+	 PyDoc_STR("(Boolean update) -> None")},
 #endif
 	{"PaintOne", (PyCFunction)WinObj_PaintOne, 1,
-	 "(RgnHandle clobberedRgn) -> None"},
+	 PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
 	{"PaintBehind", (PyCFunction)WinObj_PaintBehind, 1,
-	 "(RgnHandle clobberedRgn) -> None"},
+	 PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
 	{"CalcVis", (PyCFunction)WinObj_CalcVis, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CalcVisBehind", (PyCFunction)WinObj_CalcVisBehind, 1,
-	 "(RgnHandle clobberedRgn) -> None"},
+	 PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
 	{"BringToFront", (PyCFunction)WinObj_BringToFront, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SendBehind", (PyCFunction)WinObj_SendBehind, 1,
-	 "(WindowPtr behindWindow) -> None"},
+	 PyDoc_STR("(WindowPtr behindWindow) -> None")},
 	{"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 
 #if !TARGET_API_MAC_OS8
 	{"GetNextWindowOfClass", (PyCFunction)WinObj_GetNextWindowOfClass, 1,
-	 "(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
+	 PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"SetWindowAlternateTitle", (PyCFunction)WinObj_SetWindowAlternateTitle, 1,
-	 "(CFStringRef inTitle) -> None"},
+	 PyDoc_STR("(CFStringRef inTitle) -> None")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"CopyWindowAlternateTitle", (PyCFunction)WinObj_CopyWindowAlternateTitle, 1,
-	 "() -> (CFStringRef outTitle)"},
+	 PyDoc_STR("() -> (CFStringRef outTitle)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"IsValidWindowPtr", (PyCFunction)WinObj_IsValidWindowPtr, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 	{"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1,
-	 "(Boolean fHilite) -> None"},
+	 PyDoc_STR("(Boolean fHilite) -> None")},
 	{"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1,
-	 "(long data) -> None"},
+	 PyDoc_STR("(long data) -> None")},
 	{"GetWRefCon", (PyCFunction)WinObj_GetWRefCon, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"SetWindowPic", (PyCFunction)WinObj_SetWindowPic, 1,
-	 "(PicHandle pic) -> None"},
+	 PyDoc_STR("(PicHandle pic) -> None")},
 	{"GetWindowPic", (PyCFunction)WinObj_GetWindowPic, 1,
-	 "() -> (PicHandle _rv)"},
+	 PyDoc_STR("() -> (PicHandle _rv)")},
 	{"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"GetWindowFeatures", (PyCFunction)WinObj_GetWindowFeatures, 1,
-	 "() -> (UInt32 outFeatures)"},
+	 PyDoc_STR("() -> (UInt32 outFeatures)")},
 	{"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1,
-	 "(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None"},
+	 PyDoc_STR("(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None")},
 	{"GetWindowStructureWidths", (PyCFunction)WinObj_GetWindowStructureWidths, 1,
-	 "() -> (Rect outRect)"},
+	 PyDoc_STR("() -> (Rect outRect)")},
 	{"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"InvalWindowRgn", (PyCFunction)WinObj_InvalWindowRgn, 1,
-	 "(RgnHandle region) -> None"},
+	 PyDoc_STR("(RgnHandle region) -> None")},
 	{"InvalWindowRect", (PyCFunction)WinObj_InvalWindowRect, 1,
-	 "(Rect bounds) -> None"},
+	 PyDoc_STR("(Rect bounds) -> None")},
 	{"ValidWindowRgn", (PyCFunction)WinObj_ValidWindowRgn, 1,
-	 "(RgnHandle region) -> None"},
+	 PyDoc_STR("(RgnHandle region) -> None")},
 	{"ValidWindowRect", (PyCFunction)WinObj_ValidWindowRect, 1,
-	 "(Rect bounds) -> None"},
+	 PyDoc_STR("(Rect bounds) -> None")},
 	{"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1,
-	 "(Str255 title) -> None"},
+	 PyDoc_STR("(Str255 title) -> None")},
 	{"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
-	 "() -> (Str255 title)"},
+	 PyDoc_STR("() -> (Str255 title)")},
 
 #if !TARGET_API_MAC_OS8
 	{"SetWindowTitleWithCFString", (PyCFunction)WinObj_SetWindowTitleWithCFString, 1,
-	 "(CFStringRef inString) -> None"},
+	 PyDoc_STR("(CFStringRef inString) -> None")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"CopyWindowTitleAsCFString", (PyCFunction)WinObj_CopyWindowTitleAsCFString, 1,
-	 "() -> (CFStringRef outString)"},
+	 PyDoc_STR("() -> (CFStringRef outString)")},
 #endif
 	{"SetWindowProxyFSSpec", (PyCFunction)WinObj_SetWindowProxyFSSpec, 1,
-	 "(FSSpec inFile) -> None"},
+	 PyDoc_STR("(FSSpec inFile) -> None")},
 	{"GetWindowProxyFSSpec", (PyCFunction)WinObj_GetWindowProxyFSSpec, 1,
-	 "() -> (FSSpec outFile)"},
+	 PyDoc_STR("() -> (FSSpec outFile)")},
 	{"SetWindowProxyAlias", (PyCFunction)WinObj_SetWindowProxyAlias, 1,
-	 "(AliasHandle alias) -> None"},
+	 PyDoc_STR("(AliasHandle alias) -> None")},
 	{"GetWindowProxyAlias", (PyCFunction)WinObj_GetWindowProxyAlias, 1,
-	 "() -> (AliasHandle alias)"},
+	 PyDoc_STR("() -> (AliasHandle alias)")},
 	{"SetWindowProxyCreatorAndType", (PyCFunction)WinObj_SetWindowProxyCreatorAndType, 1,
-	 "(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None"},
+	 PyDoc_STR("(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None")},
 	{"GetWindowProxyIcon", (PyCFunction)WinObj_GetWindowProxyIcon, 1,
-	 "() -> (IconRef outIcon)"},
+	 PyDoc_STR("() -> (IconRef outIcon)")},
 	{"SetWindowProxyIcon", (PyCFunction)WinObj_SetWindowProxyIcon, 1,
-	 "(IconRef icon) -> None"},
+	 PyDoc_STR("(IconRef icon) -> None")},
 	{"RemoveWindowProxy", (PyCFunction)WinObj_RemoveWindowProxy, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"BeginWindowProxyDrag", (PyCFunction)WinObj_BeginWindowProxyDrag, 1,
-	 "(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)"},
+	 PyDoc_STR("(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)")},
 	{"EndWindowProxyDrag", (PyCFunction)WinObj_EndWindowProxyDrag, 1,
-	 "(DragReference theDrag) -> None"},
+	 PyDoc_STR("(DragReference theDrag) -> None")},
 	{"TrackWindowProxyFromExistingDrag", (PyCFunction)WinObj_TrackWindowProxyFromExistingDrag, 1,
-	 "(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None"},
+	 PyDoc_STR("(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None")},
 	{"TrackWindowProxyDrag", (PyCFunction)WinObj_TrackWindowProxyDrag, 1,
-	 "(Point startPt) -> None"},
+	 PyDoc_STR("(Point startPt) -> None")},
 	{"IsWindowModified", (PyCFunction)WinObj_IsWindowModified, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"SetWindowModified", (PyCFunction)WinObj_SetWindowModified, 1,
-	 "(Boolean modified) -> None"},
+	 PyDoc_STR("(Boolean modified) -> None")},
 	{"IsWindowPathSelectClick", (PyCFunction)WinObj_IsWindowPathSelectClick, 1,
-	 "(EventRecord event) -> (Boolean _rv)"},
+	 PyDoc_STR("(EventRecord event) -> (Boolean _rv)")},
 	{"WindowPathSelect", (PyCFunction)WinObj_WindowPathSelect, 1,
-	 "(MenuHandle menu) -> (SInt32 outMenuResult)"},
+	 PyDoc_STR("(MenuHandle menu) -> (SInt32 outMenuResult)")},
 	{"HiliteWindowFrameForDrag", (PyCFunction)WinObj_HiliteWindowFrameForDrag, 1,
-	 "(Boolean hilited) -> None"},
+	 PyDoc_STR("(Boolean hilited) -> None")},
 	{"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1,
-	 "(WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"},
+	 PyDoc_STR("(WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None")},
 
 #if TARGET_API_MAC_OSX
 	{"TransitionWindowAndParent", (PyCFunction)WinObj_TransitionWindowAndParent, 1,
-	 "(WindowPtr parentWindow, WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"},
+	 PyDoc_STR("(WindowPtr parentWindow, WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None")},
 #endif
 	{"MacMoveWindow", (PyCFunction)WinObj_MacMoveWindow, 1,
-	 "(short hGlobal, short vGlobal, Boolean front) -> None"},
+	 PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")},
 	{"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
-	 "(short w, short h, Boolean fUpdate) -> None"},
+	 PyDoc_STR("(short w, short h, Boolean fUpdate) -> None")},
 	{"GrowWindow", (PyCFunction)WinObj_GrowWindow, 1,
-	 "(Point startPt, Rect bBox) -> (long _rv)"},
+	 PyDoc_STR("(Point startPt, Rect bBox) -> (long _rv)")},
 	{"DragWindow", (PyCFunction)WinObj_DragWindow, 1,
-	 "(Point startPt, Rect boundsRect) -> None"},
+	 PyDoc_STR("(Point startPt, Rect boundsRect) -> None")},
 	{"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1,
-	 "(WindowPartCode partCode, Boolean front) -> None"},
+	 PyDoc_STR("(WindowPartCode partCode, Boolean front) -> None")},
 	{"IsWindowCollapsable", (PyCFunction)WinObj_IsWindowCollapsable, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"IsWindowCollapsed", (PyCFunction)WinObj_IsWindowCollapsed, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"CollapseWindow", (PyCFunction)WinObj_CollapseWindow, 1,
-	 "(Boolean collapse) -> None"},
+	 PyDoc_STR("(Boolean collapse) -> None")},
 	{"GetWindowBounds", (PyCFunction)WinObj_GetWindowBounds, 1,
-	 "(WindowRegionCode regionCode) -> (Rect globalBounds)"},
+	 PyDoc_STR("(WindowRegionCode regionCode) -> (Rect globalBounds)")},
 	{"ResizeWindow", (PyCFunction)WinObj_ResizeWindow, 1,
-	 "(Point startPoint, Rect sizeConstraints) -> (Boolean _rv, Rect newContentRect)"},
+	 PyDoc_STR("(Point startPoint, Rect sizeConstraints) -> (Boolean _rv, Rect newContentRect)")},
 	{"SetWindowBounds", (PyCFunction)WinObj_SetWindowBounds, 1,
-	 "(WindowRegionCode regionCode, Rect globalBounds) -> None"},
+	 PyDoc_STR("(WindowRegionCode regionCode, Rect globalBounds) -> None")},
 	{"RepositionWindow", (PyCFunction)WinObj_RepositionWindow, 1,
-	 "(WindowPtr parentWindow, WindowPositionMethod method) -> None"},
+	 PyDoc_STR("(WindowPtr parentWindow, WindowPositionMethod method) -> None")},
 	{"MoveWindowStructure", (PyCFunction)WinObj_MoveWindowStructure, 1,
-	 "(short hGlobal, short vGlobal) -> None"},
+	 PyDoc_STR("(short hGlobal, short vGlobal) -> None")},
 	{"IsWindowInStandardState", (PyCFunction)WinObj_IsWindowInStandardState, 1,
-	 "() -> (Boolean _rv, Point idealSize, Rect idealStandardState)"},
+	 PyDoc_STR("() -> (Boolean _rv, Point idealSize, Rect idealStandardState)")},
 	{"ZoomWindowIdeal", (PyCFunction)WinObj_ZoomWindowIdeal, 1,
-	 "(WindowPartCode partCode) -> (Point ioIdealSize)"},
+	 PyDoc_STR("(WindowPartCode partCode) -> (Point ioIdealSize)")},
 	{"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1,
-	 "() -> (Rect userState)"},
+	 PyDoc_STR("() -> (Rect userState)")},
 	{"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1,
-	 "(Rect userState) -> None"},
+	 PyDoc_STR("(Rect userState) -> None")},
 
 #if !TARGET_API_MAC_OS8
 	{"GetWindowGreatestAreaDevice", (PyCFunction)WinObj_GetWindowGreatestAreaDevice, 1,
-	 "(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)"},
+	 PyDoc_STR("(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"ConstrainWindowToScreen", (PyCFunction)WinObj_ConstrainWindowToScreen, 1,
-	 "(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)"},
+	 PyDoc_STR("(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)")},
 #endif
 	{"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"MacShowWindow", (PyCFunction)WinObj_MacShowWindow, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
-	 "(Boolean showFlag) -> None"},
+	 PyDoc_STR("(Boolean showFlag) -> None")},
 	{"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 
 #if !TARGET_API_MAC_OS8
 	{"ShowSheetWindow", (PyCFunction)WinObj_ShowSheetWindow, 1,
-	 "(WindowPtr inParentWindow) -> None"},
+	 PyDoc_STR("(WindowPtr inParentWindow) -> None")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"HideSheetWindow", (PyCFunction)WinObj_HideSheetWindow, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"GetSheetWindowParent", (PyCFunction)WinObj_GetSheetWindowParent, 1,
-	 "() -> (WindowPtr outParentWindow)"},
+	 PyDoc_STR("() -> (WindowPtr outParentWindow)")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"GetWindowPropertyAttributes", (PyCFunction)WinObj_GetWindowPropertyAttributes, 1,
-	 "(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
+	 PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"ChangeWindowPropertyAttributes", (PyCFunction)WinObj_ChangeWindowPropertyAttributes, 1,
-	 "(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"},
+	 PyDoc_STR("(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")},
 #endif
 	{"TrackBox", (PyCFunction)WinObj_TrackBox, 1,
-	 "(Point thePt, WindowPartCode partCode) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point thePt, WindowPartCode partCode) -> (Boolean _rv)")},
 	{"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1,
-	 "(Point thePt) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point thePt) -> (Boolean _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"GetAuxWin", (PyCFunction)WinObj_GetAuxWin, 1,
-	 "() -> (Boolean _rv, AuxWinHandle awHndl)"},
+	 PyDoc_STR("() -> (Boolean _rv, AuxWinHandle awHndl)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"GetWindowGoAwayFlag", (PyCFunction)WinObj_GetWindowGoAwayFlag, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"GetWindowSpareFlag", (PyCFunction)WinObj_GetWindowSpareFlag, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 	{"GetWindowPort", (PyCFunction)WinObj_GetWindowPort, 1,
-	 "() -> (CGrafPtr _rv)"},
+	 PyDoc_STR("() -> (CGrafPtr _rv)")},
 	{"GetWindowKind", (PyCFunction)WinObj_GetWindowKind, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 
 #if !TARGET_API_MAC_OS8
 	{"IsWindowUpdatePending", (PyCFunction)WinObj_IsWindowUpdatePending, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 	{"MacGetNextWindow", (PyCFunction)WinObj_MacGetNextWindow, 1,
-	 "() -> (WindowPtr _rv)"},
+	 PyDoc_STR("() -> (WindowPtr _rv)")},
 	{"GetWindowStandardState", (PyCFunction)WinObj_GetWindowStandardState, 1,
-	 "() -> (Rect rect)"},
+	 PyDoc_STR("() -> (Rect rect)")},
 	{"GetWindowUserState", (PyCFunction)WinObj_GetWindowUserState, 1,
-	 "() -> (Rect rect)"},
+	 PyDoc_STR("() -> (Rect rect)")},
 	{"SetWindowKind", (PyCFunction)WinObj_SetWindowKind, 1,
-	 "(short kind) -> None"},
+	 PyDoc_STR("(short kind) -> None")},
 	{"SetWindowStandardState", (PyCFunction)WinObj_SetWindowStandardState, 1,
-	 "(Rect rect) -> None"},
+	 PyDoc_STR("(Rect rect) -> None")},
 	{"SetWindowUserState", (PyCFunction)WinObj_SetWindowUserState, 1,
-	 "(Rect rect) -> None"},
+	 PyDoc_STR("(Rect rect) -> None")},
 	{"SetPortWindowPort", (PyCFunction)WinObj_SetPortWindowPort, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetWindowPortBounds", (PyCFunction)WinObj_GetWindowPortBounds, 1,
-	 "() -> (Rect bounds)"},
+	 PyDoc_STR("() -> (Rect bounds)")},
 	{"IsWindowVisible", (PyCFunction)WinObj_IsWindowVisible, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"GetWindowZoomFlag", (PyCFunction)WinObj_GetWindowZoomFlag, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 #endif
 	{"GetWindowStructureRgn", (PyCFunction)WinObj_GetWindowStructureRgn, 1,
-	 "(RgnHandle r) -> None"},
+	 PyDoc_STR("(RgnHandle r) -> None")},
 	{"GetWindowContentRgn", (PyCFunction)WinObj_GetWindowContentRgn, 1,
-	 "(RgnHandle r) -> None"},
+	 PyDoc_STR("(RgnHandle r) -> None")},
 	{"GetWindowUpdateRgn", (PyCFunction)WinObj_GetWindowUpdateRgn, 1,
-	 "(RgnHandle r) -> None"},
+	 PyDoc_STR("(RgnHandle r) -> None")},
 
 #if !TARGET_API_MAC_CARBON
 	{"GetWindowTitleWidth", (PyCFunction)WinObj_GetWindowTitleWidth, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 #endif
 	{"GetNextWindow", (PyCFunction)WinObj_GetNextWindow, 1,
-	 "() -> (WindowPtr _rv)"},
+	 PyDoc_STR("() -> (WindowPtr _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"CloseWindow", (PyCFunction)WinObj_CloseWindow, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 	{"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1,
-	 "(short hGlobal, short vGlobal, Boolean front) -> None"},
+	 PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")},
 	{"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -3658,118 +3658,118 @@ static PyObject *Win_FindWindow(PyObject *_self, PyObject *_args)
 
 static PyMethodDef Win_methods[] = {
 	{"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1,
-	 "(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
+	 PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
 	{"NewWindow", (PyCFunction)Win_NewWindow, 1,
-	 "(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
+	 PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
 	{"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1,
-	 "(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
+	 PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
 	{"NewCWindow", (PyCFunction)Win_NewCWindow, 1,
-	 "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
+	 PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
 	{"CreateNewWindow", (PyCFunction)Win_CreateNewWindow, 1,
-	 "(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)"},
+	 PyDoc_STR("(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)")},
 	{"CreateWindowFromResource", (PyCFunction)Win_CreateWindowFromResource, 1,
-	 "(SInt16 resID) -> (WindowPtr outWindow)"},
+	 PyDoc_STR("(SInt16 resID) -> (WindowPtr outWindow)")},
 	{"ShowFloatingWindows", (PyCFunction)Win_ShowFloatingWindows, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"HideFloatingWindows", (PyCFunction)Win_HideFloatingWindows, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"AreFloatingWindowsVisible", (PyCFunction)Win_AreFloatingWindowsVisible, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SetDeskCPat", (PyCFunction)Win_SetDeskCPat, 1,
-	 "(PixPatHandle deskPixPat) -> None"},
+	 PyDoc_STR("(PixPatHandle deskPixPat) -> None")},
 #endif
 	{"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
-	 "() -> (Boolean _rv, EventRecord theEvent)"},
+	 PyDoc_STR("() -> (Boolean _rv, EventRecord theEvent)")},
 	{"MacFindWindow", (PyCFunction)Win_MacFindWindow, 1,
-	 "(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)"},
+	 PyDoc_STR("(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)")},
 	{"FrontWindow", (PyCFunction)Win_FrontWindow, 1,
-	 "() -> (WindowPtr _rv)"},
+	 PyDoc_STR("() -> (WindowPtr _rv)")},
 	{"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
-	 "() -> (WindowPtr _rv)"},
+	 PyDoc_STR("() -> (WindowPtr _rv)")},
 
 #if !TARGET_API_MAC_OS8
 	{"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1,
-	 "(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
+	 PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1,
-	 "(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)"},
+	 PyDoc_STR("(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"CreateStandardWindowMenu", (PyCFunction)Win_CreateStandardWindowMenu, 1,
-	 "(OptionBits inOptions) -> (MenuHandle outMenu)"},
+	 PyDoc_STR("(OptionBits inOptions) -> (MenuHandle outMenu)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"InitWindows", (PyCFunction)Win_InitWindows, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"GetWMgrPort", (PyCFunction)Win_GetWMgrPort, 1,
-	 "() -> (GrafPtr wPort)"},
+	 PyDoc_STR("() -> (GrafPtr wPort)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"GetCWMgrPort", (PyCFunction)Win_GetCWMgrPort, 1,
-	 "() -> (CGrafPtr wMgrCPort)"},
+	 PyDoc_STR("() -> (CGrafPtr wMgrCPort)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"InitFloatingWindows", (PyCFunction)Win_InitFloatingWindows, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"InvalRect", (PyCFunction)Win_InvalRect, 1,
-	 "(Rect badRect) -> None"},
+	 PyDoc_STR("(Rect badRect) -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"InvalRgn", (PyCFunction)Win_InvalRgn, 1,
-	 "(RgnHandle badRgn) -> None"},
+	 PyDoc_STR("(RgnHandle badRgn) -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"ValidRect", (PyCFunction)Win_ValidRect, 1,
-	 "(Rect goodRect) -> None"},
+	 PyDoc_STR("(Rect goodRect) -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"ValidRgn", (PyCFunction)Win_ValidRgn, 1,
-	 "(RgnHandle goodRgn) -> None"},
+	 PyDoc_STR("(RgnHandle goodRgn) -> None")},
 #endif
 	{"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1,
-	 "(Boolean collapse) -> None"},
+	 PyDoc_STR("(Boolean collapse) -> None")},
 
 #if !TARGET_API_MAC_OS8
 	{"GetAvailableWindowPositioningBounds", (PyCFunction)Win_GetAvailableWindowPositioningBounds, 1,
-	 "(GDHandle inDevice) -> (Rect availableRect)"},
+	 PyDoc_STR("(GDHandle inDevice) -> (Rect availableRect)")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"DisableScreenUpdates", (PyCFunction)Win_DisableScreenUpdates, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 
 #if !TARGET_API_MAC_OS8
 	{"EnableScreenUpdates", (PyCFunction)Win_EnableScreenUpdates, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 #endif
 	{"PinRect", (PyCFunction)Win_PinRect, 1,
-	 "(Rect theRect, Point thePt) -> (long _rv)"},
+	 PyDoc_STR("(Rect theRect, Point thePt) -> (long _rv)")},
 	{"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"GetWindowFromPort", (PyCFunction)Win_GetWindowFromPort, 1,
-	 "(CGrafPtr port) -> (WindowPtr _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (WindowPtr _rv)")},
 	{"WhichWindow", (PyCFunction)Win_WhichWindow, 1,
-	 "Resolve an integer WindowPtr address to a Window object"},
+	 PyDoc_STR("Resolve an integer WindowPtr address to a Window object")},
 	{"FindWindow", (PyCFunction)Win_FindWindow, 1,
-	 "(Point thePoint) -> (short _rv, WindowPtr theWindow)"},
+	 PyDoc_STR("(Point thePoint) -> (short _rv, WindowPtr theWindow)")},
 	{NULL, NULL, 0}
 };