PY6/Revert "Remove old support for py2k/non-unicode/windows-ce/vista (mhammond#1874)"

This reverts commit c08c3d9

Conflicts resolved:
	win32/src/PyDEVMODE.cpp
	win32/src/PyWinTypesmodule.cpp
	win32/src/win32apimodule.cpp

Author: kxrob

Pythonwin/win32uimodule.cpp

@@ -173,6 +173,10 @@ ui_type::ui_type(const char *name, ui_type *pBase, Py_ssize_t typeSize,
     tp_methods = methodList;
     //#define funky_offsetof_weakreflist ((size_t) &((PyObject *)(ui_base_class *)0)->weakreflist)
 
+#if (PY_VERSION_HEX < 0x03000000)
+    tp_flags |= Py_TPFLAGS_HAVE_WEAKREFS;  // flag doesn't exist in py3k
+#endif
+
     tp_weaklistoffset -= pyobjOffset;
     // cast away const, as Python doesnt use it.
     tp_name = (char *)name;
@@ -346,7 +350,12 @@ int ui_base_class::setattro(PyObject *obname, PyObject *v)
 CString ui_base_class::repr()
 {
     CString csRet;
+#if (PY_VERSION_HEX < 0x03000000)
+    USES_CONVERSION;
+    csRet.Format(_T("object '%s'"), A2T((LPSTR)ob_type->tp_name));
+#else
     csRet.Format(_T("object '%S'"), ob_type->tp_name);
+#endif
     return csRet;
 }
 void ui_base_class::cleanup()
@@ -706,6 +715,10 @@ PyObject *Python_do_callback(PyObject *themeth, PyObject *thearglst)
 }
 
 // Copied from PyRecord.cpp, should move into pywintypes.h
+#if (PY_VERSION_HEX < 0x03000000)
+#define PyWinCoreString_ConcatAndDel PyBytes_ConcatAndDel
+#define PyWinCoreString_Concat PyBytes_Concat
+#else
 // Unicode versions of '_Concat' etc have different sigs.  Make them the
 // same here...
 void PyWinCoreString_Concat(register PyObject **pv, register PyObject *w)
@@ -720,6 +733,14 @@ void PyWinCoreString_Concat(register PyObject **pv, register PyObject *w)
     *pv = tmp;
 }
 
+void PyWinCoreString_ConcatAndDel(register PyObject **pv, register PyObject *w)
+{
+    PyWinCoreString_Concat(pv, w);
+    Py_XDECREF(w);
+}
+
+#endif
+
 int Python_do_int_callback(PyObject *themeth, PyObject *thearglst)
 {
     int retVal = INT_MAX;  // an identifiable, but unlikely genuine value
@@ -1459,7 +1480,7 @@ static PyObject *ui_get_resource(PyObject *self, PyObject *args)
     return ret;
 }
 
-// @pymethod string|win32ui|LoadString|Loads a string from a resource file.
+// @pymethod <o PyUnicode>|win32ui|LoadString|Loads a string from a resource file.
 static PyObject *ui_load_string(PyObject *self, PyObject *args)
 {
     UINT stringId;
@@ -1832,6 +1853,29 @@ static PyObject *ui_translate_vk(PyObject *, PyObject *args)
     return PyBytes_FromStringAndSize(result, nc);
 }
 
+/** Seems to have problems on 9x for some people (not me, though?)
+// @pymethod <o PyUnicode>/None|win32ui|TranslateVirtualKeyW|
+static PyObject *ui_translate_vkW(PyObject *, PyObject *args)
+{
+    int vk;
+    // @pyparm int|vk||The key to translate
+    if (!PyArg_ParseTuple(args, "i", &vk))
+        return NULL;
+    static HKL layout=GetKeyboardLayout(0);
+    static BYTE State[256];
+    if (GetKeyboardState(State)==FALSE)
+        RETURN_ERR("Can't get keyboard state");
+    WCHAR result[2];
+    UINT sc=MapVirtualKeyEx(vk,0,layout);
+    int nc = ToUnicodeEx(vk,sc,State,result,2, 0,layout);
+    if (nc==-1) { // a dead char.
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    return PyWinObject_FromWCHAR(result, nc);
+}
+**/
+
 extern PyObject *ui_get_dialog_resource(PyObject *, PyObject *args);
 extern PyObject *ui_create_app(PyObject *, PyObject *args);
 extern PyObject *ui_get_app(PyObject *, PyObject *args);
@@ -2043,7 +2087,13 @@ int AddConstants(PyObject *module)
     int debug = 0;
 #endif
     ADD_CONSTANT(debug);  // @const win32ui|debug|1 if we are current using a _DEBUG build of win32ui, else 0.
-    if (PyModule_AddIntConstant(module, "UNICODE", 1) == -1)
+    if (PyModule_AddIntConstant(module, "UNICODE",
+#ifdef UNICODE
+                                1
+#else
+                                0
+#endif
+                                ) == -1)
         return -1;
     ADD_CONSTANT(AFX_IDW_PANE_FIRST);   // @const win32ui|AFX_IDW_PANE_FIRST|Id of the first splitter pane
     ADD_CONSTANT(AFX_IDW_PANE_LAST);    // @const win32ui|AFX_IDW_PANE_LAST|Id of the last splitter pane
@@ -2396,7 +2446,11 @@ PYWIN_MODULE_INIT_FUNC(win32ui)
         PYWIN_MODULE_INIT_RETURN_ERROR;
     }
     if (existing_module)
+#if (PY_VERSION_HEX < 0x03000000)
+        return;
+#else
         return existing_module;
+#endif
 
     PYWIN_MODULE_INIT_PREPARE(win32ui, ui_functions, "A module, encapsulating the Microsoft Foundation Classes.");
 
@@ -2555,6 +2609,12 @@ extern "C" PYW_EXPORT BOOL Win32uiApplicationInit(Win32uiHostGlue *pGlue, const
     // a risk that when Python does "import win32ui", it
     // will locate a different one, causing obvious grief!
     PyObject *argv = PySys_GetObject("argv");
+#if (PY_VERSION_HEX < 0x03000000)
+    initwin32ui();
+    // Set sys.argv if not already done!
+    if (argv == NULL && __targv != NULL && __argc > 0)
+        PySys_SetArgv(__argc - 1, __targv + 1);
+#else
     PyInit_win32ui();
     // Decide if we render sys.argv from command line.
     // PY3.6- Py_Initialize sets sys.argv=NULL .
@@ -2573,6 +2633,7 @@ extern "C" PYW_EXPORT BOOL Win32uiApplicationInit(Win32uiHostGlue *pGlue, const
             LocalFree(myargv);
         }
     }
+#endif
     // If the versions of the .h file are not in synch, then we are in trouble!
     if (pGlue->versionNo != WIN32UIHOSTGLUE_VERSION) {
         MessageBox(0,

Pythonwin/win32util.cpp

@@ -1136,12 +1136,28 @@ CString GetReprText(PyObject *objectUse)
 {
     PyObject *s;
     CString csRet;
+#ifdef UNICODE
+// PyObject_Unicode disappeared in Py3k, where PyObject_Str returns unicode object
+#if (PY_VERSION_HEX < 0x03000000)
+    s = PyObject_Unicode(objectUse);
+#else
     s = PyObject_Str(objectUse);
+#endif
     if (s) {
         csRet = CString(PyUnicode_AsUnicode(s));
         Py_DECREF(s);
         return csRet;
     }
+#else
+    // Assumes that this will always be compiled with UNICODE defined for py3k
+    s = PyObject_Str(objectUse);
+    if (s) {
+        csRet = CString(PyBytes_AsString(s));
+        Py_DECREF(s);
+        return csRet;
+    }
+#endif
+
     PyErr_Clear();
     s = PyObject_Repr(objectUse);
     if (s == NULL) {
@@ -1150,7 +1166,7 @@ CString GetReprText(PyObject *objectUse)
         return csRet;
     }
 
-    // repr() should always return a unicode string, but for hysterical raisens we check if it is bytes.
+    // repr() should return either a string or unicode object, but not sure if this is enforced.
     if (PyUnicode_Check(s))
         csRet = CString(PyUnicode_AS_UNICODE(s));
     else if (PyBytes_Check(s))
@@ -1160,4 +1176,16 @@ CString GetReprText(PyObject *objectUse)
                      s->ob_type->tp_name);
     Py_DECREF(s);
     return csRet;
+
+    /* This was apparently trying to remove enclosing quotes, parens, and brackets but will only succeed for quotes
+        Forget about it for now
+    Py_ssize_t len=strlen(szRepr);
+    if (len > 2 && strchr("\"'[(", *szRepr)) {
+        if (szRepr[len-1]==*szRepr) {
+            ++szRepr;
+            len-=2;	// drop first and last chars.
+        }
+    }
+    csRet= CString( szRepr, PyWin_SAFE_DOWNCAST(len, Py_ssize_t, int) );
+    */
 }

SWIG/swig_lib/python/pywintypes.i

@@ -98,7 +98,7 @@ typedef unsigned long ULONG;
       }
 }
 
-// String support
+// String and UniCode support
 %typemap(python,in) char *inNullString {
 	if ($source==Py_None) {
 		$target = NULL;
@@ -588,7 +588,13 @@ typedef float HWND;
 #ifndef SWIG_PYTHONCOM
 /* This code only valid if non COM SWIG builds */
 #ifndef PYCOM_EXPORT
-	 PyDict_SetItemString(d,"UNICODE", PyLong_FromLong(1));
+	 PyDict_SetItemString(d,"UNICODE", PyLong_FromLong(
+#ifdef UNICODE
+	1
+#else
+	0
+#endif
+	));
 #endif
   PyWinGlobals_Ensure();
   PyDict_SetItemString(d, "error", PyWinExc_ApiError);

com/win32com/src/MiscTypes.cpp

@@ -103,6 +103,9 @@ PyComEnumTypeObject::PyComEnumTypeObject(const char *name, PyComTypeObject *pBas
     tp_iter = iter;
     tp_iternext = iternext;
     // Py3k does not have this flag, and depends just on presence of tp_iter
+#if (PY_VERSION_HEX < 0x03000000)
+    tp_flags |= Py_TPFLAGS_HAVE_ITER;
+#endif
 }
 
 // PyIEnum iter methods - generic for any "standard" COM IEnum interface, but
@@ -150,6 +153,9 @@ PyComEnumProviderTypeObject::PyComEnumProviderTypeObject(const char *name, PyCom
 {
     tp_iter = iter;
     // tp_iternext remains NULL
+#if (PY_VERSION_HEX < 0x03000000)
+    tp_flags |= Py_TPFLAGS_HAVE_ITER;
+#endif
 }
 
 // PyIEnumProvider iter methods - generic for COM object that can provide an IEnum*

com/win32com/src/PyComHelpers.cpp

@@ -53,7 +53,11 @@ PyObject *get_Decimal_class(void)
 
 PyObject *PyObject_FromCurrency(CURRENCY &cy)
 {
+#if (PY_VERSION_HEX < 0x03000000)
+    static char *divname = "__div__";
+#else
     static char *divname = "__truediv__";
+#endif
     if (Decimal_class == NULL) {
         Decimal_class = get_Decimal_class();
         if (Decimal_class == NULL)

com/win32com/src/PyRecord.cpp

@@ -348,6 +348,12 @@ static void _FreeFieldNames(BSTR *strings, ULONG num_names)
     delete[] strings;
 }
 
+#if (PY_VERSION_HEX < 0x03000000)
+#define PyWinCoreString_ConcatAndDel PyBytes_ConcatAndDel
+#define PyWinCoreString_Concat PyBytes_Concat
+#else
+// Unicode versions of '_Concat' etc have different sigs.  Make them the
+// same here...
 void PyWinCoreString_Concat(register PyObject **pv, register PyObject *w)
 {
     if (!w) {  // hrm - string version doesn't do this, but I saw PyObject_Repr() return NULL...
@@ -366,6 +372,8 @@ void PyWinCoreString_ConcatAndDel(register PyObject **pv, register PyObject *w)
     Py_XDECREF(w);
 }
 
+#endif
+
 PyObject *PyRecord::tp_repr(PyObject *self)
 {
     ULONG i;

com/win32com/src/dllmain.cpp

@@ -305,7 +305,11 @@ HRESULT DoRegisterUnregister(LPCSTR fileName, int argc, char **argv)
     PyCom_DLLAddRef();
     {  // A scope for _celp
         CEnterLeavePython _celp;
+#if (PY_VERSION_HEX < 0x03000000)
+        PySys_SetArgv(argc, argv);
+#else
         PySys_SetArgv(argc, __wargv);
+#endif;
 
         if (PyRun_SimpleFile(fp, (char *)fileName) != 0) {
             // Convert the Python error to a HRESULT.

com/win32com/src/extensions/PyIPropertyStorage.cpp

@@ -382,6 +382,13 @@ BOOL PyObject_AsPROPVARIANT(PyObject *ob, PROPVARIANT *pVar)
                 pVar->vt = VT_UI4;
             }
         }
+#if (PY_VERSION_HEX < 0x03000000)
+        // Not needed in Py3k, as PyLong_Check is defined to PyLong_Check
+    }
+    else if (PyLong_Check(ob)) {
+        pVar->lVal = PyLong_AsLong(ob);
+        pVar->vt = VT_I4;
+#endif
     }
     else if (PyFloat_Check(ob)) {
         pVar->dblVal = PyFloat_AsDouble(ob);

com/win32com/src/oleargs.cpp

@@ -19,7 +19,11 @@ static PyObject *PyVariant_Type;
 #define BYREF_ARRAY_USE_EXISTING_ARRAY
 
 // Need to put this in pywintypes.h with rest of compatibility macros
+#if (PY_VERSION_HEX < 0x03000000)
+#define PYWIN_BUFFER_CHECK PyBuffer_Check
+#else
 #define PYWIN_BUFFER_CHECK(obj) (PyBytes_Check(obj) || PyByteArray_Check(obj) || PyMemoryView_Check(obj))
+#endif
 
 // A little helper just for this file
 static PyObject *OleSetTypeError(TCHAR *msg)
@@ -120,6 +124,9 @@ BOOL PyCom_VariantFromPyObject(PyObject *obj, VARIANT *var)
     V_VT(var) = VT_EMPTY;
     if (
 // In py3k we don't convert PyBytes_Check objects (ie, bytes) to BSTR...
+#if (PY_VERSION_HEX < 0x03000000)
+        PyBytes_Check(obj) ||
+#endif
         PyUnicode_Check(obj)) {
         if (!PyWinObject_AsBstr(obj, &V_BSTR(var))) {
             PyErr_SetString(PyExc_MemoryError, "Making BSTR for variant");
@@ -216,6 +223,15 @@ BOOL PyCom_VariantFromPyObject(PyObject *obj, VARIANT *var)
     else if (obj == Py_None) {
         V_VT(var) = VT_NULL;
     }
+#if (PY_VERSION_HEX < 0x03000000)
+    // This is redundant in 3.x, since PyLong_Check is #defined to PyLong_Check
+    else if (PyLong_Check(obj)) {
+        V_VT(var) = VT_I4;
+        V_I4(var) = PyLong_AsLong(obj);
+        if (V_I4(var) == -1 && PyErr_Occurred())
+            return FALSE;
+    }
+#endif
     else if (PyObject_HasAttrString(obj, "_oleobj_")) {
         if (PyCom_InterfaceFromPyInstanceOrObject(obj, IID_IDispatch, (void **)&V_DISPATCH(var), FALSE))
             V_VT(var) = VT_DISPATCH;

com/win32com/src/univgw.cpp

@@ -349,6 +349,7 @@ static void free_vtbl(gw_vtbl *vtbl)
     VirtualFree(vtbl, 0, MEM_RELEASE);
 }
 
+#if PY_VERSION_HEX > 0x03010000
 // Use the new capsule API
 const char *capsule_name = "win32com universal gateway";
 
@@ -358,6 +359,20 @@ static PyObject *PyVTable_Create(void *vtbl) { return PyCapsule_New(vtbl, capsul
 static gw_vtbl *PyVTable_Get(PyObject *ob) { return (gw_vtbl *)PyCapsule_GetPointer(ob, capsule_name); }
 
 static bool PyVTable_Check(PyObject *ob) { return PyCapsule_IsValid(ob, capsule_name) != 0; }
+#else
+// Use the old CObject API.
+static void __cdecl do_free_vtbl(void *cobject)
+{
+    gw_vtbl *vtbl = (gw_vtbl *)cobject;
+    free_vtbl(vtbl);
+}
+
+static PyObject *PyVTable_Create(void *vtbl) { return PyCObject_FromVoidPtr(vtbl, do_free_vtbl); }
+
+static gw_vtbl *PyVTable_Get(PyObject *ob) { return (gw_vtbl *)PyCObject_AsVoidPtr(ob); }
+
+static bool PyVTable_Check(PyObject *ob) { return PyCObject_Check(ob) != 0; }
+#endif
 
 static PyObject *univgw_CreateVTable(PyObject *self, PyObject *args)
 {
@@ -716,9 +731,13 @@ BOOL initunivgw(PyObject *parentDict)
 
     PyObject *module;
 
+#if (PY_VERSION_HEX < 0x03000000)
+    module = Py_InitModule("pythoncom.__univgw", univgw_functions);
+#else
     static PyModuleDef univgw_def = {PyModuleDef_HEAD_INIT, "pythoncom.__univgw", "Univeral gateway", -1,
                                      univgw_functions};
     module = PyModule_Create(&univgw_def);
+#endif
     if (!module) /* Eeek - some serious error! */
         return FALSE;