Changeset 6648 for trunk/src/oleaut32

Timestamp:

Sep 5, 2001, 3:19:02 PM (24 years ago)

Author:

bird

Message:

Added $Id:$ keyword.

Location:

trunk/src/oleaut32

Files:

• connpt.c (modified) (30 diffs)
• dispatch.c (modified) (4 diffs)
• initterm.cpp (modified) (5 diffs)
• ole2disp.c (modified) (21 diffs)
• oleaut.c (modified) (7 diffs)
• olefont.c (modified) (58 diffs)
• olepicture.c (modified) (51 diffs)
• parsedt.c (modified) (19 diffs)
• safearray.c (modified) (68 diffs)
• typelib.c (modified) (171 diffs)
• variant.c (modified) (68 diffs)

trunk/src/oleaut32/connpt.c

@@ +1 @@
+/* $Id: connpt.c,v 1.2 2001-09-05 13:18:59 bird Exp $ */
 /*
  * Implementation of a generic ConnectionPoint object.
@@ -72 +73 @@
   CONNECTDATA *pCD;
   DWORD nConns;
-  
+
   /* Next connection to enumerate from */
   DWORD nCur;
@@ -79 +80 @@
 
 static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
-                                                          DWORD nSinks,
-                                                          CONNECTDATA *pCD);
+                              DWORD nSinks,
+                              CONNECTDATA *pCD);
 
 
@@ -87 +88 @@
  */
 static ConnectionPointImpl *ConnectionPointImpl_Construct(IUnknown *pUnk,
-                                                          REFIID riid)
+                              REFIID riid)
 {
   ConnectionPointImpl *Obj;
@@ -97 +98 @@
   Obj->iid =  *riid;
   Obj->maxSinks = MAXSINKS;
-  Obj->sinks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 
-                         sizeof(IUnknown*) * MAXSINKS);
+  Obj->sinks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+             sizeof(IUnknown*) * MAXSINKS);
   Obj->nSinks = 0;
   return Obj;
@@ -139 +140 @@
   if ( (This==0) || (ppvObject==0) )
     return E_INVALIDARG;
-  
+
   /*
    * Initialize the return parameter.
    */
   *ppvObject = 0;
-  
+
   /*
    * Compare the riid with the interface IDs implemented by this object.
    */
-  if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0) 
+  if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
   {
     *ppvObject = (IConnectionPoint*)This;
   }
-  else if (memcmp(&IID_IConnectionPoint, riid, sizeof(IID_IConnectionPoint)) == 0) 
+  else if (memcmp(&IID_IConnectionPoint, riid, sizeof(IID_IConnectionPoint)) == 0)
   {
     *ppvObject = (IConnectionPoint*)This;
   }
-  
+
   /*
    * Check that we obtained an interface.
@@ -165 +166 @@
     return E_NOINTERFACE;
   }
-  
+
   /*
    * Query Interface always increases the reference count by one when it is
@@ -189 +190 @@
   return This->ref;
 }
-        
+
 /************************************************************************
  * ConnectionPointImpl_Release (IUnknown)
@@ -195 +196 @@
  * See Windows documentation for more details on IUnknown methods.
  */
-static ULONG WINAPI ConnectionPointImpl_Release( 
+static ULONG WINAPI ConnectionPointImpl_Release(
       IConnectionPoint* iface)
 {
@@ -215 +216 @@
     return 0;
   }
-  
+
   return This->ref;
 }
@@ -224 +225 @@
  */
 static HRESULT WINAPI ConnectionPointImpl_GetConnectionInterface(
-                                               IConnectionPoint *iface,
-                                               IID              *piid)
+                           IConnectionPoint *iface,
+                           IID              *piid)
 {
   ICOM_THIS(ConnectionPointImpl, iface);
@@ -238 +239 @@
  */
 static HRESULT WINAPI ConnectionPointImpl_GetConnectionPointContainer(
-                                      IConnectionPoint           *iface,
-                                      IConnectionPointContainer  **ppCPC)
+                      IConnectionPoint           *iface,
+                      IConnectionPointContainer  **ppCPC)
 {
   ICOM_THIS(ConnectionPointImpl, iface);
@@ -245 +246 @@
 
   return IUnknown_QueryInterface(This->Obj,
-                                 &IID_IConnectionPointContainer,
-                                 (LPVOID)ppCPC);
+                 &IID_IConnectionPointContainer,
+                 (LPVOID)ppCPC);
 }
 
@@ -254 +255 @@
  */
 static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface,
-                                                 IUnknown *lpUnk,
-                                                 DWORD *pdwCookie)
+                         IUnknown *lpUnk,
+                         DWORD *pdwCookie)
 {
   DWORD i;
@@ -273 +274 @@
     This->maxSinks += MAXSINKS;
     This->sinks = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->sinks,
-                              This->maxSinks * sizeof(IUnknown *));
+                  This->maxSinks * sizeof(IUnknown *));
   }
   This->sinks[i] = lpSink;
@@ -287 +288 @@
  */
 static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface,
-                                                   DWORD dwCookie)
+                           DWORD dwCookie)
 {
   ICOM_THIS(ConnectionPointImpl, iface);
@@ -307 +308 @@
  */
 static HRESULT WINAPI ConnectionPointImpl_EnumConnections(
-                                                    IConnectionPoint *iface,
-                                                    LPENUMCONNECTIONS *ppEnum)
-{ 
+                            IConnectionPoint *iface,
+                            LPENUMCONNECTIONS *ppEnum)
+{
   ICOM_THIS(ConnectionPointImpl, iface);
   CONNECTDATA *pCD;
@@ -317 +318 @@
 
   TRACE("(%p)->(%p)\n", This, ppEnum);
-  
+
   *ppEnum = NULL;
 
@@ -339 +340 @@
   EnumObj = EnumConnectionsImpl_Construct((IUnknown*)This, This->nSinks, pCD);
   hr = IEnumConnections_QueryInterface((IEnumConnections*)EnumObj,
-                                  &IID_IEnumConnections, (LPVOID)ppEnum);
+                  &IID_IEnumConnections, (LPVOID)ppEnum);
   IEnumConnections_Release((IEnumConnections*)EnumObj);
 
@@ -367 +368 @@
  */
 static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
-                                                          DWORD nSinks,
-                                                          CONNECTDATA *pCD)
+                              DWORD nSinks,
+                              CONNECTDATA *pCD)
 {
   EnumConnectionsImpl *Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
@@ -420 +421 @@
   if ( (This==0) || (ppvObject==0) )
     return E_INVALIDARG;
-  
+
   /*
    * Initialize the return parameter.
    */
   *ppvObject = 0;
-  
+
   /*
    * Compare the riid with the interface IDs implemented by this object.
    */
-  if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0) 
+  if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
   {
     *ppvObject = (IEnumConnections*)This;
   }
-  else if (memcmp(&IID_IEnumConnections, riid, sizeof(IID_IEnumConnections)) == 0) 
+  else if (memcmp(&IID_IEnumConnections, riid, sizeof(IID_IEnumConnections)) == 0)
   {
     *ppvObject = (IEnumConnections*)This;
   }
-  
+
   /*
    * Check that we obtained an interface.
@@ -446 +447 @@
     return E_NOINTERFACE;
   }
-  
+
   /*
    * Query Interface always increases the reference count by one when it is
@@ -470 +471 @@
   return This->ref;
 }
-        
+
 /************************************************************************
  * EnumConnectionsImpl_Release (IUnknown)
@@ -497 +498 @@
     return 0;
   }
-  
+
   return This->ref;
 }
@@ -506 +507 @@
  */
 static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface,
-                                               ULONG cConn, LPCONNECTDATA pCD,
-                                               ULONG *pEnum)
+                           ULONG cConn, LPCONNECTDATA pCD,
+                           ULONG *pEnum)
 {
   ICOM_THIS(EnumConnectionsImpl, iface);
@@ -542 +543 @@
  */
 static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface,
-                                               ULONG cSkip)
+                           ULONG cSkip)
 {
   ICOM_THIS(EnumConnectionsImpl, iface);
@@ -576 +577 @@
  */
 static HRESULT WINAPI EnumConnectionsImpl_Clone(IEnumConnections* iface,
-                                                LPENUMCONNECTIONS *ppEnum)
+                        LPENUMCONNECTIONS *ppEnum)
 {
   ICOM_THIS(EnumConnectionsImpl, iface);
   EnumConnectionsImpl *newObj;
   TRACE("(%p)->(%p)\n", This, ppEnum);
-  
+
   newObj = EnumConnectionsImpl_Construct(This->pUnk, This->nConns, This->pCD);
   newObj->nCur = This->nCur;
@@ -588 +589 @@
   return S_OK;
 }
-  
+
 static ICOM_VTABLE(IEnumConnections) EnumConnectionsImpl_VTable =
 {
@@ -616 +617 @@
  */
 HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid,
-                              IConnectionPoint **pCP)
+                  IConnectionPoint **pCP)
 {
   ConnectionPointImpl *Obj;
@@ -624 +625 @@
   if(!Obj) return E_OUTOFMEMORY;
 
-  hr = IConnectionPoint_QueryInterface((IConnectionPoint *)Obj, 
-                                       &IID_IConnectionPoint, (LPVOID)pCP);
+  hr = IConnectionPoint_QueryInterface((IConnectionPoint *)Obj,
+                       &IID_IConnectionPoint, (LPVOID)pCP);
   IConnectionPoint_Release((IConnectionPoint *)Obj);
   return hr;

trunk/src/oleaut32/dispatch.c

@@ +1 @@
+/* $Id: dispatch.c,v 1.2 2001-09-05 13:19:00 bird Exp $ */
 /**
  * Dispatch API functions
@@ -37 +38 @@
  *
  * NOTES
- *              - Defer method invocation to ITypeInfo::Invoke()
+ *      - Defer method invocation to ITypeInfo::Invoke()
  *
  * RETURNS
  *
- *              S_OK on success.
+ *      S_OK on success.
  */
 HRESULT WINAPI
@@ -76 +77 @@
  *         DispGetIDsOfNames (OLEAUT32.29)
  *
- * Convert a set of names to dispids, based on information 
+ * Convert a set of names to dispids, based on information
  * contained in object's type library.
- * 
+ *
  * NOTES
- *              - Defers to ITypeInfo::GetIDsOfNames()
+ *      - Defers to ITypeInfo::GetIDsOfNames()
  *
  * RETURNS
  *
- *              S_OK on success.
+ *      S_OK on success.
  */
 HRESULT WINAPI
@@ -109 +110 @@
  *
  * NOTES
- *              Coercion is done using system (0) locale.
+ *      Coercion is done using system (0) locale.
  *
  * RETURNS
  *
- *              S_OK on success.
+ *      S_OK on success.
  */
 HRESULT WINAPI DispGetParam(DISPPARAMS* pdispparams, UINT position,

trunk/src/oleaut32/initterm.cpp

@@ +1 @@
+/* $Id: initterm.cpp,v 1.10 2001-09-05 13:19:00 bird Exp $ */
 /*
  * DLL entry point
@@ -59 +60 @@
    {
    case DLL_PROCESS_ATTACH:
-        return TRUE;
+    return TRUE;
 
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
-        return TRUE;
+    return TRUE;
 
    case DLL_PROCESS_DETACH:
-        ctordtorTerm();
-        ClosePrivateLogFiles();
-        return TRUE;
+    ctordtorTerm();
+    ClosePrivateLogFiles();
+    return TRUE;
    }
    return FALSE;
@@ -95 +96 @@
       case 0 :
       {
-         loadNr = globLoadNr++;
+     loadNr = globLoadNr++;
 
-         DosQueryModuleName(hModule, sizeof(oleaut32Path), oleaut32Path);
-         char *endofpath = strrchr(oleaut32Path, '\\');
-         *(endofpath+1) = 0;
+     DosQueryModuleName(hModule, sizeof(oleaut32Path), oleaut32Path);
+     char *endofpath = strrchr(oleaut32Path, '\\');
+     *(endofpath+1) = 0;
 
          ctordtorInit();
@@ -105 +106 @@
          CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
 
-         dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
-         if(dllHandle == 0) 
-                return 0UL;
+     dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
+         if(dllHandle == 0)
+        return 0UL;
 
 #ifdef DEFAULT_LOGGING_OFF
-         if(getenv("WIN32LOG_ENABLED")) {
+         if(getenv("WIN32LOG_ENABLED")) {
 #else
-         if(!getenv("NOWIN32LOG")) {
+         if(!getenv("NOWIN32LOG")) {
 #endif
-                OpenPrivateLogFiles();
-         }
+            OpenPrivateLogFiles();
+     }
          Hash_Initialise();
 
@@ -122 +123 @@
       case 1 :
          if(dllHandle) {
-                UnregisterLxDll(dllHandle);
+        UnregisterLxDll(dllHandle);
          }
          break;

trunk/src/oleaut32/ole2disp.c

@@ +1 @@
+/* $Id: ole2disp.c,v 1.2 2001-09-05 13:19:00 bird Exp $ */
 /*
- *      OLE2DISP library
+ *  OLE2DISP library
  *
- *      Copyright 1995  Martin von Loewis
+ *  Copyright 1995  Martin von Loewis
  */
 #ifdef __WIN32OS2__
@@ -31 +32 @@
 
 /******************************************************************************
- *              BSTR_AllocBytes [Internal]
+ *      BSTR_AllocBytes [Internal]
  */
 static BSTR16 BSTR_AllocBytes(int n)
@@ -56 +57 @@
 
 /******************************************************************************
- *              SysAllocString16        [OLE2DISP.2]
+ *      SysAllocString16    [OLE2DISP.2]
  */
 BSTR16 WINAPI SysAllocString16(LPCOLESTR16 in)
 {
-        BSTR16 out;
-    
-        if (!in) return 0;
-    
-        out = BSTR_AllocBytes(strlen(in)+1);
-        if(!out)return 0;
-        strcpy(BSTR_GetAddr(out),in);
-        return out;
-}
-#endif
-
-/******************************************************************************
- *              SysAllocString  [OLEAUT32.2]
+    BSTR16 out;
+
+    if (!in) return 0;
+
+    out = BSTR_AllocBytes(strlen(in)+1);
+    if(!out)return 0;
+    strcpy(BSTR_GetAddr(out),in);
+    return out;
+}
+#endif
+
+/******************************************************************************
+ *      SysAllocString  [OLEAUT32.2]
  */
 BSTR WINAPI SysAllocString(LPCOLESTR in)
 {
     if (!in) return 0;
-    
+
     /* Delegate this to the SysAllocStringLen32 method. */
     return SysAllocStringLen(in, lstrlenW(in));
@@ -84 +85 @@
 #ifndef __WIN32OS2__
 /******************************************************************************
- *              SysReAllocString16      [OLE2DISP.3]
+ *      SysReAllocString16  [OLE2DISP.3]
  */
 INT16 WINAPI SysReAllocString16(LPBSTR16 old,LPCOLESTR16 in)
 {
-        BSTR16 new=SysAllocString16(in);
-        BSTR_Free(*old);
-        *old=new;
-        return 1;
-}
-#endif
-
-/******************************************************************************
- *              SysReAllocString        [OLEAUT32.3]
+    BSTR16 new=SysAllocString16(in);
+    BSTR_Free(*old);
+    *old=new;
+    return 1;
+}
+#endif
+
+/******************************************************************************
+ *      SysReAllocString    [OLEAUT32.3]
  */
 INT WINAPI SysReAllocString(LPBSTR old,LPCOLESTR in)
@@ -103 +104 @@
      * Sanity check
      */
-    if (old==NULL) 
+    if (old==NULL)
       return 0;
 
@@ -109 +110 @@
      * Make sure we free the old string.
      */
-    if (*old!=NULL)      
+    if (*old!=NULL)
       SysFreeString(*old);
 
@@ -122 +123 @@
 #ifndef __WIN32OS2__
 /******************************************************************************
- *              SysAllocStringLen16     [OLE2DISP.4]
+ *      SysAllocStringLen16 [OLE2DISP.4]
  */
 BSTR16 WINAPI SysAllocStringLen16(const char *in, int len)
 {
-        BSTR16 out=BSTR_AllocBytes(len+1);
-
-        if (!out)
-                return 0;
+    BSTR16 out=BSTR_AllocBytes(len+1);
+
+    if (!out)
+        return 0;
 
     /*
@@ -137 +138 @@
      */
     if (in != 0)
-        strcpy(BSTR_GetAddr(out),in);
+    strcpy(BSTR_GetAddr(out),in);
     else
       memset(BSTR_GetAddr(out), 0, len+1);
 
-        return out;
+    return out;
 }
 #endif
@@ -152 +153 @@
  * he describes it as a "DWORD count of characters". By experimenting with
  * a windows application, this count seems to be a DWORD count of bytes in
- * the string. Meaning that the count is double the number of wide 
+ * the string. Meaning that the count is double the number of wide
  * characters in the string.
  */
@@ -214 +215 @@
 #ifndef __WIN32OS2__
 /******************************************************************************
- *              SysReAllocStringLen16   [OLE2DISP.5]
+ *      SysReAllocStringLen16   [OLE2DISP.5]
  */
 int WINAPI SysReAllocStringLen16(BSTR16 *old,const char *in,int len)
 {
-        BSTR16 new=SysAllocStringLen16(in,len);
-        BSTR_Free(*old);
-        *old=new;
-        return 1;
-}
-#endif
-
- 
+    BSTR16 new=SysAllocStringLen16(in,len);
+    BSTR_Free(*old);
+    *old=new;
+    return 1;
+}
+#endif
+
+
 /******************************************************************************
  *             SysReAllocStringLen   [OLEAUT32.5]
@@ -234 +235 @@
      * Sanity check
      */
-    if (old==NULL) 
+    if (old==NULL)
       return 0;
 
@@ -240 +241 @@
      * Make sure we free the old string.
      */
-    if (*old!=NULL)      
+    if (*old!=NULL)
       SysFreeString(*old);
 
@@ -253 +254 @@
 #ifndef __WIN32OS2__
 /******************************************************************************
- *              SysFreeString16 [OLE2DISP.6]
+ *      SysFreeString16 [OLE2DISP.6]
  */
 void WINAPI SysFreeString16(BSTR16 in)
 {
-        BSTR_Free(in);
-}
-#endif
-
-/******************************************************************************
- *              SysFreeString   [OLEAUT32.6]
+    BSTR_Free(in);
+}
+#endif
+
+/******************************************************************************
+ *      SysFreeString   [OLEAUT32.6]
  */
 void WINAPI SysFreeString(BSTR in)
 {
     DWORD* bufferPointer;
-    
+
     /* NULL is a valid parameter */
     if(!in) return;
@@ -288 +289 @@
 #ifndef __WIN32OS2__
 /******************************************************************************
- *              SysStringLen16  [OLE2DISP.7]
+ *      SysStringLen16  [OLE2DISP.7]
  */
 int WINAPI SysStringLen16(BSTR16 str)
 {
-        return strlen(BSTR_GetAddr(str));
+    return strlen(BSTR_GetAddr(str));
 }
 #endif
@@ -310 +311 @@
      if (!str) return 0;
     /*
-     * The length of the string (in bytes) is contained in a DWORD placed 
+     * The length of the string (in bytes) is contained in a DWORD placed
      * just before the BSTR pointer
      */
@@ -334 +335 @@
      if (!str) return 0;
     /*
-     * The length of the string (in bytes) is contained in a DWORD placed 
+     * The length of the string (in bytes) is contained in a DWORD placed
      * just before the BSTR pointer
      */
@@ -349 +350 @@
  */
 HRESULT WINAPI CreateDispTypeInfo16(
-        INTERFACEDATA *pidata,
-        LCID lcid,
-        ITypeInfo **pptinfo)
-{
-        FIXME("(%p,%ld,%p),stub\n",pidata,lcid,pptinfo);
-        return 0;
+    INTERFACEDATA *pidata,
+    LCID lcid,
+    ITypeInfo **pptinfo)
+{
+    FIXME("(%p,%ld,%p),stub\n",pidata,lcid,pptinfo);
+    return 0;
 }
 #endif
@@ -362 +363 @@
  */
 HRESULT WINAPI CreateDispTypeInfo(
-        INTERFACEDATA *pidata,
-        LCID lcid,
-        ITypeInfo **pptinfo)
-{
-        FIXME("(%p,%ld,%p),stub\n",pidata,lcid,pptinfo);
-        return 0;
+    INTERFACEDATA *pidata,
+    LCID lcid,
+    ITypeInfo **pptinfo)
+{
+    FIXME("(%p,%ld,%p),stub\n",pidata,lcid,pptinfo);
+    return 0;
 }
 
@@ -377 +378 @@
         IUnknown* punkOuter,
         void* pvThis,
-        ITypeInfo* ptinfo,
-        IUnknown** ppunkStdDisp)
-{
-        FIXME("(%p,%p,%p,%p),stub\n",punkOuter, pvThis, ptinfo,
+    ITypeInfo* ptinfo,
+    IUnknown** ppunkStdDisp)
+{
+    FIXME("(%p,%p,%p,%p),stub\n",punkOuter, pvThis, ptinfo,
                ppunkStdDisp);
-        return 0;
+    return 0;
 }
 #endif
@@ -392 +393 @@
         IUnknown* punkOuter,
         void* pvThis,
-        ITypeInfo* ptinfo,
-        IUnknown** ppunkStdDisp)
-{
-        FIXME("(%p,%p,%p,%p),stub\n",punkOuter, pvThis, ptinfo,
+    ITypeInfo* ptinfo,
+    IUnknown** ppunkStdDisp)
+{
+    FIXME("(%p,%p,%p,%p),stub\n",punkOuter, pvThis, ptinfo,
                ppunkStdDisp);
-        return 0;
+    return 0;
 }
 
@@ -405 +406 @@
  */
 HRESULT WINAPI RegisterActiveObject16(
-        IUnknown *punk, REFCLSID rclsid, DWORD dwFlags, unsigned long *pdwRegister
+    IUnknown *punk, REFCLSID rclsid, DWORD dwFlags, unsigned long *pdwRegister
 ) {
-        FIXME("(%p,%s,0x%08lx,%p):stub\n",punk,debugstr_guid(rclsid),dwFlags,pdwRegister);
-        return 0;
-}
-#endif
-
-/******************************************************************************
- *              OleTranslateColor       [OLEAUT32.421]
+    FIXME("(%p,%s,0x%08lx,%p):stub\n",punk,debugstr_guid(rclsid),dwFlags,pdwRegister);
+    return 0;
+}
+#endif
+
+/******************************************************************************
+ *      OleTranslateColor   [OLEAUT32.421]
  *
  * Converts an OLE_COLOR to a COLORREF.
  * See the documentation for conversion rules.
- * pColorRef can be NULL. In that case the user only wants to test the 
+ * pColorRef can be NULL. In that case the user only wants to test the
  * conversion.
  */

trunk/src/oleaut32/oleaut.c

@@ +1 @@
+/* $Id: oleaut.c,v 1.2 2001-09-05 13:19:00 bird Exp $ */
 /*
- *      OLEAUT32
+ *  OLEAUT32
  *
  */
@@ -17 +18 @@
 DEFAULT_DEBUG_CHANNEL(ole);
 
-static WCHAR    _delimiter[2] = {'!',0}; /* default delimiter apparently */
-static WCHAR    *pdelimiter = &_delimiter[0];
+static WCHAR    _delimiter[2] = {'!',0}; /* default delimiter apparently */
+static WCHAR    *pdelimiter = &_delimiter[0];
 
 /***********************************************************************
- *              RegisterActiveObject (OLEAUT32.33)
+ *      RegisterActiveObject (OLEAUT32.33)
  */
 HRESULT WINAPI RegisterActiveObject(
-        LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
+    LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
 ) {
-        WCHAR                   guidbuf[80];
-        HRESULT                 ret;
-        LPRUNNINGOBJECTTABLE    runobtable;
-        LPMONIKER               moniker;
+    WCHAR           guidbuf[80];
+    HRESULT         ret;
+    LPRUNNINGOBJECTTABLE    runobtable;
+    LPMONIKER       moniker;
 
-        StringFromGUID2(rcid,guidbuf,39);
+    StringFromGUID2(rcid,guidbuf,39);
 #ifdef __WIN32OS2__
         dprintf(("RegisterActiveObject %x %ls (%x) %x %x", punk, guidbuf, rcid, dwFlags, pdwRegister));
 #endif
-        ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
-        if (FAILED(ret)) 
-                return ret;
-        ret = GetRunningObjectTable(0,&runobtable);
-        if (FAILED(ret)) {
-                IMoniker_Release(moniker);
-                return ret;
-        }
-        ret = IRunningObjectTable_Register(runobtable,dwFlags,punk,moniker,pdwRegister);
-        IRunningObjectTable_Release(runobtable);
-        IMoniker_Release(moniker);
-        return ret;
+    ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
+    if (FAILED(ret))
+        return ret;
+    ret = GetRunningObjectTable(0,&runobtable);
+    if (FAILED(ret)) {
+        IMoniker_Release(moniker);
+        return ret;
+    }
+    ret = IRunningObjectTable_Register(runobtable,dwFlags,punk,moniker,pdwRegister);
+    IRunningObjectTable_Release(runobtable);
+    IMoniker_Release(moniker);
+    return ret;
 }
 
 /***********************************************************************
- *              RevokeActiveObject (OLEAUT32.34)
+ *      RevokeActiveObject (OLEAUT32.34)
  */
 HRESULT WINAPI RevokeActiveObject(DWORD xregister,LPVOID reserved)
 {
-        LPRUNNINGOBJECTTABLE    runobtable;
-        HRESULT                 ret;
+    LPRUNNINGOBJECTTABLE    runobtable;
+    HRESULT         ret;
 
 #ifdef __WIN32OS2__
@@ -61 +62 @@
 #endif
 
-        ret = GetRunningObjectTable(0,&runobtable);
-        if (FAILED(ret)) return ret;
-        ret = IRunningObjectTable_Revoke(runobtable,xregister);
-        if (SUCCEEDED(ret)) ret = S_OK;
-        IRunningObjectTable_Release(runobtable);
-        return ret;
+    ret = GetRunningObjectTable(0,&runobtable);
+    if (FAILED(ret)) return ret;
+    ret = IRunningObjectTable_Revoke(runobtable,xregister);
+    if (SUCCEEDED(ret)) ret = S_OK;
+    IRunningObjectTable_Release(runobtable);
+    return ret;
 }
 
 /***********************************************************************
- *              GetActiveObject (OLEAUT32.35)
+ *      GetActiveObject (OLEAUT32.35)
  */
 HRESULT WINAPI GetActiveObject(REFCLSID rcid,LPVOID preserved,LPUNKNOWN *ppunk)
 {
-        WCHAR                   guidbuf[80];
-        HRESULT                 ret;
-        LPRUNNINGOBJECTTABLE    runobtable;
-        LPMONIKER               moniker;
+    WCHAR           guidbuf[80];
+    HRESULT         ret;
+    LPRUNNINGOBJECTTABLE    runobtable;
+    LPMONIKER       moniker;
 
-        StringFromGUID2(rcid,guidbuf,39);
+    StringFromGUID2(rcid,guidbuf,39);
 #ifdef __WIN32OS2__
         dprintf(("GetActiveObject %ls (%x) %x %x", guidbuf, rcid, preserved, ppunk));
 #endif
-        ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
-        if (FAILED(ret)) 
-                return ret;
-        ret = GetRunningObjectTable(0,&runobtable);
-        if (FAILED(ret)) {
-                IMoniker_Release(moniker);
-                return ret;
-        }
-        ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
-        IRunningObjectTable_Release(runobtable);
-        IMoniker_Release(moniker);
-        return ret;
+    ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
+    if (FAILED(ret))
+        return ret;
+    ret = GetRunningObjectTable(0,&runobtable);
+    if (FAILED(ret)) {
+        IMoniker_Release(moniker);
+        return ret;
+    }
+    ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
+    IRunningObjectTable_Release(runobtable);
+    IMoniker_Release(moniker);
+    return ret;
 }
 
@@ -101 +102 @@
  *
  * known OLEAUT32.DLL versions:
- * OLE 2.1  NT                          1993-95 10     3023
- * OLE 2.1                                      10     3027
- * OLE 2.20 W95/NT                      1993-96 20     4112
- * OLE 2.20 W95/NT                      1993-96 20     4118
- * OLE 2.20 W95/NT                      1993-96 20     4122
- * OLE 2.30 W95/NT                      1993-98 30     4265
- * OLE 2.40 NT??                        1993-98 40     4267
- * OLE 2.40 W98 SE orig. file           1993-98 40     4275
+ * OLE 2.1  NT              1993-95 10     3023
+ * OLE 2.1                  10     3027
+ * OLE 2.20 W95/NT          1993-96 20     4112
+ * OLE 2.20 W95/NT          1993-96 20     4118
+ * OLE 2.20 W95/NT          1993-96 20     4122
+ * OLE 2.30 W95/NT          1993-98 30     4265
+ * OLE 2.40 NT??            1993-98 40     4267
+ * OLE 2.40 W98 SE orig. file       1993-98 40     4275
  */
 UINT WINAPI OaBuildVersion()
@@ -120 +121 @@
     {
     case 0x80000a03:  /* WIN31 */
-                return MAKELONG(4049, 20); /* from Win32s 1.1e */
+        return MAKELONG(4049, 20); /* from Win32s 1.1e */
     case 0x80000004:  /* WIN95 */
-                return MAKELONG(4265, 30);
+        return MAKELONG(4265, 30);
     case 0x80000a04:  /* WIN98 */
-                return MAKELONG(4275, 40); /* value of W98 SE; orig. W98 AFAIK has 4265, 30 just as W95 */
+        return MAKELONG(4275, 40); /* value of W98 SE; orig. W98 AFAIK has 4265, 30 just as W95 */
     case 0x00003303:  /* NT351 */
-                return MAKELONG(4265, 30); /* value borrowed from Win95 */
+        return MAKELONG(4265, 30); /* value borrowed from Win95 */
     case 0x00000004:  /* NT40 */
 #ifdef __WIN32OS2__
                 return 0x2810b5; //returned by NT4, SP6
 #else
-                return MAKELONG(4122, 20); /* ouch ! Quite old, I guess */
+        return MAKELONG(4122, 20); /* ouch ! Quite old, I guess */
 #endif
     default:
-                ERR("Version value not known yet. Please investigate it !\n");
-                return 0x0;
+        ERR("Version value not known yet. Please investigate it !\n");
+        return 0x0;
     }
 }
@@ -141 +142 @@
 #ifndef __WIN32OS2__
 /***********************************************************************
- *              DllRegisterServer
+ *      DllRegisterServer
  */
-HRESULT WINAPI OLEAUT32_DllRegisterServer() { 
+HRESULT WINAPI OLEAUT32_DllRegisterServer() {
     FIXME("stub!\n");
     return S_OK;
@@ -149 +150 @@
 
 /***********************************************************************
- *              DllUnregisterServer
+ *      DllUnregisterServer
  */
 HRESULT WINAPI OLEAUT32_DllUnregisterServer() {

trunk/src/oleaut32/olefont.c

@@ +1 @@
+/* $Id: olefont.c,v 1.3 2001-09-05 13:19:00 bird Exp $ */
 /*
  * OLE Font encapsulation implementation
@@ -46 +47 @@
 {
   /*
-   * This class supports many interfaces. IUnknown, IFont, 
+   * This class supports many interfaces. IUnknown, IFont,
    * IDispatch, IDispFont IPersistStream and IConnectionPointContainer.
    * The first two are supported by the first vtable, the next two are
@@ -85 +86 @@
 
 /*
- * Here, I define utility macros to help with the casting of the 
+ * Here, I define utility macros to help with the casting of the
  * "this" parameter.
  * There is a version to accomodate all of the VTables implemented
@@ -91 +92 @@
  */
 #define _ICOM_THIS(class,name) class* this = (class*)name;
-#define _ICOM_THIS_From_IDispatch(class, name) class* this = (class*)(((char*)name)-sizeof(void*)); 
-#define _ICOM_THIS_From_IPersistStream(class, name) class* this = (class*)(((char*)name)-2*sizeof(void*)); 
-#define _ICOM_THIS_From_IConnectionPointContainer(class, name) class* this = (class*)(((char*)name)-3*sizeof(void*)); 
+#define _ICOM_THIS_From_IDispatch(class, name) class* this = (class*)(((char*)name)-sizeof(void*));
+#define _ICOM_THIS_From_IPersistStream(class, name) class* this = (class*)(((char*)name)-2*sizeof(void*));
+#define _ICOM_THIS_From_IConnectionPointContainer(class, name) class* this = (class*)(((char*)name)-3*sizeof(void*));
 
 
@@ -134 +135 @@
  * interface
  */
-static HRESULT WINAPI OLEFontImpl_IDispatch_QueryInterface(IDispatch* iface, 
-                                                    REFIID     riid, 
-                                                    VOID**     ppvoid);
+static HRESULT WINAPI OLEFontImpl_IDispatch_QueryInterface(IDispatch* iface,
+                            REFIID     riid,
+                            VOID**     ppvoid);
 static ULONG   WINAPI OLEFontImpl_IDispatch_AddRef(IDispatch* iface);
 static ULONG   WINAPI OLEFontImpl_IDispatch_Release(IDispatch* iface);
-static HRESULT WINAPI OLEFontImpl_GetTypeInfoCount(IDispatch*    iface, 
-                                                   unsigned int* pctinfo);
-static HRESULT WINAPI OLEFontImpl_GetTypeInfo(IDispatch*  iface, 
-                                              UINT      iTInfo,
-                                              LCID        lcid, 
-                                              ITypeInfo** ppTInfo);
+static HRESULT WINAPI OLEFontImpl_GetTypeInfoCount(IDispatch*    iface,
+                               unsigned int* pctinfo);
+static HRESULT WINAPI OLEFontImpl_GetTypeInfo(IDispatch*  iface,
+                              UINT      iTInfo,
+                              LCID        lcid,
+                              ITypeInfo** ppTInfo);
 static HRESULT WINAPI OLEFontImpl_GetIDsOfNames(IDispatch*  iface,
-                                                REFIID      riid, 
-                                                LPOLESTR* rgszNames, 
-                                                UINT      cNames, 
-                                                LCID        lcid,
-                                                DISPID*     rgDispId);
+                            REFIID      riid,
+                            LPOLESTR* rgszNames,
+                            UINT      cNames,
+                            LCID        lcid,
+                            DISPID*     rgDispId);
 static HRESULT WINAPI OLEFontImpl_Invoke(IDispatch*  iface,
-                                         DISPID      dispIdMember, 
-                                         REFIID      riid, 
-                                         LCID        lcid, 
-                                         WORD        wFlags,
-                                         DISPPARAMS* pDispParams,
-                                         VARIANT*    pVarResult, 
-                                         EXCEPINFO*  pExepInfo,
-                                         UINT*     puArgErr); 
+                         DISPID      dispIdMember,
+                         REFIID      riid,
+                         LCID        lcid,
+                         WORD        wFlags,
+                         DISPPARAMS* pDispParams,
+                         VARIANT*    pVarResult,
+                         EXCEPINFO*  pExepInfo,
+                         UINT*     puArgErr);
 
 /***********************************************************************
@@ -165 +166 @@
  * interface
  */
-static HRESULT WINAPI OLEFontImpl_IPersistStream_QueryInterface(IPersistStream* iface, 
-                                                    REFIID     riid, 
-                                                    VOID**     ppvoid);
+static HRESULT WINAPI OLEFontImpl_IPersistStream_QueryInterface(IPersistStream* iface,
+                            REFIID     riid,
+                            VOID**     ppvoid);
 static ULONG   WINAPI OLEFontImpl_IPersistStream_AddRef(IPersistStream* iface);
 static ULONG   WINAPI OLEFontImpl_IPersistStream_Release(IPersistStream* iface);
-static HRESULT WINAPI OLEFontImpl_GetClassID(IPersistStream* iface, 
-                                             CLSID*                pClassID);
+static HRESULT WINAPI OLEFontImpl_GetClassID(IPersistStream* iface,
+                         CLSID*                pClassID);
 static HRESULT WINAPI OLEFontImpl_IsDirty(IPersistStream*  iface);
 static HRESULT WINAPI OLEFontImpl_Load(IPersistStream*  iface,
-                                       IStream*         pLoadStream);
+                       IStream*         pLoadStream);
 static HRESULT WINAPI OLEFontImpl_Save(IPersistStream*  iface,
-                                       IStream*         pOutStream,
-                                       BOOL             fClearDirty); 
+                       IStream*         pOutStream,
+                       BOOL             fClearDirty);
 static HRESULT WINAPI OLEFontImpl_GetSizeMax(IPersistStream*  iface,
-                                             ULARGE_INTEGER*  pcbSize); 
+                         ULARGE_INTEGER*  pcbSize);
 
 /***********************************************************************
@@ -186 +187 @@
  */
 static HRESULT WINAPI OLEFontImpl_IConnectionPointContainer_QueryInterface(
-                                            IConnectionPointContainer* iface, 
-                                            REFIID     riid, 
-                                            VOID**     ppvoid);
+                        IConnectionPointContainer* iface,
+                        REFIID     riid,
+                        VOID**     ppvoid);
 static ULONG   WINAPI OLEFontImpl_IConnectionPointContainer_AddRef(
-                                            IConnectionPointContainer* iface);
+                        IConnectionPointContainer* iface);
 static ULONG   WINAPI OLEFontImpl_IConnectionPointContainer_Release(
-                                            IConnectionPointContainer* iface);
+                        IConnectionPointContainer* iface);
 static HRESULT WINAPI OLEFontImpl_EnumConnectionPoints(
-                                            IConnectionPointContainer* iface,
-                                            IEnumConnectionPoints **ppEnum);
+                        IConnectionPointContainer* iface,
+                        IEnumConnectionPoints **ppEnum);
 static HRESULT WINAPI OLEFontImpl_FindConnectionPoint(
-                                            IConnectionPointContainer* iface,
-                                            REFIID riid,
-                                            IConnectionPoint **ppCp);
+                        IConnectionPointContainer* iface,
+                        REFIID riid,
+                        IConnectionPoint **ppCp);
 
 /*
@@ -227 +228 @@
   OLEFontImpl_put_Charset,
   OLEFontImpl_get_hFont,
-  OLEFontImpl_Clone, 
+  OLEFontImpl_Clone,
   OLEFontImpl_IsEqual,
   OLEFontImpl_SetRatio,
@@ -273 +274 @@
 
 /******************************************************************************
- *              OleCreateFontIndirect   [OLEAUT32.420]
+ *      OleCreateFontIndirect   [OLEAUT32.420]
  */
 HRESULT WINAPI OleCreateFontIndirect(
@@ -331 +332 @@
 
   IConnectionPoint_EnumConnections(this->pCP, &pEnum);
-  
+
   while(IEnumConnections_Next(pEnum, 1, &CD, NULL) == S_OK) {
     IPropertyNotifySink *sink;
@@ -343 +344 @@
   return;
 }
-  
+
 /************************************************************************
  * OLEFontImpl_Construct
@@ -364 +365 @@
   if (newObject==0)
     return newObject;
-  
+
   /*
    * Initialize the virtual function table.
@@ -372 +373 @@
   newObject->lpvtbl3 = &OLEFontImpl_IPersistStream_VTable;
   newObject->lpvtbl4 = &OLEFontImpl_IConnectionPointContainer_VTable;
-  
-  /*
-   * Start with one reference count. The caller of this function 
+
+  /*
+   * Start with one reference count. The caller of this function
    * must release the interface pointer when it is done.
    */
@@ -386 +387 @@
   newObject->description.cbSizeofstruct = sizeof(FONTDESC);
   newObject->description.lpstrName = HeapAlloc(GetProcessHeap(),
-                                               0, 
-                                               (lstrlenW(fontDesc->lpstrName)+1) * sizeof(WCHAR));
+                           0,
+                           (lstrlenW(fontDesc->lpstrName)+1) * sizeof(WCHAR));
   strcpyW(newObject->description.lpstrName, fontDesc->lpstrName);
   newObject->description.cySize         = fontDesc->cySize;
@@ -448 +449 @@
   if ( (this==0) || (ppvObject==0) )
     return E_INVALIDARG;
-  
+
   /*
    * Initialize the return parameter.
    */
   *ppvObject = 0;
-  
+
   /*
    * Compare the riid with the interface IDs implemented by this object.
    */
-  if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0) 
+  if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
   {
     *ppvObject = (IFont*)this;
   }
-  else if (memcmp(&IID_IFont, riid, sizeof(IID_IFont)) == 0) 
+  else if (memcmp(&IID_IFont, riid, sizeof(IID_IFont)) == 0)
   {
     *ppvObject = (IFont*)this;
   }
-  else if (memcmp(&IID_IDispatch, riid, sizeof(IID_IDispatch)) == 0) 
+  else if (memcmp(&IID_IDispatch, riid, sizeof(IID_IDispatch)) == 0)
   {
     *ppvObject = (IDispatch*)&(this->lpvtbl2);
   }
-  else if (memcmp(&IID_IFontDisp, riid, sizeof(IID_IFontDisp)) == 0) 
+  else if (memcmp(&IID_IFontDisp, riid, sizeof(IID_IFontDisp)) == 0)
   {
     *ppvObject = (IDispatch*)&(this->lpvtbl2);
   }
-  else if (memcmp(&IID_IPersistStream, riid, sizeof(IID_IPersistStream)) == 0) 
+  else if (memcmp(&IID_IPersistStream, riid, sizeof(IID_IPersistStream)) == 0)
   {
     *ppvObject = (IPersistStream*)&(this->lpvtbl3);
   }
   else if (memcmp(&IID_IConnectionPointContainer, riid,
-                  sizeof(IID_IConnectionPointContainer)) == 0) 
+          sizeof(IID_IConnectionPointContainer)) == 0)
   {
     *ppvObject = (IPersistStream*)&(this->lpvtbl4);
   }
-  
+
   /*
    * Check that we obtained an interface.
@@ -491 +492 @@
     return E_NOINTERFACE;
   }
-  
+
   /*
    * Query Interface always increases the reference count by one when it is
@@ -500 +501 @@
   return S_OK;;
 }
-        
+
 /************************************************************************
  * OLEFontImpl_AddRef (IUnknown)
@@ -506 +507 @@
  * See Windows documentation for more details on IUnknown methods.
  */
-ULONG WINAPI OLEFontImpl_AddRef( 
+ULONG WINAPI OLEFontImpl_AddRef(
   IFont* iface)
 {
@@ -515 +516 @@
   return this->ref;
 }
-        
+
 /************************************************************************
  * OLEFontImpl_Release (IUnknown)
@@ -521 +522 @@
  * See Windows documentation for more details on IUnknown methods.
  */
-ULONG WINAPI OLEFontImpl_Release( 
+ULONG WINAPI OLEFontImpl_Release(
       IFont* iface)
 {
@@ -541 +542 @@
     return 0;
   }
-  
+
   return this->ref;
 }
-        
+
 /************************************************************************
  * OLEFontImpl_get_Name (IFont)
@@ -551 +552 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Name(
-  IFont*  iface, 
+  IFont*  iface,
   BSTR* pname)
 {
@@ -576 +577 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Name(
-  IFont* iface, 
+  IFont* iface,
   BSTR name)
 {
@@ -585 +586 @@
   {
     this->description.lpstrName = HeapAlloc(GetProcessHeap(),
-                                            0, 
-                                            (lstrlenW(name)+1) * sizeof(WCHAR));
+                        0,
+                        (lstrlenW(name)+1) * sizeof(WCHAR));
   }
   else
   {
     this->description.lpstrName = HeapReAlloc(GetProcessHeap(),
-                                              0, 
-                                              this->description.lpstrName,
-                                              (lstrlenW(name)+1) * sizeof(WCHAR));
+                          0,
+                          this->description.lpstrName,
+                          (lstrlenW(name)+1) * sizeof(WCHAR));
   }
 
@@ -611 +612 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Size(
-  IFont* iface, 
+  IFont* iface,
   CY*    psize)
 {
@@ -635 +636 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Size(
-  IFont* iface, 
+  IFont* iface,
   CY     size)
 {
@@ -653 +654 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Bold(
-  IFont*  iface, 
+  IFont*  iface,
   BOOL* pbold)
 {
@@ -692 +693 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Italic(
-  IFont*  iface, 
+  IFont*  iface,
   BOOL* pitalic)
 {
@@ -714 +715 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Italic(
-  IFont* iface, 
+  IFont* iface,
   BOOL italic)
 {
@@ -732 +733 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Underline(
-  IFont*  iface, 
+  IFont*  iface,
   BOOL* punderline)
 {
@@ -773 +774 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Strikethrough(
-  IFont*  iface, 
+  IFont*  iface,
   BOOL* pstrikethrough)
 {
@@ -796 +797 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Strikethrough(
- IFont* iface, 
+ IFont* iface,
  BOOL strikethrough)
 {
@@ -814 +815 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Weight(
-  IFont* iface, 
+  IFont* iface,
   short* pweight)
 {
@@ -837 +838 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Weight(
-  IFont* iface, 
+  IFont* iface,
   short  weight)
 {
@@ -855 +856 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Charset(
-  IFont* iface, 
+  IFont* iface,
   short* pcharset)
 {
@@ -878 +879 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Charset(
-  IFont* iface, 
+  IFont* iface,
   short charset)
 {
@@ -912 +913 @@
     INT      fontHeight;
     CY       cySize;
-    
+
     /*
      * The height of the font returned by the get_Size property is the
@@ -982 +983 @@
    */
   newObject->description.lpstrName = HeapAlloc(
-        GetProcessHeap(),0,
-        (1+strlenW(this->description.lpstrName))*2
+    GetProcessHeap(),0,
+    (1+strlenW(this->description.lpstrName))*2
   );
   /* We need to clone the HFONT too. This is just cut & paste from above */
@@ -994 +995 @@
 
   logFont.lfHeight          = ((fontHeight%10000L)>5000L) ? (-fontHeight/10000L)-1 :
-                                                            (-fontHeight/10000L);
+                                (-fontHeight/10000L);
   logFont.lfItalic          = this->description.fItalic;
   logFont.lfUnderline       = this->description.fUnderline;
@@ -1023 +1024 @@
  */
 static HRESULT WINAPI OLEFontImpl_IsEqual(
-  IFont* iface, 
+  IFont* iface,
   IFont* pFontOther)
 {
@@ -1055 +1056 @@
  */
 static HRESULT      WINAPI OLEFontImpl_QueryTextMetrics(
-  IFont*         iface, 
+  IFont*         iface,
   TEXTMETRICOLE* ptm)
 {
@@ -1068 +1069 @@
  */
 static HRESULT WINAPI OLEFontImpl_AddRefHfont(
-  IFont*  iface, 
+  IFont*  iface,
   HFONT hfont)
 {
@@ -1107 +1108 @@
   {
     DeleteObject(this->gdiFont);
-    this->gdiFont = 0; 
+    this->gdiFont = 0;
   }
 
@@ -1174 +1175 @@
  */
 static HRESULT WINAPI OLEFontImpl_GetTypeInfoCount(
-  IDispatch*    iface, 
+  IDispatch*    iface,
   unsigned int* pctinfo)
 {
@@ -1189 +1190 @@
  */
 static HRESULT WINAPI OLEFontImpl_GetTypeInfo(
-  IDispatch*  iface, 
+  IDispatch*  iface,
   UINT      iTInfo,
-  LCID        lcid, 
+  LCID        lcid,
   ITypeInfo** ppTInfo)
 {
@@ -1207 +1208 @@
 static HRESULT WINAPI OLEFontImpl_GetIDsOfNames(
   IDispatch*  iface,
-  REFIID      riid, 
-  LPOLESTR* rgszNames, 
-  UINT      cNames, 
+  REFIID      riid,
+  LPOLESTR* rgszNames,
+  UINT      cNames,
   LCID        lcid,
   DISPID*     rgDispId)
@@ -1226 +1227 @@
 static HRESULT WINAPI OLEFontImpl_Invoke(
   IDispatch*  iface,
-  DISPID      dispIdMember, 
-  REFIID      riid, 
-  LCID        lcid, 
+  DISPID      dispIdMember,
+  REFIID      riid,
+  LCID        lcid,
   WORD        wFlags,
   DISPPARAMS* pDispParams,
-  VARIANT*    pVarResult, 
+  VARIANT*    pVarResult,
   EXCEPINFO*  pExepInfo,
   UINT*     puArgErr)
@@ -1289 +1290 @@
  */
 static HRESULT WINAPI OLEFontImpl_GetClassID(
-  IPersistStream* iface, 
+  IPersistStream* iface,
   CLSID*                pClassID)
 {
@@ -1343 +1344 @@
 
   _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
-  
+
   /*
    * Read the version byte
@@ -1372 +1373 @@
   this->description.fStrikethrough = (bAttributes & FONTPERSIST_STRIKETHROUGH) != 0;
   this->description.fUnderline     = (bAttributes & FONTPERSIST_UNDERLINE) != 0;
-    
+
   /*
    * Weight
@@ -1408 +1409 @@
     HeapFree(GetProcessHeap(), 0, this->description.lpstrName);
 
-  this->description.lpstrName = HEAP_strdupAtoW(GetProcessHeap(), 
-                                                    HEAP_ZERO_MEMORY,
-                                                    readBuffer);
+  this->description.lpstrName = HEAP_strdupAtoW(GetProcessHeap(),
+                            HEAP_ZERO_MEMORY,
+                            readBuffer);
 
   return S_OK;
@@ -1430 +1431 @@
   BYTE  bAttributes;
   BYTE  bStringSize;
-  
+
   _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
 
@@ -1459 +1460 @@
   if (this->description.fStrikethrough)
     bAttributes |= FONTPERSIST_STRIKETHROUGH;
-  
+
   if (this->description.fUnderline)
     bAttributes |= FONTPERSIST_UNDERLINE;
@@ -1467 +1468 @@
   if (cbWritten!=1)
     return E_FAIL;
-  
+
   /*
    * Weight
@@ -1499 +1500 @@
   if (bStringSize!=0)
   {
-    writeBuffer = HEAP_strdupWtoA(GetProcessHeap(), 
-                                  HEAP_ZERO_MEMORY,
-                                  this->description.lpstrName);
+    writeBuffer = HEAP_strdupWtoA(GetProcessHeap(),
+                  HEAP_ZERO_MEMORY,
+                  this->description.lpstrName);
 
     if (writeBuffer==0)
@@ -1507 +1508 @@
 
     IStream_Write(pOutStream, writeBuffer, bStringSize, &cbWritten);
-    
+
     HeapFree(GetProcessHeap(), 0, writeBuffer);
 
@@ -1620 +1621 @@
   if(memcmp(riid, &IID_IPropertyNotifySink, sizeof(IID_IPropertyNotifySink)) == 0) {
     return IConnectionPoint_QueryInterface(this->pCP, &IID_IConnectionPoint,
-                                           (LPVOID)ppCp);
+                       (LPVOID)ppCp);
   } else {
     FIXME("Tried to find connection point on %s\n", debugstr_guid(riid));
@@ -1637 +1638 @@
 } IClassFactoryImpl;
 
-static HRESULT WINAPI 
+static HRESULT WINAPI
 SFCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
-        ICOM_THIS(IClassFactoryImpl,iface);
-
-        FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
-        return E_NOINTERFACE;
+    ICOM_THIS(IClassFactoryImpl,iface);
+
+    FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+    return E_NOINTERFACE;
 }
 
 static ULONG WINAPI
 SFCF_AddRef(LPCLASSFACTORY iface) {
-        ICOM_THIS(IClassFactoryImpl,iface);
-        return ++(This->ref);
+    ICOM_THIS(IClassFactoryImpl,iface);
+    return ++(This->ref);
 }
 
 static ULONG WINAPI SFCF_Release(LPCLASSFACTORY iface) {
-        ICOM_THIS(IClassFactoryImpl,iface);
-        /* static class, won't be  freed */
-        return --(This->ref);
+    ICOM_THIS(IClassFactoryImpl,iface);
+    /* static class, won't be  freed */
+    return --(This->ref);
 }
 
 static HRESULT WINAPI SFCF_CreateInstance(
-        LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
+    LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
 ) {
-        ICOM_THIS(IClassFactoryImpl,iface);
-
-        if (IsEqualGUID(riid,&IID_IFont)) {
-            FONTDESC fd;
-
-            WCHAR fname[] = { 'S','y','s','t','e','m',0 };
-
-            fd.cbSizeofstruct = sizeof(fd);
-            fd.lpstrName      = fname;
-            fd.cySize.s.Lo    = 80000;
-            fd.cySize.s.Hi    = 0;
-            fd.sWeight        = 0;
-            fd.sCharset       = 0;
-            fd.fItalic        = 0;
-            fd.fUnderline     = 0;
-            fd.fStrikethrough = 0;
-            return OleCreateFontIndirect(&fd,riid,ppobj);
-        }
-
-        FIXME("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
-        return E_NOINTERFACE;
+    ICOM_THIS(IClassFactoryImpl,iface);
+
+    if (IsEqualGUID(riid,&IID_IFont)) {
+        FONTDESC fd;
+
+        WCHAR fname[] = { 'S','y','s','t','e','m',0 };
+
+        fd.cbSizeofstruct = sizeof(fd);
+        fd.lpstrName      = fname;
+        fd.cySize.s.Lo    = 80000;
+        fd.cySize.s.Hi    = 0;
+        fd.sWeight        = 0;
+        fd.sCharset       = 0;
+        fd.fItalic        = 0;
+        fd.fUnderline     = 0;
+        fd.fStrikethrough = 0;
+        return OleCreateFontIndirect(&fd,riid,ppobj);
+    }
+
+    FIXME("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
+    return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI SFCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
-        ICOM_THIS(IClassFactoryImpl,iface);
-        FIXME("(%p)->(%d),stub!\n",This,dolock);
-        return S_OK;
+    ICOM_THIS(IClassFactoryImpl,iface);
+    FIXME("(%p)->(%d),stub!\n",This,dolock);
+    return S_OK;
 }
 
 static ICOM_VTABLE(IClassFactory) SFCF_Vtbl = {
-        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
-        SFCF_QueryInterface,
-        SFCF_AddRef,
-        SFCF_Release,
-        SFCF_CreateInstance,
-        SFCF_LockServer
+    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+    SFCF_QueryInterface,
+    SFCF_AddRef,
+    SFCF_Release,
+    SFCF_CreateInstance,
+    SFCF_LockServer
 };
 static IClassFactoryImpl STDFONT_CF = {&SFCF_Vtbl, 1 };

trunk/src/oleaut32/olepicture.c

@@ +1 @@
+/* $Id: olepicture.c,v 1.5 2001-09-05 13:19:01 bird Exp $ */
 /*
  * OLE Picture object
@@ -50 +51 @@
 #ifdef HAVE_LIBJPEG
 /* This is a hack, so jpeglib.h does not redefine INT32 and the like*/
-#define XMD_H 
+#define XMD_H
 #ifdef HAVE_JPEGLIB_H
 # include <jpeglib.h>
@@ -90 +91 @@
   /* We own the object and must destroy it ourselves */
     BOOL fOwn;
-  
+
   /* Picture description */
     PICTDESC desc;
@@ -105 +106 @@
 
     BOOL keepOrigFormat;
-    HDC hDCCur;
+    HDC hDCCur;
 } OLEPictureImpl;
 
@@ -174 +175 @@
   if (newObject==0)
     return newObject;
-  
+
   /*
    * Initialize the virtual function table.
@@ -186 +187 @@
 
   /*
-   * Start with one reference count. The caller of this function 
+   * Start with one reference count. The caller of this function
    * must release the interface pointer when it is done.
    */
-  newObject->ref        = 1;
-  newObject->hDCCur     = 0;
-
-  newObject->fOwn       = fOwn;
+  newObject->ref    = 1;
+  newObject->hDCCur = 0;
+
+  newObject->fOwn   = fOwn;
 
   /* dunno about original value */
@@ -199 +200 @@
   if (pictDesc) {
       if(pictDesc->cbSizeofstruct != sizeof(PICTDESC)) {
-          FIXME("struct size = %d\n", pictDesc->cbSizeofstruct);
+      FIXME("struct size = %d\n", pictDesc->cbSizeofstruct);
       }
       memcpy(&newObject->desc, pictDesc, sizeof(PICTDESC));
@@ -206 +207 @@
       switch(pictDesc->picType) {
       case PICTYPE_BITMAP:
-        OLEPictureImpl_SetBitmap(newObject);
-        break;
+    OLEPictureImpl_SetBitmap(newObject);
+    break;
 
       case PICTYPE_METAFILE:
-        TRACE("metafile handle %08x\n", pictDesc->u.wmf.hmeta);
-        newObject->himetricWidth = pictDesc->u.wmf.xExt;
-        newObject->himetricHeight = pictDesc->u.wmf.yExt;
-        break;
+    TRACE("metafile handle %08x\n", pictDesc->u.wmf.hmeta);
+    newObject->himetricWidth = pictDesc->u.wmf.xExt;
+    newObject->himetricHeight = pictDesc->u.wmf.yExt;
+    break;
 
       case PICTYPE_ICON:
       case PICTYPE_ENHMETAFILE:
       default:
-        FIXME("Unsupported type %d\n", pictDesc->picType);
-        newObject->himetricWidth = newObject->himetricHeight = 0;
-        break;
+    FIXME("Unsupported type %d\n", pictDesc->picType);
+    newObject->himetricWidth = newObject->himetricHeight = 0;
+    break;
       }
   } else {
       newObject->desc.picType = PICTYPE_UNINITIALIZED;
   }
-    
+
   TRACE("returning %p\n", newObject);
   return newObject;
@@ -237 +238 @@
  * this object.  */
 static void OLEPictureImpl_Destroy(OLEPictureImpl* Obj)
-{ 
+{
   TRACE("(%p)\n", Obj);
 
@@ -282 +283 @@
   if ( (This==0) || (ppvObject==0) )
     return E_INVALIDARG;
-  
+
   /*
    * Initialize the return parameter.
    */
   *ppvObject = 0;
-  
+
   /*
    * Compare the riid with the interface IDs implemented by this object.
    */
-  if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0) 
+  if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
   {
     *ppvObject = (IPicture*)This;
   }
-  else if (memcmp(&IID_IPicture, riid, sizeof(IID_IPicture)) == 0) 
+  else if (memcmp(&IID_IPicture, riid, sizeof(IID_IPicture)) == 0)
   {
     *ppvObject = (IPicture*)This;
   }
-  else if (memcmp(&IID_IDispatch, riid, sizeof(IID_IDispatch)) == 0) 
+  else if (memcmp(&IID_IDispatch, riid, sizeof(IID_IDispatch)) == 0)
   {
     *ppvObject = (IDispatch*)&(This->lpvtbl2);
   }
-  else if (memcmp(&IID_IPictureDisp, riid, sizeof(IID_IPictureDisp)) == 0) 
+  else if (memcmp(&IID_IPictureDisp, riid, sizeof(IID_IPictureDisp)) == 0)
   {
     *ppvObject = (IDispatch*)&(This->lpvtbl2);
   }
-  else if (memcmp(&IID_IPersistStream, riid, sizeof(IID_IPersistStream)) == 0) 
+  else if (memcmp(&IID_IPersistStream, riid, sizeof(IID_IPersistStream)) == 0)
   {
   *ppvObject = (IPersistStream*)&(This->lpvtbl3);
   }
-  else if (memcmp(&IID_IConnectionPointContainer, riid, sizeof(IID_IConnectionPointContainer)) == 0) 
+  else if (memcmp(&IID_IConnectionPointContainer, riid, sizeof(IID_IConnectionPointContainer)) == 0)
   {
   *ppvObject = (IConnectionPointContainer*)&(This->lpvtbl4);
@@ -323 +324 @@
     return E_NOINTERFACE;
   }
-  
+
   /*
    * Query Interface always increases the reference count by one when it is
@@ -362 +363 @@
  * See Windows documentation for more details on IUnknown methods.
  */
-static ULONG WINAPI OLEPictureImpl_AddRef( 
+static ULONG WINAPI OLEPictureImpl_AddRef(
   IPicture* iface)
 {
@@ -371 +372 @@
   return This->ref;
 }
-        
+
 /************************************************************************
  * OLEPictureImpl_Release (IUnknown)
@@ -377 +378 @@
  * See Windows documentation for more details on IUnknown methods.
  */
-static ULONG WINAPI OLEPictureImpl_Release( 
+static ULONG WINAPI OLEPictureImpl_Release(
       IPicture* iface)
 {
@@ -397 +398 @@
     return 0;
   }
-  
+
   return This->ref;
 }
@@ -404 +405 @@
 /************************************************************************
  * OLEPictureImpl_get_Handle
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_get_Handle(IPicture *iface,
-                                                OLE_HANDLE *phandle)
+                        OLE_HANDLE *phandle)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -433 +434 @@
 /************************************************************************
  * OLEPictureImpl_get_hPal
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_get_hPal(IPicture *iface,
-                                              OLE_HANDLE *phandle)
+                          OLE_HANDLE *phandle)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -444 +445 @@
 /************************************************************************
  * OLEPictureImpl_get_Type
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_get_Type(IPicture *iface,
-                                              short *ptype)
+                          short *ptype)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -456 +457 @@
 /************************************************************************
  * OLEPictureImpl_get_Width
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_get_Width(IPicture *iface,
-                                               OLE_XSIZE_HIMETRIC *pwidth)
+                           OLE_XSIZE_HIMETRIC *pwidth)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -468 +469 @@
 /************************************************************************
  * OLEPictureImpl_get_Height
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_get_Height(IPicture *iface,
-                                                OLE_YSIZE_HIMETRIC *pheight)
+                        OLE_YSIZE_HIMETRIC *pheight)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -480 +481 @@
 /************************************************************************
  * OLEPictureImpl_Render
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
-                                            long x, long y, long cx, long cy,
-                                            OLE_XPOS_HIMETRIC xSrc,
-                                            OLE_YPOS_HIMETRIC ySrc,
-                                            OLE_XSIZE_HIMETRIC cxSrc,
-                                            OLE_YSIZE_HIMETRIC cySrc,
-                                            LPCRECT prcWBounds)
+                        long x, long y, long cx, long cy,
+                        OLE_XPOS_HIMETRIC xSrc,
+                        OLE_YPOS_HIMETRIC ySrc,
+                        OLE_XSIZE_HIMETRIC cxSrc,
+                        OLE_YSIZE_HIMETRIC cySrc,
+                        LPCRECT prcWBounds)
 {
   ICOM_THIS(OLEPictureImpl, iface);
   TRACE("(%p)->(%08x, (%ld,%ld), (%ld,%ld) <- (%ld,%ld), (%ld,%ld), %p)\n",
-        This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, prcWBounds);
+    This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, prcWBounds);
   if(prcWBounds)
     TRACE("prcWBounds (%d,%d) - (%d,%d)\n", prcWBounds->left, prcWBounds->top,
-          prcWBounds->right, prcWBounds->bottom);
+      prcWBounds->right, prcWBounds->bottom);
 
   /*
@@ -542 +543 @@
 /************************************************************************
  * OLEPictureImpl_set_hPal
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_set_hPal(IPicture *iface,
-                                              OLE_HANDLE hpal)
+                          OLE_HANDLE hpal)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -554 +555 @@
 /************************************************************************
  * OLEPictureImpl_get_CurDC
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_get_CurDC(IPicture *iface,
-                                               HDC *phdc)
+                           HDC *phdc)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -566 +567 @@
 /************************************************************************
  * OLEPictureImpl_SelectPicture
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_SelectPicture(IPicture *iface,
-                                                   HDC hdcIn,
-                                                   HDC *phdcOut,
-                                                   OLE_HANDLE *phbmpOut)
+                           HDC hdcIn,
+                           HDC *phdcOut,
+                           OLE_HANDLE *phbmpOut)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -578 +579 @@
 
       if (phdcOut)
-          *phdcOut = This->hDCCur;
+      *phdcOut = This->hDCCur;
       This->hDCCur = hdcIn;
       if (phbmpOut)
-          *phbmpOut = This->desc.u.bmp.hbitmap;
+      *phbmpOut = This->desc.u.bmp.hbitmap;
       return S_OK;
   } else {
@@ -591 +592 @@
 /************************************************************************
  * OLEPictureImpl_get_KeepOriginalFormat
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_get_KeepOriginalFormat(IPicture *iface,
-                                                            BOOL *pfKeep)
+                                BOOL *pfKeep)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -605 +606 @@
 /************************************************************************
  * OLEPictureImpl_put_KeepOriginalFormat
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_put_KeepOriginalFormat(IPicture *iface,
-                                                            BOOL keep)
+                                BOOL keep)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -618 +619 @@
 /************************************************************************
  * OLEPictureImpl_PictureChanged
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_PictureChanged(IPicture *iface)
 {
@@ -629 +630 @@
 /************************************************************************
  * OLEPictureImpl_SaveAsFile
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_SaveAsFile(IPicture *iface,
-                                                IStream *pstream,
-                                                BOOL SaveMemCopy,
-                                                LONG *pcbSize)
+                        IStream *pstream,
+                        BOOL SaveMemCopy,
+                        LONG *pcbSize)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -642 +643 @@
 /************************************************************************
  * OLEPictureImpl_get_Attributes
- */ 
+ */
 static HRESULT WINAPI OLEPictureImpl_get_Attributes(IPicture *iface,
-                                                    DWORD *pdwAttr)
+                            DWORD *pdwAttr)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -650 +651 @@
   *pdwAttr = 0;
   switch (This->desc.picType) {
-  case PICTYPE_BITMAP:  break;  /* not 'truely' scalable, see MSDN. */
+  case PICTYPE_BITMAP:  break;  /* not 'truely' scalable, see MSDN. */
   case PICTYPE_ICON: *pdwAttr     = PICTURE_TRANSPARENT;break;
   case PICTYPE_METAFILE: *pdwAttr = PICTURE_TRANSPARENT|PICTURE_SCALABLE;break;
@@ -706 +707 @@
   ICOM_THIS_From_IConnectionPointContainer(OLEPictureImpl, iface);
   TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppCP);
-  if (!ppCP) 
+  if (!ppCP)
       return E_POINTER;
   *ppCP = NULL;
@@ -805 +806 @@
  * Loads the binary data from the IStream. Starts at current position.
  * There appears to be an 2 DWORD header:
- *      DWORD magic;
- *      DWORD len;
+ *  DWORD magic;
+ *  DWORD len;
  *
  * Currently implemented: BITMAP, ICON, JPEG.
  */
 static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface,IStream*pStm) {
-  HRESULT       hr = E_FAIL;
-  ULONG         xread;
-  BYTE          *xbuf;
-  DWORD         header[2];
-  WORD          magic;
+  HRESULT   hr = E_FAIL;
+  ULONG     xread;
+  BYTE      *xbuf;
+  DWORD     header[2];
+  WORD      magic;
   ICOM_THIS_From_IPersistStream(OLEPictureImpl, iface);
 
@@ -828 +829 @@
   xbuf = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,header[1]);
   while (xread < header[1]) {
-    ULONG nread; 
+    ULONG nread;
     hr = IStream_Read(pStm,xbuf+xread,header[1]-xread,&nread);
     xread+=nread;
@@ -841 +842 @@
   case 0xd8ff: { /* JPEG */
 #ifdef HAVE_LIBJPEG
-    struct jpeg_decompress_struct       jd;
-    struct jpeg_error_mgr               jerr;
-    int                                 ret;
-    JDIMENSION                          x;
-    JSAMPROW                            samprow;
-    BITMAPINFOHEADER                    bmi;
-    LPBYTE                              bits;
-    HDC                                 hdcref;
-    struct jpeg_source_mgr              xjsm;
+    struct jpeg_decompress_struct   jd;
+    struct jpeg_error_mgr       jerr;
+    int                 ret;
+    JDIMENSION              x;
+    JSAMPROW                samprow;
+    BITMAPINFOHEADER            bmi;
+    LPBYTE              bits;
+    HDC                 hdcref;
+    struct jpeg_source_mgr      xjsm;
 
     /* This is basically so we can use in-memory data for jpeg decompression.
      * We need to have all the functions.
      */
-    xjsm.next_input_byte        = xbuf;
-    xjsm.bytes_in_buffer        = xread;
-    xjsm.init_source            = _jpeg_init_source;
-    xjsm.fill_input_buffer      = _jpeg_fill_input_buffer;
-    xjsm.skip_input_data        = _jpeg_skip_input_data;
-    xjsm.resync_to_restart      = _jpeg_resync_to_restart;
-    xjsm.term_source            = _jpeg_term_source;
+    xjsm.next_input_byte    = xbuf;
+    xjsm.bytes_in_buffer    = xread;
+    xjsm.init_source        = _jpeg_init_source;
+    xjsm.fill_input_buffer  = _jpeg_fill_input_buffer;
+    xjsm.skip_input_data    = _jpeg_skip_input_data;
+    xjsm.resync_to_restart  = _jpeg_resync_to_restart;
+    xjsm.term_source        = _jpeg_term_source;
 
     jd.err = jpeg_std_error(&jerr);
@@ -868 +869 @@
     jpeg_start_decompress(&jd);
     if (ret != JPEG_HEADER_OK) {
-        ERR("Jpeg image in stream has bad format, read header returned %d.\n",ret);
-        HeapFree(GetProcessHeap(),0,xbuf);
-        return E_FAIL;
+    ERR("Jpeg image in stream has bad format, read header returned %d.\n",ret);
+    HeapFree(GetProcessHeap(),0,xbuf);
+    return E_FAIL;
     }
     bits = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(jd.output_height+1)*jd.output_width*jd.output_components);
@@ -877 +878 @@
       x = jpeg_read_scanlines(&jd,&samprow,1);
       if (x != 1) {
-        FIXME("failed to read current scanline?\n");
-        break;
+    FIXME("failed to read current scanline?\n");
+    break;
       }
       memcpy( bits+jd.output_scanline*jd.output_width*jd.output_components,
-              samprow,
-              jd.output_width*jd.output_components
+          samprow,
+              jd.output_width*jd.output_components
       );
     }
-    bmi.biSize          = sizeof(bmi);
-    bmi.biWidth         =  jd.output_width;
-    bmi.biHeight        = -jd.output_height;
-    bmi.biPlanes        = 1;
-    bmi.biBitCount      = jd.output_components<<3;
-    bmi.biCompression   = BI_RGB;
-    bmi.biSizeImage     = jd.output_height*jd.output_width*jd.output_components;
-    bmi.biXPelsPerMeter = 0;
-    bmi.biYPelsPerMeter = 0;
-    bmi.biClrUsed       = 0;
-    bmi.biClrImportant  = 0;
+    bmi.biSize      = sizeof(bmi);
+    bmi.biWidth     =  jd.output_width;
+    bmi.biHeight    = -jd.output_height;
+    bmi.biPlanes    = 1;
+    bmi.biBitCount  = jd.output_components<<3;
+    bmi.biCompression   = BI_RGB;
+    bmi.biSizeImage = jd.output_height*jd.output_width*jd.output_components;
+    bmi.biXPelsPerMeter = 0;
+    bmi.biYPelsPerMeter = 0;
+    bmi.biClrUsed   = 0;
+    bmi.biClrImportant  = 0;
 
     HeapFree(GetProcessHeap(),0,samprow);
@@ -902 +903 @@
     hdcref = GetDC(0);
     This->desc.u.bmp.hbitmap=CreateDIBitmap(
-            hdcref,
-            &bmi,
-            CBM_INIT,
-            bits,
-            (BITMAPINFO*)&bmi,
-            DIB_RGB_COLORS
+        hdcref,
+        &bmi,
+        CBM_INIT,
+        bits,
+        (BITMAPINFO*)&bmi,
+        DIB_RGB_COLORS
     );
     DeleteDC(hdcref);
@@ -921 +922 @@
   }
   case 0x4d42: { /* Bitmap */
-    BITMAPFILEHEADER    *bfh = (BITMAPFILEHEADER*)xbuf;
-    BITMAPINFO          *bi = (BITMAPINFO*)(bfh+1);
-    HDC                 hdcref;
+    BITMAPFILEHEADER    *bfh = (BITMAPFILEHEADER*)xbuf;
+    BITMAPINFO      *bi = (BITMAPINFO*)(bfh+1);
+    HDC         hdcref;
 
     /* Does not matter whether this is a coreheader or not, we only use
@@ -930 +931 @@
     hdcref = GetDC(0);
     This->desc.u.bmp.hbitmap = CreateDIBitmap(
-        hdcref,
-        &(bi->bmiHeader),
-        CBM_INIT,
-        xbuf+bfh->bfOffBits,
-        bi,
-        (bi->bmiHeader.biBitCount<=8)?DIB_PAL_COLORS:DIB_RGB_COLORS
+    hdcref,
+    &(bi->bmiHeader),
+    CBM_INIT,
+    xbuf+bfh->bfOffBits,
+    bi,
+    (bi->bmiHeader.biBitCount<=8)?DIB_PAL_COLORS:DIB_RGB_COLORS
     );
     DeleteDC(hdcref);
@@ -945 +946 @@
   case 0x0000: { /* ICON , first word is dwReserved */
     HICON hicon;
-    CURSORICONFILEDIR   *cifd = (CURSORICONFILEDIR*)xbuf;
-    int i;
+    CURSORICONFILEDIR   *cifd = (CURSORICONFILEDIR*)xbuf;
+    int i;
 
     /*
@@ -954 +955 @@
 
     for (i=0;i<cifd->idCount;i++) {
-        FIXME("[%d] width %d\n",i,cifd->idEntries[i].bWidth);
-        FIXME("[%d] height %d\n",i,cifd->idEntries[i].bHeight);
-        FIXME("[%d] bColorCount %d\n",i,cifd->idEntries[i].bColorCount);
-        FIXME("[%d] bReserved %d\n",i,cifd->idEntries[i].bReserved);
-        FIXME("[%d] xHotspot %d\n",i,cifd->idEntries[i].xHotspot);
-        FIXME("[%d] yHotspot %d\n",i,cifd->idEntries[i].yHotspot);
-        FIXME("[%d] dwDIBSize %d\n",i,cifd->idEntries[i].dwDIBSize);
-        FIXME("[%d] dwDIBOffset %d\n",i,cifd->idEntries[i].dwDIBOffset);
+    FIXME("[%d] width %d\n",i,cifd->idEntries[i].bWidth);
+    FIXME("[%d] height %d\n",i,cifd->idEntries[i].bHeight);
+    FIXME("[%d] bColorCount %d\n",i,cifd->idEntries[i].bColorCount);
+    FIXME("[%d] bReserved %d\n",i,cifd->idEntries[i].bReserved);
+    FIXME("[%d] xHotspot %d\n",i,cifd->idEntries[i].xHotspot);
+    FIXME("[%d] yHotspot %d\n",i,cifd->idEntries[i].yHotspot);
+    FIXME("[%d] dwDIBSize %d\n",i,cifd->idEntries[i].dwDIBSize);
+    FIXME("[%d] dwDIBOffset %d\n",i,cifd->idEntries[i].dwDIBOffset);
     }
     */
@@ -969 +970 @@
      */
     if (cifd->idCount!=1) {
-        for (i=0;i<cifd->idCount;i++) {
-            if (cifd->idEntries[i].bWidth == 32)
-                break;
-        }
-        if (i==cifd->idCount) i=0;
+    for (i=0;i<cifd->idCount;i++) {
+        if (cifd->idEntries[i].bWidth == 32)
+        break;
     }
+    if (i==cifd->idCount) i=0;
+    }
 
     hicon = CreateIconFromResourceEx(
-                xbuf+cifd->idEntries[i].dwDIBOffset,
-                cifd->idEntries[i].dwDIBSize,
-                TRUE, /* is icon */
-                0x00030000,
-                cifd->idEntries[i].bWidth,
-                cifd->idEntries[i].bHeight,
-                0
+        xbuf+cifd->idEntries[i].dwDIBOffset,
+        cifd->idEntries[i].dwDIBSize,
+        TRUE, /* is icon */
+        0x00030000,
+        cifd->idEntries[i].bWidth,
+        cifd->idEntries[i].bHeight,
+        0
     );
     if (!hicon) {
-        FIXME("CreateIcon failed.\n");
-        hr = E_FAIL;
+    FIXME("CreateIcon failed.\n");
+    hr = E_FAIL;
     } else {
-        This->desc.picType = PICTYPE_ICON;
-        This->desc.u.icon.hicon = hicon;
-        hr = S_OK;
+    This->desc.picType = PICTYPE_ICON;
+    This->desc.u.icon.hicon = hicon;
+    hr = S_OK;
     }
     break;
@@ -1074 +1075 @@
  */
 static HRESULT WINAPI OLEPictureImpl_GetTypeInfoCount(
-  IDispatch*    iface, 
+  IDispatch*    iface,
   unsigned int* pctinfo)
 {
@@ -1088 +1089 @@
  */
 static HRESULT WINAPI OLEPictureImpl_GetTypeInfo(
-  IDispatch*  iface, 
+  IDispatch*  iface,
   UINT      iTInfo,
-  LCID        lcid, 
+  LCID        lcid,
   ITypeInfo** ppTInfo)
 {
@@ -1105 +1106 @@
 static HRESULT WINAPI OLEPictureImpl_GetIDsOfNames(
   IDispatch*  iface,
-  REFIID      riid, 
-  LPOLESTR* rgszNames, 
-  UINT      cNames, 
+  REFIID      riid,
+  LPOLESTR* rgszNames,
+  UINT      cNames,
   LCID        lcid,
   DISPID*     rgDispId)
@@ -1123 +1124 @@
 static HRESULT WINAPI OLEPictureImpl_Invoke(
   IDispatch*  iface,
-  DISPID      dispIdMember, 
-  REFIID      riid, 
-  LCID        lcid, 
+  DISPID      dispIdMember,
+  REFIID      riid,
+  LCID        lcid,
   WORD        wFlags,
   DISPPARAMS* pDispParams,
-  VARIANT*    pVarResult, 
+  VARIANT*    pVarResult,
   EXCEPINFO*  pExepInfo,
   UINT*     puArgErr)
@@ -1202 +1203 @@
  */
 HRESULT WINAPI OleCreatePictureIndirect(LPPICTDESC lpPictDesc, REFIID riid,
-                            BOOL fOwn, LPVOID *ppvObj )
+                    BOOL fOwn, LPVOID *ppvObj )
 {
   OLEPictureImpl* newPict = NULL;
@@ -1244 +1245 @@
  */
 HRESULT WINAPI OleLoadPicture( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
-                            REFIID riid, LPVOID *ppvObj )
+                    REFIID riid, LPVOID *ppvObj )
 {
   LPPERSISTSTREAM ps;
-  IPicture      *newpic;
+  IPicture  *newpic;
   HRESULT hr;
 
   TRACE("(%p,%ld,%d,%s,%p), partially implemented.\n",
-        lpstream, lSize, fRunmode, debugstr_guid(riid), ppvObj);
+    lpstream, lSize, fRunmode, debugstr_guid(riid), ppvObj);
 
   hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
@@ -1276 +1277 @@
  */
 HRESULT WINAPI OleLoadPictureEx( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
-                            REFIID reed, DWORD xsiz, DWORD ysiz, DWORD flags, LPVOID *ppvObj )
+                    REFIID reed, DWORD xsiz, DWORD ysiz, DWORD flags, LPVOID *ppvObj )
 {
   FIXME("(%p,%ld,%d,%p,%lx,%lx,%lx,%p), not implemented\n",
-        lpstream, lSize, fRunmode, reed, xsiz, ysiz, flags, ppvObj);
+    lpstream, lSize, fRunmode, reed, xsiz, ysiz, flags, ppvObj);
   return S_OK;
 }
- 
+
 #ifdef __WIN32OS2__
 
@@ -1308 +1309 @@
 // ----------------------------------------------------------------------
 HRESULT WIN32API OleLoadPicturePath
-   (LPOLESTR            szURLorPath,
-    LPUNKNOWN           punkCaller,
-    DWORD               dwReserved,
-    OLE_COLOR           clrReserved,
-    REFIID              riid,
-    LPVOID *            ppvRet )
+   (LPOLESTR        szURLorPath,
+    LPUNKNOWN       punkCaller,
+    DWORD           dwReserved,
+    OLE_COLOR       clrReserved,
+    REFIID          riid,
+    LPVOID *        ppvRet )
 {
     dprintf(("OLEAUT32: OleLoadPicturePath - stub"));

trunk/src/oleaut32/parsedt.c

@@ +1 @@
+/* $Id: parsedt.c,v 1.2 2001-09-05 13:19:01 bird Exp $ */
 /*
 PostgreSQL Data Base Management System (formerly known as Postgres, then
@@ -26 +27 @@
  *
  * dt.c--
- *        Functions for the built-in type "dt".
+ *    Functions for the built-in type "dt".
  *
  * Copyright (c) 1994, Regents of the University of California
@@ -45 +46 @@
 
 static datetkn *datebsearch(char *key, datetkn *base, unsigned int nel);
-static int      DecodeDate(char *str, int fmask, int *tmask, struct tm * tm);
+static int  DecodeDate(char *str, int fmask, int *tmask, struct tm * tm);
 static int DecodeNumber(int flen, char *field,
-                         int fmask, int *tmask, struct tm * tm, double *fsec);
+             int fmask, int *tmask, struct tm * tm, double *fsec);
 static int DecodeNumberField(int len, char *str,
-                                  int fmask, int *tmask, struct tm * tm, double *fsec);
-static int      DecodeSpecial(int field, char *lowtoken, int *val);
+                  int fmask, int *tmask, struct tm * tm, double *fsec);
+static int  DecodeSpecial(int field, char *lowtoken, int *val);
 static int DecodeTime(char *str, int fmask, int *tmask,
-                   struct tm * tm, double *fsec);
-static int      DecodeTimezone(char *str, int *tzp);
+           struct tm * tm, double *fsec);
+static int  DecodeTimezone(char *str, int *tzp);
 
 #define USE_DATE_CACHE 1
@@ -66 +67 @@
 "Thursday", "Friday", "Saturday", NULL};
 
-/* those three vars are useless, and not even initialized, so 
+/* those three vars are useless, and not even initialized, so
  * I'd rather remove them all (EPP)
  */
-int     DateStyle; 
-bool    EuroDates;
-int     CTimeZone;
+int DateStyle;
+bool    EuroDates;
+int CTimeZone;
 
 #define UTIME_MINYEAR (1901)
@@ -91 +92 @@
 
 /*****************************************************************************
- *       PRIVATE ROUTINES                                                                                                                *
+ *   PRIVATE ROUTINES                                                        *
  *****************************************************************************/
 
 /* definitions for squeezing values into "value" */
-#define ABS_SIGNBIT             (char) 0200
-#define VALMASK                 (char) 0177
-#define NEG(n)                  ((n)|ABS_SIGNBIT)
-#define SIGNEDCHAR(c)   ((c)&ABS_SIGNBIT? -((c)&VALMASK): (c))
-#define FROMVAL(tp)             (-SIGNEDCHAR((tp)->value) * 10) /* uncompress */
-#define TOVAL(tp, v)    ((tp)->value = ((v) < 0? NEG((-(v))/10): (v)/10))
+#define ABS_SIGNBIT     (char) 0200
+#define VALMASK         (char) 0177
+#define NEG(n)          ((n)|ABS_SIGNBIT)
+#define SIGNEDCHAR(c)   ((c)&ABS_SIGNBIT? -((c)&VALMASK): (c))
+#define FROMVAL(tp)     (-SIGNEDCHAR((tp)->value) * 10) /* uncompress */
+#define TOVAL(tp, v)    ((tp)->value = ((v) < 0? NEG((-(v))/10): (v)/10))
 
 /*
@@ -108 +109 @@
  */
 static datetkn datetktbl[] = {
-/*              text                    token   lexval */
-        {EARLY, RESERV, DTK_EARLY}, /* "-infinity" reserved for "early time" */
-        {"acsst", DTZ, 63},                     /* Cent. Australia */
-        {"acst", TZ, 57},                       /* Cent. Australia */
-        {DA_D, ADBC, AD},                       /* "ad" for years >= 0 */
-        {"abstime", IGNOREFIELD, 0},            /* "abstime" for pre-v6.1 "Invalid
-                                                                 * Abstime" */
-        {"adt", DTZ, NEG(18)},          /* Atlantic Daylight Time */
-        {"aesst", DTZ, 66},                     /* E. Australia */
-        {"aest", TZ, 60},                       /* Australia Eastern Std Time */
-        {"ahst", TZ, 60},                       /* Alaska-Hawaii Std Time */
-        {"allballs", RESERV, DTK_ZULU},         /* 00:00:00 */
-        {"am", AMPM, AM},
-        {"apr", MONTH, 4},
-        {"april", MONTH, 4},
-        {"ast", TZ, NEG(24)},           /* Atlantic Std Time (Canada) */
-        {"at", IGNOREFIELD, 0},                 /* "at" (throwaway) */
-        {"aug", MONTH, 8},
-        {"august", MONTH, 8},
-        {"awsst", DTZ, 54},                     /* W. Australia */
-        {"awst", TZ, 48},                       /* W. Australia */
-        {DB_C, ADBC, BC},                       /* "bc" for years < 0 */
-        {"bst", TZ, 6},                         /* British Summer Time */
-        {"bt", TZ, 18},                         /* Baghdad Time */
-        {"cadt", DTZ, 63},                      /* Central Australian DST */
-        {"cast", TZ, 57},                       /* Central Australian ST */
-        {"cat", TZ, NEG(60)},           /* Central Alaska Time */
-        {"cct", TZ, 48},                        /* China Coast */
-        {"cdt", DTZ, NEG(30)},          /* Central Daylight Time */
-        {"cet", TZ, 6},                         /* Central European Time */
-        {"cetdst", DTZ, 12},            /* Central European Dayl.Time */
-        {"cst", TZ, NEG(36)},           /* Central Standard Time */
-        {DCURRENT, RESERV, DTK_CURRENT},        /* "current" is always now */
-        {"dec", MONTH, 12},
-        {"december", MONTH, 12},
-        {"dnt", TZ, 6},                         /* Dansk Normal Tid */
-        {"dow", RESERV, DTK_DOW},       /* day of week */
-        {"doy", RESERV, DTK_DOY},       /* day of year */
-        {"dst", DTZMOD, 6},
-        {"east", TZ, NEG(60)},          /* East Australian Std Time */
-        {"edt", DTZ, NEG(24)},          /* Eastern Daylight Time */
-        {"eet", TZ, 12},                        /* East. Europe, USSR Zone 1 */
-        {"eetdst", DTZ, 18},            /* Eastern Europe */
-        {EPOCH, RESERV, DTK_EPOCH}, /* "epoch" reserved for system epoch time */
+/*      text            token   lexval */
+    {EARLY, RESERV, DTK_EARLY}, /* "-infinity" reserved for "early time" */
+    {"acsst", DTZ, 63},         /* Cent. Australia */
+    {"acst", TZ, 57},           /* Cent. Australia */
+    {DA_D, ADBC, AD},           /* "ad" for years >= 0 */
+    {"abstime", IGNOREFIELD, 0},        /* "abstime" for pre-v6.1 "Invalid
+                                 * Abstime" */
+    {"adt", DTZ, NEG(18)},      /* Atlantic Daylight Time */
+    {"aesst", DTZ, 66},         /* E. Australia */
+    {"aest", TZ, 60},           /* Australia Eastern Std Time */
+    {"ahst", TZ, 60},           /* Alaska-Hawaii Std Time */
+    {"allballs", RESERV, DTK_ZULU},     /* 00:00:00 */
+    {"am", AMPM, AM},
+    {"apr", MONTH, 4},
+    {"april", MONTH, 4},
+    {"ast", TZ, NEG(24)},       /* Atlantic Std Time (Canada) */
+    {"at", IGNOREFIELD, 0},         /* "at" (throwaway) */
+    {"aug", MONTH, 8},
+    {"august", MONTH, 8},
+    {"awsst", DTZ, 54},         /* W. Australia */
+    {"awst", TZ, 48},           /* W. Australia */
+    {DB_C, ADBC, BC},           /* "bc" for years < 0 */
+    {"bst", TZ, 6},             /* British Summer Time */
+    {"bt", TZ, 18},             /* Baghdad Time */
+    {"cadt", DTZ, 63},          /* Central Australian DST */
+    {"cast", TZ, 57},           /* Central Australian ST */
+    {"cat", TZ, NEG(60)},       /* Central Alaska Time */
+    {"cct", TZ, 48},            /* China Coast */
+    {"cdt", DTZ, NEG(30)},      /* Central Daylight Time */
+    {"cet", TZ, 6},             /* Central European Time */
+    {"cetdst", DTZ, 12},        /* Central European Dayl.Time */
+    {"cst", TZ, NEG(36)},       /* Central Standard Time */
+    {DCURRENT, RESERV, DTK_CURRENT},    /* "current" is always now */
+    {"dec", MONTH, 12},
+    {"december", MONTH, 12},
+    {"dnt", TZ, 6},             /* Dansk Normal Tid */
+    {"dow", RESERV, DTK_DOW},   /* day of week */
+    {"doy", RESERV, DTK_DOY},   /* day of year */
+    {"dst", DTZMOD, 6},
+    {"east", TZ, NEG(60)},      /* East Australian Std Time */
+    {"edt", DTZ, NEG(24)},      /* Eastern Daylight Time */
+    {"eet", TZ, 12},            /* East. Europe, USSR Zone 1 */
+    {"eetdst", DTZ, 18},        /* Eastern Europe */
+    {EPOCH, RESERV, DTK_EPOCH}, /* "epoch" reserved for system epoch time */
 #if USE_AUSTRALIAN_RULES
-        {"est", TZ, 60},                        /* Australia Eastern Std Time */
+    {"est", TZ, 60},            /* Australia Eastern Std Time */
 #else
-        {"est", TZ, NEG(30)},           /* Eastern Standard Time */
-#endif
-        {"feb", MONTH, 2},
-        {"february", MONTH, 2},
-        {"fri", DOW, 5},
-        {"friday", DOW, 5},
-        {"fst", TZ, 6},                         /* French Summer Time */
-        {"fwt", DTZ, 12},                       /* French Winter Time  */
-        {"gmt", TZ, 0},                         /* Greenwish Mean Time */
-        {"gst", TZ, 60},                        /* Guam Std Time, USSR Zone 9 */
-        {"hdt", DTZ, NEG(54)},          /* Hawaii/Alaska */
-        {"hmt", DTZ, 18},                       /* Hellas ? ? */
-        {"hst", TZ, NEG(60)},           /* Hawaii Std Time */
-        {"idle", TZ, 72},                       /* Intl. Date Line, East */
-        {"idlw", TZ, NEG(72)},          /* Intl. Date Line,,    est */
-        {LATE, RESERV, DTK_LATE},       /* "infinity" reserved for "late time" */
-        {INVALID, RESERV, DTK_INVALID},         /* "invalid" reserved for invalid
-                                                                                 * time */
-        {"ist", TZ, 12},                        /* Israel */
-        {"it", TZ, 22},                         /* Iran Time */
-        {"jan", MONTH, 1},
-        {"january", MONTH, 1},
-        {"jst", TZ, 54},                        /* Japan Std Time,USSR Zone 8 */
-        {"jt", TZ, 45},                         /* Java Time */
-        {"jul", MONTH, 7},
-        {"july", MONTH, 7},
-        {"jun", MONTH, 6},
-        {"june", MONTH, 6},
-        {"kst", TZ, 54},                        /* Korea Standard Time */
-        {"ligt", TZ, 60},                       /* From Melbourne, Australia */
-        {"mar", MONTH, 3},
-        {"march", MONTH, 3},
-        {"may", MONTH, 5},
-        {"mdt", DTZ, NEG(36)},          /* Mountain Daylight Time */
-        {"mest", DTZ, 12},                      /* Middle Europe Summer Time */
-        {"met", TZ, 6},                         /* Middle Europe Time */
-        {"metdst", DTZ, 12},            /* Middle Europe Daylight Time */
-        {"mewt", TZ, 6},                        /* Middle Europe Winter Time */
-        {"mez", TZ, 6},                         /* Middle Europe Zone */
-        {"mon", DOW, 1},
-        {"monday", DOW, 1},
-        {"mst", TZ, NEG(42)},           /* Mountain Standard Time */
-        {"mt", TZ, 51},                         /* Moluccas Time */
-        {"ndt", DTZ, NEG(15)},          /* Nfld. Daylight Time */
-        {"nft", TZ, NEG(21)},           /* Newfoundland Standard Time */
-        {"nor", TZ, 6},                         /* Norway Standard Time */
-        {"nov", MONTH, 11},
-        {"november", MONTH, 11},
-        {NOW, RESERV, DTK_NOW},         /* current transaction time */
-        {"nst", TZ, NEG(21)},           /* Nfld. Standard Time */
-        {"nt", TZ, NEG(66)},            /* Nome Time */
-        {"nzdt", DTZ, 78},                      /* New Zealand Daylight Time */
-        {"nzst", TZ, 72},                       /* New Zealand Standard Time */
-        {"nzt", TZ, 72},                        /* New Zealand Time */
-        {"oct", MONTH, 10},
-        {"october", MONTH, 10},
-        {"on", IGNOREFIELD, 0},                 /* "on" (throwaway) */
-        {"pdt", DTZ, NEG(42)},          /* Pacific Daylight Time */
-        {"pm", AMPM, PM},
-        {"pst", TZ, NEG(48)},           /* Pacific Standard Time */
-        {"sadt", DTZ, 63},                      /* S. Australian Dayl. Time */
-        {"sast", TZ, 57},                       /* South Australian Std Time */
-        {"sat", DOW, 6},
-        {"saturday", DOW, 6},
-        {"sep", MONTH, 9},
-        {"sept", MONTH, 9},
-        {"september", MONTH, 9},
-        {"set", TZ, NEG(6)},            /* Seychelles Time ?? */
-        {"sst", DTZ, 12},                       /* Swedish Summer Time */
-        {"sun", DOW, 0},
-        {"sunday", DOW, 0},
-        {"swt", TZ, 6},                         /* Swedish Winter Time  */
-        {"thu", DOW, 4},
-        {"thur", DOW, 4},
-        {"thurs", DOW, 4},
-        {"thursday", DOW, 4},
-        {TODAY, RESERV, DTK_TODAY}, /* midnight */
-        {TOMORROW, RESERV, DTK_TOMORROW},       /* tomorrow midnight */
-        {"tue", DOW, 2},
-        {"tues", DOW, 2},
-        {"tuesday", DOW, 2},
-        {"undefined", RESERV, DTK_INVALID}, /* "undefined" pre-v6.1 invalid
-                                                                                 * time */
-        {"ut", TZ, 0},
-        {"utc", TZ, 0},
-        {"wadt", DTZ, 48},                      /* West Australian DST */
-        {"wast", TZ, 42},                       /* West Australian Std Time */
-        {"wat", TZ, NEG(6)},            /* West Africa Time */
-        {"wdt", DTZ, 54},                       /* West Australian DST */
-        {"wed", DOW, 3},
-        {"wednesday", DOW, 3},
-        {"weds", DOW, 3},
-        {"wet", TZ, 0},                         /* Western Europe */
-        {"wetdst", DTZ, 6},                     /* Western Europe */
-        {"wst", TZ, 48},                        /* West Australian Std Time */
-        {"ydt", DTZ, NEG(48)},          /* Yukon Daylight Time */
-        {YESTERDAY, RESERV, DTK_YESTERDAY}, /* yesterday midnight */
-        {"yst", TZ, NEG(54)},           /* Yukon Standard Time */
-        {"zp4", TZ, NEG(24)},           /* GMT +4  hours. */
-        {"zp5", TZ, NEG(30)},           /* GMT +5  hours. */
-        {"zp6", TZ, NEG(36)},           /* GMT +6  hours. */
-        {"z", RESERV, DTK_ZULU},        /* 00:00:00 */
-        {ZULU, RESERV, DTK_ZULU},       /* 00:00:00 */
+    {"est", TZ, NEG(30)},       /* Eastern Standard Time */
+#endif
+    {"feb", MONTH, 2},
+    {"february", MONTH, 2},
+    {"fri", DOW, 5},
+    {"friday", DOW, 5},
+    {"fst", TZ, 6},             /* French Summer Time */
+    {"fwt", DTZ, 12},           /* French Winter Time  */
+    {"gmt", TZ, 0},             /* Greenwish Mean Time */
+    {"gst", TZ, 60},            /* Guam Std Time, USSR Zone 9 */
+    {"hdt", DTZ, NEG(54)},      /* Hawaii/Alaska */
+    {"hmt", DTZ, 18},           /* Hellas ? ? */
+    {"hst", TZ, NEG(60)},       /* Hawaii Std Time */
+    {"idle", TZ, 72},           /* Intl. Date Line, East */
+    {"idlw", TZ, NEG(72)},      /* Intl. Date Line,,    est */
+    {LATE, RESERV, DTK_LATE},   /* "infinity" reserved for "late time" */
+    {INVALID, RESERV, DTK_INVALID},     /* "invalid" reserved for invalid
+                                         * time */
+    {"ist", TZ, 12},            /* Israel */
+    {"it", TZ, 22},             /* Iran Time */
+    {"jan", MONTH, 1},
+    {"january", MONTH, 1},
+    {"jst", TZ, 54},            /* Japan Std Time,USSR Zone 8 */
+    {"jt", TZ, 45},             /* Java Time */
+    {"jul", MONTH, 7},
+    {"july", MONTH, 7},
+    {"jun", MONTH, 6},
+    {"june", MONTH, 6},
+    {"kst", TZ, 54},            /* Korea Standard Time */
+    {"ligt", TZ, 60},           /* From Melbourne, Australia */
+    {"mar", MONTH, 3},
+    {"march", MONTH, 3},
+    {"may", MONTH, 5},
+    {"mdt", DTZ, NEG(36)},      /* Mountain Daylight Time */
+    {"mest", DTZ, 12},          /* Middle Europe Summer Time */
+    {"met", TZ, 6},             /* Middle Europe Time */
+    {"metdst", DTZ, 12},        /* Middle Europe Daylight Time */
+    {"mewt", TZ, 6},            /* Middle Europe Winter Time */
+    {"mez", TZ, 6},             /* Middle Europe Zone */
+    {"mon", DOW, 1},
+    {"monday", DOW, 1},
+    {"mst", TZ, NEG(42)},       /* Mountain Standard Time */
+    {"mt", TZ, 51},             /* Moluccas Time */
+    {"ndt", DTZ, NEG(15)},      /* Nfld. Daylight Time */
+    {"nft", TZ, NEG(21)},       /* Newfoundland Standard Time */
+    {"nor", TZ, 6},             /* Norway Standard Time */
+    {"nov", MONTH, 11},
+    {"november", MONTH, 11},
+    {NOW, RESERV, DTK_NOW},     /* current transaction time */
+    {"nst", TZ, NEG(21)},       /* Nfld. Standard Time */
+    {"nt", TZ, NEG(66)},        /* Nome Time */
+    {"nzdt", DTZ, 78},          /* New Zealand Daylight Time */
+    {"nzst", TZ, 72},           /* New Zealand Standard Time */
+    {"nzt", TZ, 72},            /* New Zealand Time */
+    {"oct", MONTH, 10},
+    {"october", MONTH, 10},
+    {"on", IGNOREFIELD, 0},         /* "on" (throwaway) */
+    {"pdt", DTZ, NEG(42)},      /* Pacific Daylight Time */
+    {"pm", AMPM, PM},
+    {"pst", TZ, NEG(48)},       /* Pacific Standard Time */
+    {"sadt", DTZ, 63},          /* S. Australian Dayl. Time */
+    {"sast", TZ, 57},           /* South Australian Std Time */
+    {"sat", DOW, 6},
+    {"saturday", DOW, 6},
+    {"sep", MONTH, 9},
+    {"sept", MONTH, 9},
+    {"september", MONTH, 9},
+    {"set", TZ, NEG(6)},        /* Seychelles Time ?? */
+    {"sst", DTZ, 12},           /* Swedish Summer Time */
+    {"sun", DOW, 0},
+    {"sunday", DOW, 0},
+    {"swt", TZ, 6},             /* Swedish Winter Time  */
+    {"thu", DOW, 4},
+    {"thur", DOW, 4},
+    {"thurs", DOW, 4},
+    {"thursday", DOW, 4},
+    {TODAY, RESERV, DTK_TODAY}, /* midnight */
+    {TOMORROW, RESERV, DTK_TOMORROW},   /* tomorrow midnight */
+    {"tue", DOW, 2},
+    {"tues", DOW, 2},
+    {"tuesday", DOW, 2},
+    {"undefined", RESERV, DTK_INVALID}, /* "undefined" pre-v6.1 invalid
+                                         * time */
+    {"ut", TZ, 0},
+    {"utc", TZ, 0},
+    {"wadt", DTZ, 48},          /* West Australian DST */
+    {"wast", TZ, 42},           /* West Australian Std Time */
+    {"wat", TZ, NEG(6)},        /* West Africa Time */
+    {"wdt", DTZ, 54},           /* West Australian DST */
+    {"wed", DOW, 3},
+    {"wednesday", DOW, 3},
+    {"weds", DOW, 3},
+    {"wet", TZ, 0},             /* Western Europe */
+    {"wetdst", DTZ, 6},         /* Western Europe */
+    {"wst", TZ, 48},            /* West Australian Std Time */
+    {"ydt", DTZ, NEG(48)},      /* Yukon Daylight Time */
+    {YESTERDAY, RESERV, DTK_YESTERDAY}, /* yesterday midnight */
+    {"yst", TZ, NEG(54)},       /* Yukon Standard Time */
+    {"zp4", TZ, NEG(24)},       /* GMT +4  hours. */
+    {"zp5", TZ, NEG(30)},       /* GMT +5  hours. */
+    {"zp6", TZ, NEG(36)},       /* GMT +6  hours. */
+    {"z", RESERV, DTK_ZULU},    /* 00:00:00 */
+    {ZULU, RESERV, DTK_ZULU},   /* 00:00:00 */
 };
 
@@ -275 +276 @@
  * Calendar time to Julian date conversions.
  * Julian date is commonly used in astronomical applications,
- *      since it is numerically accurate and computationally simple.
+ *  since it is numerically accurate and computationally simple.
  * The algorithms here will accurately convert between Julian day
- *      and calendar date for all non-negative Julian days
- *      (i.e. from Nov 23, -4713 on).
+ *  and calendar date for all non-negative Julian days
+ *  (i.e. from Nov 23, -4713 on).
  *
  * Ref: Explanatory Supplement to the Astronomical Almanac, 1992.
- *      University Science Books, 20 Edgehill Rd. Mill Valley CA 94941.
+ *  University Science Books, 20 Edgehill Rd. Mill Valley CA 94941.
  *
  * Use the algorithm by Henry Fliegel, a former NASA/JPL colleague
- *      now at Aerospace Corp. (hi, Henry!)
+ *  now at Aerospace Corp. (hi, Henry!)
  *
  * These routines will be used by other date/time packages - tgl 97/02/25
@@ -290 +291 @@
 
 /* Set the minimum year to one greater than the year of the first valid day
- *      to avoid having to check year and day both. - tgl 97/05/08
+ *  to avoid having to check year and day both. - tgl 97/05/08
  */
 
@@ -304 +305 @@
 date2j(int y, int m, int d)
 {
-        int                     m12 = (m - 14) / 12;
-
-        return ((1461 * (y + 4800 + m12)) / 4 + (367 * (m - 2 - 12 * (m12))) / 12
-                        - (3 * ((y + 4900 + m12) / 100)) / 4 + d - 32075);
-}       /* date2j() */
+    int         m12 = (m - 14) / 12;
+
+    return ((1461 * (y + 4800 + m12)) / 4 + (367 * (m - 2 - 12 * (m12))) / 12
+            - (3 * ((y + 4900 + m12) / 100)) / 4 + d - 32075);
+}   /* date2j() */
 
 void
 j2date(int jd, int *year, int *month, int *day)
 {
-        int                     j,
-                                y,
-                                m,
-                                d;
-
-        int                     i,
-                                l,
-                                n;
-
-        l = jd + 68569;
-        n = (4 * l) / 146097;
-        l -= (146097 * n + 3) / 4;
-        i = (4000 * (l + 1)) / 1461001;
-        l += 31 - (1461 * i) / 4;
-        j = (80 * l) / 2447;
-        d = l - (2447 * j) / 80;
-        l = j / 11;
-        m = (j + 2) - (12 * l);
-        y = 100 * (n - 49) + i + l;
-
-        *year = y;
-        *month = m;
-        *day = d;
-        return;
-}       /* j2date() */
+    int         j,
+                y,
+                m,
+                d;
+
+    int         i,
+                l,
+                n;
+
+    l = jd + 68569;
+    n = (4 * l) / 146097;
+    l -= (146097 * n + 3) / 4;
+    i = (4000 * (l + 1)) / 1461001;
+    l += 31 - (1461 * i) / 4;
+    j = (80 * l) / 2447;
+    d = l - (2447 * j) / 80;
+    l = j / 11;
+    m = (j + 2) - (12 * l);
+    y = 100 * (n - 49) + i + l;
+
+    *year = y;
+    *month = m;
+    *day = d;
+    return;
+}   /* j2date() */
 
 
@@ -353 +354 @@
 int
 ParseDateTime(char *timestr, char *lowstr,
-                          char **field, int *ftype, int maxfields, int *numfields)
+              char **field, int *ftype, int maxfields, int *numfields)
 {
-        int                     nf = 0;
-        char       *cp = timestr;
-        char       *lp = lowstr;
-
-#ifdef DATEDEBUG
-        printf("ParseDateTime- input string is %s\n", timestr);
-#endif
-        /* outer loop through fields */
-        while (*cp != '\0')
-        {
-                field[nf] = lp;
-
-                /* leading digit? then date or time */
-                if (isdigit(*cp) || (*cp == '.'))
-                {
-                        *lp++ = *cp++;
-                        while (isdigit(*cp))
-                                *lp++ = *cp++;
-                        /* time field? */
-                        if (*cp == ':')
-                        {
-                                ftype[nf] = DTK_TIME;
-                                while (isdigit(*cp) || (*cp == ':') || (*cp == '.'))
-                                        *lp++ = *cp++;
-
-                        }
-                        /* date field? allow embedded text month */
-                        else if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
-                        {
-                                ftype[nf] = DTK_DATE;
-                                while (isalnum(*cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
-                                        *lp++ = tolower(*cp++);
-
-                        }
-
-                        /*
-                         * otherwise, number only and will determine year, month, or
-                         * day later
-                         */
-                        else
-                                ftype[nf] = DTK_NUMBER;
-
-                }
-
-                /*
-                 * text? then date string, month, day of week, special, or
-                 * timezone
-                 */
-                else if (isalpha(*cp))
-                {
-                        ftype[nf] = DTK_STRING;
-                        *lp++ = tolower(*cp++);
-                        while (isalpha(*cp))
-                                *lp++ = tolower(*cp++);
-
-                        /* full date string with leading text month? */
-                        if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
-                        {
-                                ftype[nf] = DTK_DATE;
-                                while (isdigit(*cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
-                                        *lp++ = tolower(*cp++);
-                        }
-
-                        /* skip leading spaces */
-                }
-                else if (isspace(*cp))
-                {
-                        cp++;
-                        continue;
-
-                        /* sign? then special or numeric timezone */
-                }
-                else if ((*cp == '+') || (*cp == '-'))
-                {
-                        *lp++ = *cp++;
-                        /* soak up leading whitespace */
-                        while (isspace(*cp))
-                                cp++;
-                        /* numeric timezone? */
-                        if (isdigit(*cp))
-                        {
-                                ftype[nf] = DTK_TZ;
-                                *lp++ = *cp++;
-                                while (isdigit(*cp) || (*cp == ':'))
-                                        *lp++ = *cp++;
-
-                                /* special? */
-                        }
-                        else if (isalpha(*cp))
-                        {
-                                ftype[nf] = DTK_SPECIAL;
-                                *lp++ = tolower(*cp++);
-                                while (isalpha(*cp))
-                                        *lp++ = tolower(*cp++);
-
-                                /* otherwise something wrong... */
-                        }
-                        else
-                                return -1;
-
-                        /* ignore punctuation but use as delimiter */
-                }
-                else if (ispunct(*cp))
-                {
-                        cp++;
-                        continue;
-
-                }
-                else
-                        return -1;
-
-                /* force in a delimiter */
-                *lp++ = '\0';
-                nf++;
-                if (nf > MAXDATEFIELDS)
-                        return -1;
-#ifdef DATEDEBUG
-                printf("ParseDateTime- set field[%d] to %s type %d\n", (nf - 1), field[nf - 1], ftype[nf - 1]);
-#endif
-        }
-
-        *numfields = nf;
-
-        return 0;
-}       /* ParseDateTime() */
+    int         nf = 0;
+    char       *cp = timestr;
+    char       *lp = lowstr;
+
+#ifdef DATEDEBUG
+    printf("ParseDateTime- input string is %s\n", timestr);
+#endif
+    /* outer loop through fields */
+    while (*cp != '\0')
+    {
+        field[nf] = lp;
+
+        /* leading digit? then date or time */
+        if (isdigit(*cp) || (*cp == '.'))
+        {
+            *lp++ = *cp++;
+            while (isdigit(*cp))
+                *lp++ = *cp++;
+            /* time field? */
+            if (*cp == ':')
+            {
+                ftype[nf] = DTK_TIME;
+                while (isdigit(*cp) || (*cp == ':') || (*cp == '.'))
+                    *lp++ = *cp++;
+
+            }
+            /* date field? allow embedded text month */
+            else if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
+            {
+                ftype[nf] = DTK_DATE;
+                while (isalnum(*cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
+                    *lp++ = tolower(*cp++);
+
+            }
+
+            /*
+             * otherwise, number only and will determine year, month, or
+             * day later
+             */
+            else
+                ftype[nf] = DTK_NUMBER;
+
+        }
+
+        /*
+         * text? then date string, month, day of week, special, or
+         * timezone
+         */
+        else if (isalpha(*cp))
+        {
+            ftype[nf] = DTK_STRING;
+            *lp++ = tolower(*cp++);
+            while (isalpha(*cp))
+                *lp++ = tolower(*cp++);
+
+            /* full date string with leading text month? */
+            if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
+            {
+                ftype[nf] = DTK_DATE;
+                while (isdigit(*cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
+                    *lp++ = tolower(*cp++);
+            }
+
+            /* skip leading spaces */
+        }
+        else if (isspace(*cp))
+        {
+            cp++;
+            continue;
+
+            /* sign? then special or numeric timezone */
+        }
+        else if ((*cp == '+') || (*cp == '-'))
+        {
+            *lp++ = *cp++;
+            /* soak up leading whitespace */
+            while (isspace(*cp))
+                cp++;
+            /* numeric timezone? */
+            if (isdigit(*cp))
+            {
+                ftype[nf] = DTK_TZ;
+                *lp++ = *cp++;
+                while (isdigit(*cp) || (*cp == ':'))
+                    *lp++ = *cp++;
+
+                /* special? */
+            }
+            else if (isalpha(*cp))
+            {
+                ftype[nf] = DTK_SPECIAL;
+                *lp++ = tolower(*cp++);
+                while (isalpha(*cp))
+                    *lp++ = tolower(*cp++);
+
+                /* otherwise something wrong... */
+            }
+            else
+                return -1;
+
+            /* ignore punctuation but use as delimiter */
+        }
+        else if (ispunct(*cp))
+        {
+            cp++;
+            continue;
+
+        }
+        else
+            return -1;
+
+        /* force in a delimiter */
+        *lp++ = '\0';
+        nf++;
+        if (nf > MAXDATEFIELDS)
+            return -1;
+#ifdef DATEDEBUG
+        printf("ParseDateTime- set field[%d] to %s type %d\n", (nf - 1), field[nf - 1], ftype[nf - 1]);
+#endif
+    }
+
+    *numfields = nf;
+
+    return 0;
+}   /* ParseDateTime() */
 
 
@@ -485 +486 @@
  * Interpret previously parsed fields for general date and time.
  * Return 0 if full date, 1 if only time, and -1 if problems.
- *              External format(s):
- *                              "<weekday> <month>-<day>-<year> <hour>:<minute>:<second>"
- *                              "Fri Feb-7-1997 15:23:27"
- *                              "Feb-7-1997 15:23:27"
- *                              "2-7-1997 15:23:27"
- *                              "1997-2-7 15:23:27"
- *                              "1997.038 15:23:27"             (day of year 1-366)
- *              Also supports input in compact time:
- *                              "970207 152327"
- *                              "97038 152327"
+ *      External format(s):
+ *              "<weekday> <month>-<day>-<year> <hour>:<minute>:<second>"
+ *              "Fri Feb-7-1997 15:23:27"
+ *              "Feb-7-1997 15:23:27"
+ *              "2-7-1997 15:23:27"
+ *              "1997-2-7 15:23:27"
+ *              "1997.038 15:23:27"     (day of year 1-366)
+ *      Also supports input in compact time:
+ *              "970207 152327"
+ *              "97038 152327"
  *
  * Use the system-provided functions to get the current time zone
- *      if not specified in the input string.
+ *  if not specified in the input string.
  * If the date is outside the time_t system-supported time range,
- *      then assume GMT time zone. - tgl 97/05/27
+ *  then assume GMT time zone. - tgl 97/05/27
  */
 int
 DecodeDateTime(char **field, int *ftype, int nf,
-                           int *dtype, struct tm * tm, double *fsec, int *tzp)
+               int *dtype, struct tm * tm, double *fsec, int *tzp)
 {
-        int                     fmask = 0,
-                                tmask,
-                                type;
-        int                     i;
-        int                     flen,
-                                val;
-        int                     mer = HR24;
-        int                     bc = FALSE;
-
-        *dtype = DTK_DATE;
-        tm->tm_hour = 0;
-        tm->tm_min = 0;
-        tm->tm_sec = 0;
-        *fsec = 0;
-        tm->tm_isdst = -1;                      /* don't know daylight savings time status
-                                                                 * apriori */
-        if (tzp != NULL)
-                *tzp = 0;
-
-        for (i = 0; i < nf; i++)
-        {
-#ifdef DATEDEBUG
-                printf("DecodeDateTime- field[%d] is %s (type %d)\n", i, field[i], ftype[i]);
-#endif
-                switch (ftype[i])
-                {
-                        case DTK_DATE:
-                                if (DecodeDate(field[i], fmask, &tmask, tm) != 0)
-                                        return -1;
-                                break;
-
-                        case DTK_TIME:
-                                if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
-                                        return -1;
-
-                                /*
-                                 * check upper limit on hours; other limits checked in
-                                 * DecodeTime()
-                                 */
-                                if (tm->tm_hour > 23)
-                                        return -1;
-                                break;
-
-                        case DTK_TZ:
-                                if (tzp == NULL)
-                                        return -1;
-                                if (DecodeTimezone(field[i], tzp) != 0)
-                                        return -1;
-                                tmask = DTK_M(TZ);
-                                break;
-
-                        case DTK_NUMBER:
-                                flen = strlen(field[i]);
-
-                                if (flen > 4)
-                                {
-                                        if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec) != 0)
-                                                return -1;
-
-                                }
-                                else
-                                {
-                                        if (DecodeNumber(flen, field[i], fmask, &tmask, tm, fsec) != 0)
-                                                return -1;
-                                }
-                                break;
-
-                        case DTK_STRING:
-                        case DTK_SPECIAL:
-                                type = DecodeSpecial(i, field[i], &val);
-#ifdef DATEDEBUG
-                                printf("DecodeDateTime- special field[%d] %s type=%d value=%d\n", i, field[i], type, val);
-#endif
-                                if (type == IGNOREFIELD)
-                                        continue;
-
-                                tmask = DTK_M(type);
-                                switch (type)
-                                {
-                                        case RESERV:
-#ifdef DATEDEBUG
-                                                printf("DecodeDateTime- RESERV field %s value is %d\n", field[i], val);
-#endif
-                                                switch (val)
-                                                {
-
-                                                        default:
-                                                                *dtype = val;
-                                                }
-
-                                                break;
-
-                                        case MONTH:
-#ifdef DATEDEBUG
-                                                printf("DecodeDateTime- month field %s value is %d\n", field[i], val);
-#endif
-                                                tm->tm_mon = val;
-                                                break;
-
-                                                /*
-                                                 * daylight savings time modifier (solves "MET
-                                                 * DST" syntax)
-                                                 */
-                                        case DTZMOD:
-                                                tmask |= DTK_M(DTZ);
-                                                tm->tm_isdst = 1;
-                                                if (tzp == NULL)
-                                                        return -1;
-                                                *tzp += val * 60;
-                                                break;
-
-                                        case DTZ:
-
-                                                /*
-                                                 * set mask for TZ here _or_ check for DTZ later
-                                                 * when getting default timezone
-                                                 */
-                                                tmask |= DTK_M(TZ);
-                                                tm->tm_isdst = 1;
-                                                if (tzp == NULL)
-                                                        return -1;
-                                                *tzp = val * 60;
-                                                break;
-
-                                        case TZ:
-                                                tm->tm_isdst = 0;
-                                                if (tzp == NULL)
-                                                        return -1;
-                                                *tzp = val * 60;
-                                                break;
-
-                                        case IGNOREFIELD:
-                                                break;
-
-                                        case AMPM:
-                                                mer = val;
-                                                break;
-
-                                        case ADBC:
-                                                bc = (val == BC);
-                                                break;
-
-                                        case DOW:
-                                                tm->tm_wday = val;
-                                                break;
-
-                                        default:
-                                                return -1;
-                                }
-                                break;
-
-                        default:
-                                return -1;
-                }
-
-#ifdef DATEDEBUG
-                printf("DecodeDateTime- field[%d] %s (%08x/%08x) value is %d\n",
-                           i, field[i], fmask, tmask, val);
-#endif
-
-                if (tmask & fmask)
-                        return -1;
-                fmask |= tmask;
-        }
-
-        /* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */
-        if (bc)
-                tm->tm_year = -(tm->tm_year - 1);
-
-        if ((mer != HR24) && (tm->tm_hour > 12))
-                return -1;
-        if ((mer == AM) && (tm->tm_hour == 12))
-                tm->tm_hour = 0;
-        else if ((mer == PM) && (tm->tm_hour != 12))
-                tm->tm_hour += 12;
-
-#ifdef DATEDEBUG
-        printf("DecodeDateTime- mask %08x (%08x)", fmask, DTK_DATE_M);
-        printf(" set y%04d m%02d d%02d", tm->tm_year, tm->tm_mon, tm->tm_mday);
-        printf(" %02d:%02d:%02d\n", tm->tm_hour, tm->tm_min, tm->tm_sec);
-#endif
-
-        if ((*dtype == DTK_DATE) && ((fmask & DTK_DATE_M) != DTK_DATE_M))
-                return ((fmask & DTK_TIME_M) == DTK_TIME_M) ? 1 : -1;
-
-        /* timezone not specified? then find local timezone if possible */
-        if ((*dtype == DTK_DATE) && ((fmask & DTK_DATE_M) == DTK_DATE_M)
-                && (tzp != NULL) && (!(fmask & DTK_M(TZ))))
-        {
-
-                /*
-                 * daylight savings time modifier but no standard timezone? then
-                 * error
-                 */
-                if (fmask & DTK_M(DTZMOD))
-                        return -1;
-
-                if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
-                {
+    int         fmask = 0,
+                tmask,
+                type;
+    int         i;
+    int         flen,
+                val;
+    int         mer = HR24;
+    int         bc = FALSE;
+
+    *dtype = DTK_DATE;
+    tm->tm_hour = 0;
+    tm->tm_min = 0;
+    tm->tm_sec = 0;
+    *fsec = 0;
+    tm->tm_isdst = -1;          /* don't know daylight savings time status
+                                 * apriori */
+    if (tzp != NULL)
+        *tzp = 0;
+
+    for (i = 0; i < nf; i++)
+    {
+#ifdef DATEDEBUG
+        printf("DecodeDateTime- field[%d] is %s (type %d)\n", i, field[i], ftype[i]);
+#endif
+        switch (ftype[i])
+        {
+            case DTK_DATE:
+                if (DecodeDate(field[i], fmask, &tmask, tm) != 0)
+                    return -1;
+                break;
+
+            case DTK_TIME:
+                if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
+                    return -1;
+
+                /*
+                 * check upper limit on hours; other limits checked in
+                 * DecodeTime()
+                 */
+                if (tm->tm_hour > 23)
+                    return -1;
+                break;
+
+            case DTK_TZ:
+                if (tzp == NULL)
+                    return -1;
+                if (DecodeTimezone(field[i], tzp) != 0)
+                    return -1;
+                tmask = DTK_M(TZ);
+                break;
+
+            case DTK_NUMBER:
+                flen = strlen(field[i]);
+
+                if (flen > 4)
+                {
+                    if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec) != 0)
+                        return -1;
+
+                }
+                else
+                {
+                    if (DecodeNumber(flen, field[i], fmask, &tmask, tm, fsec) != 0)
+                        return -1;
+                }
+                break;
+
+            case DTK_STRING:
+            case DTK_SPECIAL:
+                type = DecodeSpecial(i, field[i], &val);
+#ifdef DATEDEBUG
+                printf("DecodeDateTime- special field[%d] %s type=%d value=%d\n", i, field[i], type, val);
+#endif
+                if (type == IGNOREFIELD)
+                    continue;
+
+                tmask = DTK_M(type);
+                switch (type)
+                {
+                    case RESERV:
+#ifdef DATEDEBUG
+                        printf("DecodeDateTime- RESERV field %s value is %d\n", field[i], val);
+#endif
+                        switch (val)
+                        {
+
+                            default:
+                                *dtype = val;
+                        }
+
+                        break;
+
+                    case MONTH:
+#ifdef DATEDEBUG
+                        printf("DecodeDateTime- month field %s value is %d\n", field[i], val);
+#endif
+                        tm->tm_mon = val;
+                        break;
+
+                        /*
+                         * daylight savings time modifier (solves "MET
+                         * DST" syntax)
+                         */
+                    case DTZMOD:
+                        tmask |= DTK_M(DTZ);
+                        tm->tm_isdst = 1;
+                        if (tzp == NULL)
+                            return -1;
+                        *tzp += val * 60;
+                        break;
+
+                    case DTZ:
+
+                        /*
+                         * set mask for TZ here _or_ check for DTZ later
+                         * when getting default timezone
+                         */
+                        tmask |= DTK_M(TZ);
+                        tm->tm_isdst = 1;
+                        if (tzp == NULL)
+                            return -1;
+                        *tzp = val * 60;
+                        break;
+
+                    case TZ:
+                        tm->tm_isdst = 0;
+                        if (tzp == NULL)
+                            return -1;
+                        *tzp = val * 60;
+                        break;
+
+                    case IGNOREFIELD:
+                        break;
+
+                    case AMPM:
+                        mer = val;
+                        break;
+
+                    case ADBC:
+                        bc = (val == BC);
+                        break;
+
+                    case DOW:
+                        tm->tm_wday = val;
+                        break;
+
+                    default:
+                        return -1;
+                }
+                break;
+
+            default:
+                return -1;
+        }
+
+#ifdef DATEDEBUG
+        printf("DecodeDateTime- field[%d] %s (%08x/%08x) value is %d\n",
+               i, field[i], fmask, tmask, val);
+#endif
+
+        if (tmask & fmask)
+            return -1;
+        fmask |= tmask;
+    }
+
+    /* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */
+    if (bc)
+        tm->tm_year = -(tm->tm_year - 1);
+
+    if ((mer != HR24) && (tm->tm_hour > 12))
+        return -1;
+    if ((mer == AM) && (tm->tm_hour == 12))
+        tm->tm_hour = 0;
+    else if ((mer == PM) && (tm->tm_hour != 12))
+        tm->tm_hour += 12;
+
+#ifdef DATEDEBUG
+    printf("DecodeDateTime- mask %08x (%08x)", fmask, DTK_DATE_M);
+    printf(" set y%04d m%02d d%02d", tm->tm_year, tm->tm_mon, tm->tm_mday);
+    printf(" %02d:%02d:%02d\n", tm->tm_hour, tm->tm_min, tm->tm_sec);
+#endif
+
+    if ((*dtype == DTK_DATE) && ((fmask & DTK_DATE_M) != DTK_DATE_M))
+        return ((fmask & DTK_TIME_M) == DTK_TIME_M) ? 1 : -1;
+
+    /* timezone not specified? then find local timezone if possible */
+    if ((*dtype == DTK_DATE) && ((fmask & DTK_DATE_M) == DTK_DATE_M)
+        && (tzp != NULL) && (!(fmask & DTK_M(TZ))))
+    {
+
+        /*
+         * daylight savings time modifier but no standard timezone? then
+         * error
+         */
+        if (fmask & DTK_M(DTZMOD))
+            return -1;
+
+        if (IS_VALID_UTIME(tm->tm_year, tm->tm_mon, tm->tm_mday))
+        {
 #ifdef USE_POSIX_TIME
-                        tm->tm_year -= 1900;
-                        tm->tm_mon -= 1;
-                        tm->tm_isdst = -1;
-                        mktime(tm);
-                        tm->tm_year += 1900;
-                        tm->tm_mon += 1;
+            tm->tm_year -= 1900;
+            tm->tm_mon -= 1;
+            tm->tm_isdst = -1;
+            mktime(tm);
+            tm->tm_year += 1900;
+            tm->tm_mon += 1;
 
 #ifdef HAVE_INT_TIMEZONE
-                        *tzp = ((tm->tm_isdst > 0) ? (timezone - 3600) : timezone);
-
-#else                                                   /* !HAVE_INT_TIMEZONE */
-                        *tzp = -(tm->tm_gmtoff);        /* tm_gmtoff is Sun/DEC-ism */
-#endif
-
-#else                                                   /* !USE_POSIX_TIME */
-                        *tzp = CTimeZone;
-#endif
-                }
-                else
-                {
-                        tm->tm_isdst = 0;
-                        *tzp = 0;
-                }
-        }
-
-        return 0;
-}       /* DecodeDateTime() */
+            *tzp = ((tm->tm_isdst > 0) ? (timezone - 3600) : timezone);
+
+#else                           /* !HAVE_INT_TIMEZONE */
+            *tzp = -(tm->tm_gmtoff);    /* tm_gmtoff is Sun/DEC-ism */
+#endif
+
+#else                           /* !USE_POSIX_TIME */
+            *tzp = CTimeZone;
+#endif
+        }
+        else
+        {
+            tm->tm_isdst = 0;
+            *tzp = 0;
+        }
+    }
+
+    return 0;
+}   /* DecodeDateTime() */
 
 
@@ -740 +741 @@
 DecodeTimeOnly(char **field, int *ftype, int nf, int *dtype, struct tm * tm, double *fsec)
 {
-        int                     fmask,
-                                tmask,
-                                type;
-        int                     i;
-        int                     flen,
-                                val;
-        int                     mer = HR24;
-
-        *dtype = DTK_TIME;
-        tm->tm_hour = 0;
-        tm->tm_min = 0;
-        tm->tm_sec = 0;
-        tm->tm_isdst = -1;                      /* don't know daylight savings time status
-                                                                 * apriori */
-        *fsec = 0;
-
-        fmask = DTK_DATE_M;
-
-        for (i = 0; i < nf; i++)
-        {
-#ifdef DATEDEBUG
-                printf("DecodeTimeOnly- field[%d] is %s (type %d)\n", i, field[i], ftype[i]);
-#endif
-                switch (ftype[i])
-                {
-                        case DTK_TIME:
-                                if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
-                                        return -1;
-                                break;
-
-                        case DTK_NUMBER:
-                                flen = strlen(field[i]);
-
-                                if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec) != 0)
-                                        return -1;
-                                break;
-
-                        case DTK_STRING:
-                        case DTK_SPECIAL:
-                                type = DecodeSpecial(i, field[i], &val);
-#ifdef DATEDEBUG
-                                printf("DecodeTimeOnly- special field[%d] %s type=%d value=%d\n", i, field[i], type, val);
-#endif
-                                if (type == IGNOREFIELD)
-                                        continue;
-
-                                tmask = DTK_M(type);
-                                switch (type)
-                                {
-                                        case RESERV:
-#ifdef DATEDEBUG
-                                                printf("DecodeTimeOnly- RESERV field %s value is %d\n", field[i], val);
-#endif
-                                                switch (val)
-                                                {
-
-                                                        default:
-                                                                return -1;
-                                                }
-
-                                                break;
-
-                                        case IGNOREFIELD:
-                                                break;
-
-                                        case AMPM:
-                                                mer = val;
-                                                break;
-
-                                        default:
-                                                return -1;
-                                }
-                                break;
-
-                        default:
-                                return -1;
-                }
-
-                if (tmask & fmask)
-                        return -1;
-                fmask |= tmask;
-
-#ifdef DATEDEBUG
-                printf("DecodeTimeOnly- field[%d] %s value is %d\n", i, field[i], val);
-#endif
-        }
-
-#ifdef DATEDEBUG
-        printf("DecodeTimeOnly- mask %08x (%08x)", fmask, DTK_TIME_M);
-        printf(" %02d:%02d:%02d (%f)\n", tm->tm_hour, tm->tm_min, tm->tm_sec, *fsec);
-#endif
-
-        if ((mer != HR24) && (tm->tm_hour > 12))
-                return -1;
-        if ((mer == AM) && (tm->tm_hour == 12))
-                tm->tm_hour = 0;
-        else if ((mer == PM) && (tm->tm_hour != 12))
-                tm->tm_hour += 12;
-
-        if ((fmask & DTK_TIME_M) != DTK_TIME_M)
-                return -1;
-
-        return 0;
-}       /* DecodeTimeOnly() */
+    int         fmask,
+                tmask,
+                type;
+    int         i;
+    int         flen,
+                val;
+    int         mer = HR24;
+
+    *dtype = DTK_TIME;
+    tm->tm_hour = 0;
+    tm->tm_min = 0;
+    tm->tm_sec = 0;
+    tm->tm_isdst = -1;          /* don't know daylight savings time status
+                                 * apriori */
+    *fsec = 0;
+
+    fmask = DTK_DATE_M;
+
+    for (i = 0; i < nf; i++)
+    {
+#ifdef DATEDEBUG
+        printf("DecodeTimeOnly- field[%d] is %s (type %d)\n", i, field[i], ftype[i]);
+#endif
+        switch (ftype[i])
+        {
+            case DTK_TIME:
+                if (DecodeTime(field[i], fmask, &tmask, tm, fsec) != 0)
+                    return -1;
+                break;
+
+            case DTK_NUMBER:
+                flen = strlen(field[i]);
+
+                if (DecodeNumberField(flen, field[i], fmask, &tmask, tm, fsec) != 0)
+                    return -1;
+                break;
+
+            case DTK_STRING:
+            case DTK_SPECIAL:
+                type = DecodeSpecial(i, field[i], &val);
+#ifdef DATEDEBUG
+                printf("DecodeTimeOnly- special field[%d] %s type=%d value=%d\n", i, field[i], type, val);
+#endif
+                if (type == IGNOREFIELD)
+                    continue;
+
+                tmask = DTK_M(type);
+                switch (type)
+                {
+                    case RESERV:
+#ifdef DATEDEBUG
+                        printf("DecodeTimeOnly- RESERV field %s value is %d\n", field[i], val);
+#endif
+                        switch (val)
+                        {
+
+                            default:
+                                return -1;
+                        }
+
+                        break;
+
+                    case IGNOREFIELD:
+                        break;
+
+                    case AMPM:
+                        mer = val;
+                        break;
+
+                    default:
+                        return -1;
+                }
+                break;
+
+            default:
+                return -1;
+        }
+
+        if (tmask & fmask)
+            return -1;
+        fmask |= tmask;
+
+#ifdef DATEDEBUG
+        printf("DecodeTimeOnly- field[%d] %s value is %d\n", i, field[i], val);
+#endif
+    }
+
+#ifdef DATEDEBUG
+    printf("DecodeTimeOnly- mask %08x (%08x)", fmask, DTK_TIME_M);
+    printf(" %02d:%02d:%02d (%f)\n", tm->tm_hour, tm->tm_min, tm->tm_sec, *fsec);
+#endif
+
+    if ((mer != HR24) && (tm->tm_hour > 12))
+        return -1;
+    if ((mer == AM) && (tm->tm_hour == 12))
+        tm->tm_hour = 0;
+    else if ((mer == PM) && (tm->tm_hour != 12))
+        tm->tm_hour += 12;
+
+    if ((fmask & DTK_TIME_M) != DTK_TIME_M)
+        return -1;
+
+    return 0;
+}   /* DecodeTimeOnly() */
 
 
@@ -853 +854 @@
 DecodeDate(char *str, int fmask, int *tmask, struct tm * tm)
 {
-        double          fsec;
-
-        int                     nf = 0;
-        int                     i,
-                                len;
-        int                     type,
-                                val,
-                                dmask = 0;
-        char       *field[MAXDATEFIELDS];
-
-        /* parse this string... */
-        while ((*str != '\0') && (nf < MAXDATEFIELDS))
-        {
-                /* skip field separators */
-                while (!isalnum(*str))
-                        str++;
-
-                field[nf] = str;
-                if (isdigit(*str))
-                {
-                        while (isdigit(*str))
-                                str++;
-                }
-                else if (isalpha(*str))
-                {
-                        while (isalpha(*str))
-                                str++;
-                }
-
-                if (*str != '\0')
-                        *str++ = '\0';
-                nf++;
-        }
-
-        /* don't allow too many fields */
-        if (nf > 3)
-                return -1;
-
-        *tmask = 0;
-
-        /* look first for text fields, since that will be unambiguous month */
-        for (i = 0; i < nf; i++)
-        {
-                if (isalpha(*field[i]))
-                {
-                        type = DecodeSpecial(i, field[i], &val);
-                        if (type == IGNOREFIELD)
-                                continue;
-
-                        dmask = DTK_M(type);
-                        switch (type)
-                        {
-                                case MONTH:
-#ifdef DATEDEBUG
-                                        printf("DecodeDate- month field %s value is %d\n", field[i], val);
-#endif
-                                        tm->tm_mon = val;
-                                        break;
-
-                                default:
-#ifdef DATEDEBUG
-                                        printf("DecodeDate- illegal field %s value is %d\n", field[i], val);
-#endif
-                                        return -1;
-                        }
-                        if (fmask & dmask)
-                                return -1;
-
-                        fmask |= dmask;
-                        *tmask |= dmask;
-
-                        /* mark this field as being completed */
-                        field[i] = NULL;
-                }
-        }
-
-        /* now pick up remaining numeric fields */
-        for (i = 0; i < nf; i++)
-        {
-                if (field[i] == NULL)
-                        continue;
-
-                if ((len = strlen(field[i])) <= 0)
-                        return -1;
-
-                if (DecodeNumber(len, field[i], fmask, &dmask, tm, &fsec) != 0)
-                        return -1;
-
-                if (fmask & dmask)
-                        return -1;
-
-                fmask |= dmask;
-                *tmask |= dmask;
-        }
-
-        return 0;
-}       /* DecodeDate() */
+    double      fsec;
+
+    int         nf = 0;
+    int         i,
+                len;
+    int         type,
+                val,
+                dmask = 0;
+    char       *field[MAXDATEFIELDS];
+
+    /* parse this string... */
+    while ((*str != '\0') && (nf < MAXDATEFIELDS))
+    {
+        /* skip field separators */
+        while (!isalnum(*str))
+            str++;
+
+        field[nf] = str;
+        if (isdigit(*str))
+        {
+            while (isdigit(*str))
+                str++;
+        }
+        else if (isalpha(*str))
+        {
+            while (isalpha(*str))
+                str++;
+        }
+
+        if (*str != '\0')
+            *str++ = '\0';
+        nf++;
+    }
+
+    /* don't allow too many fields */
+    if (nf > 3)
+        return -1;
+
+    *tmask = 0;
+
+    /* look first for text fields, since that will be unambiguous month */
+    for (i = 0; i < nf; i++)
+    {
+        if (isalpha(*field[i]))
+        {
+            type = DecodeSpecial(i, field[i], &val);
+            if (type == IGNOREFIELD)
+                continue;
+
+            dmask = DTK_M(type);
+            switch (type)
+            {
+                case MONTH:
+#ifdef DATEDEBUG
+                    printf("DecodeDate- month field %s value is %d\n", field[i], val);
+#endif
+                    tm->tm_mon = val;
+                    break;
+
+                default:
+#ifdef DATEDEBUG
+                    printf("DecodeDate- illegal field %s value is %d\n", field[i], val);
+#endif
+                    return -1;
+            }
+            if (fmask & dmask)
+                return -1;
+
+            fmask |= dmask;
+            *tmask |= dmask;
+
+            /* mark this field as being completed */
+            field[i] = NULL;
+        }
+    }
+
+    /* now pick up remaining numeric fields */
+    for (i = 0; i < nf; i++)
+    {
+        if (field[i] == NULL)
+            continue;
+
+        if ((len = strlen(field[i])) <= 0)
+            return -1;
+
+        if (DecodeNumber(len, field[i], fmask, &dmask, tm, &fsec) != 0)
+            return -1;
+
+        if (fmask & dmask)
+            return -1;
+
+        fmask |= dmask;
+        *tmask |= dmask;
+    }
+
+    return 0;
+}   /* DecodeDate() */
 
 
@@ -955 +956 @@
  * Decode time string which includes delimiters.
  * Only check the lower limit on hours, since this same code
- *      can be used to represent time spans.
+ *  can be used to represent time spans.
  */
 static int
 DecodeTime(char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
 {
-        char       *cp;
-
-        *tmask = DTK_TIME_M;
-
-        tm->tm_hour = strtol(str, &cp, 10);
-        if (*cp != ':')
-                return -1;
-        str = cp + 1;
-        tm->tm_min = strtol(str, &cp, 10);
-        if (*cp == '\0')
-        {
-                tm->tm_sec = 0;
-                *fsec = 0;
-
-        }
-        else if (*cp != ':')
-        {
-                return -1;
-
-        }
-        else
-        {
-                str = cp + 1;
-                tm->tm_sec = strtol(str, &cp, 10);
-                if (*cp == '\0')
-                        *fsec = 0;
-                else if (*cp == '.')
-                {
-                        str = cp;
-                        *fsec = strtod(str, &cp);
-                        if (cp == str)
-                                return -1;
-                }
-                else
-                        return -1;
-        }
-
-        /* do a sanity check */
-        if ((tm->tm_hour < 0)
-                || (tm->tm_min < 0) || (tm->tm_min > 59)
-                || (tm->tm_sec < 0) || (tm->tm_sec > 59))
-                return -1;
-
-        return 0;
-}       /* DecodeTime() */
+    char       *cp;
+
+    *tmask = DTK_TIME_M;
+
+    tm->tm_hour = strtol(str, &cp, 10);
+    if (*cp != ':')
+        return -1;
+    str = cp + 1;
+    tm->tm_min = strtol(str, &cp, 10);
+    if (*cp == '\0')
+    {
+        tm->tm_sec = 0;
+        *fsec = 0;
+
+    }
+    else if (*cp != ':')
+    {
+        return -1;
+
+    }
+    else
+    {
+        str = cp + 1;
+        tm->tm_sec = strtol(str, &cp, 10);
+        if (*cp == '\0')
+            *fsec = 0;
+        else if (*cp == '.')
+        {
+            str = cp;
+            *fsec = strtod(str, &cp);
+            if (cp == str)
+                return -1;
+        }
+        else
+            return -1;
+    }
+
+    /* do a sanity check */
+    if ((tm->tm_hour < 0)
+        || (tm->tm_min < 0) || (tm->tm_min > 59)
+        || (tm->tm_sec < 0) || (tm->tm_sec > 59))
+        return -1;
+
+    return 0;
+}   /* DecodeTime() */
 
 
@@ -1013 +1014 @@
 DecodeNumber(int flen, char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
 {
-        int                     val;
-        char       *cp;
-
-        *tmask = 0;
-
-        val = strtol(str, &cp, 10);
-        if (cp == str)
-                return -1;
-        if (*cp == '.')
-        {
-                *fsec = strtod(cp, &cp);
-                if (*cp != '\0')
-                        return -1;
-        }
-
-#ifdef DATEDEBUG
-        printf("DecodeNumber- %s is %d fmask=%08x tmask=%08x\n", str, val, fmask, *tmask);
-#endif
-
-        /* enough digits to be unequivocal year? */
-        if (flen == 4)
-        {
-#ifdef DATEDEBUG
-                printf("DecodeNumber- match %d (%s) as year\n", val, str);
-#endif
-                *tmask = DTK_M(YEAR);
-
-                /* already have a year? then see if we can substitute... */
-                if (fmask & DTK_M(YEAR))
-                {
-                        if ((!(fmask & DTK_M(DAY)))
-                                && ((tm->tm_year >= 1) && (tm->tm_year <= 31)))
-                        {
-#ifdef DATEDEBUG
-                                printf("DecodeNumber- misidentified year previously; swap with day %d\n", tm->tm_mday);
-#endif
-                                tm->tm_mday = tm->tm_year;
-                                *tmask = DTK_M(DAY);
-                        }
-                }
-
-                tm->tm_year = val;
-
-                /* special case day of year? */
-        }
-        else if ((flen == 3) && (fmask & DTK_M(YEAR))
-                         && ((val >= 1) && (val <= 366)))
-        {
-                *tmask = (DTK_M(DOY) | DTK_M(MONTH) | DTK_M(DAY));
-                tm->tm_yday = val;
-                j2date((date2j(tm->tm_year, 1, 1) + tm->tm_yday - 1),
-                           &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
-
-                /* already have year? then could be month */
-        }
-        else if ((fmask & DTK_M(YEAR)) && (!(fmask & DTK_M(MONTH)))
-                         && ((val >= 1) && (val <= 12)))
-        {
-#ifdef DATEDEBUG
-                printf("DecodeNumber- match %d (%s) as month\n", val, str);
-#endif
-                *tmask = DTK_M(MONTH);
-                tm->tm_mon = val;
-
-                /* no year and EuroDates enabled? then could be day */
-        }
-        else if ((EuroDates || (fmask & DTK_M(MONTH)))
-                         && (!(fmask & DTK_M(YEAR)) && !(fmask & DTK_M(DAY)))
-                         && ((val >= 1) && (val <= 31)))
-        {
-#ifdef DATEDEBUG
-                printf("DecodeNumber- match %d (%s) as day\n", val, str);
-#endif
-                *tmask = DTK_M(DAY);
-                tm->tm_mday = val;
-
-        }
-        else if ((!(fmask & DTK_M(MONTH)))
-                         && ((val >= 1) && (val <= 12)))
-        {
-#ifdef DATEDEBUG
-                printf("DecodeNumber- (2) match %d (%s) as month\n", val, str);
-#endif
-                *tmask = DTK_M(MONTH);
-                tm->tm_mon = val;
-
-        }
-        else if ((!(fmask & DTK_M(DAY)))
-                         && ((val >= 1) && (val <= 31)))
-        {
-#ifdef DATEDEBUG
-                printf("DecodeNumber- (2) match %d (%s) as day\n", val, str);
-#endif
-                *tmask = DTK_M(DAY);
-                tm->tm_mday = val;
-
-        }
-        else if (!(fmask & DTK_M(YEAR)))
-        {
-#ifdef DATEDEBUG
-                printf("DecodeNumber- (2) match %d (%s) as year\n", val, str);
-#endif
-                *tmask = DTK_M(YEAR);
-                tm->tm_year = val;
-                if (tm->tm_year < 70)
-                        tm->tm_year += 2000;
-                else if (tm->tm_year < 100)
-                        tm->tm_year += 1900;
-
-        }
-        else
-                return -1;
-
-        return 0;
-}       /* DecodeNumber() */
+    int         val;
+    char       *cp;
+
+    *tmask = 0;
+
+    val = strtol(str, &cp, 10);
+    if (cp == str)
+        return -1;
+    if (*cp == '.')
+    {
+        *fsec = strtod(cp, &cp);
+        if (*cp != '\0')
+            return -1;
+    }
+
+#ifdef DATEDEBUG
+    printf("DecodeNumber- %s is %d fmask=%08x tmask=%08x\n", str, val, fmask, *tmask);
+#endif
+
+    /* enough digits to be unequivocal year? */
+    if (flen == 4)
+    {
+#ifdef DATEDEBUG
+        printf("DecodeNumber- match %d (%s) as year\n", val, str);
+#endif
+        *tmask = DTK_M(YEAR);
+
+        /* already have a year? then see if we can substitute... */
+        if (fmask & DTK_M(YEAR))
+        {
+            if ((!(fmask & DTK_M(DAY)))
+                && ((tm->tm_year >= 1) && (tm->tm_year <= 31)))
+            {
+#ifdef DATEDEBUG
+                printf("DecodeNumber- misidentified year previously; swap with day %d\n", tm->tm_mday);
+#endif
+                tm->tm_mday = tm->tm_year;
+                *tmask = DTK_M(DAY);
+            }
+        }
+
+        tm->tm_year = val;
+
+        /* special case day of year? */
+    }
+    else if ((flen == 3) && (fmask & DTK_M(YEAR))
+             && ((val >= 1) && (val <= 366)))
+    {
+        *tmask = (DTK_M(DOY) | DTK_M(MONTH) | DTK_M(DAY));
+        tm->tm_yday = val;
+        j2date((date2j(tm->tm_year, 1, 1) + tm->tm_yday - 1),
+               &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
+
+        /* already have year? then could be month */
+    }
+    else if ((fmask & DTK_M(YEAR)) && (!(fmask & DTK_M(MONTH)))
+             && ((val >= 1) && (val <= 12)))
+    {
+#ifdef DATEDEBUG
+        printf("DecodeNumber- match %d (%s) as month\n", val, str);
+#endif
+        *tmask = DTK_M(MONTH);
+        tm->tm_mon = val;
+
+        /* no year and EuroDates enabled? then could be day */
+    }
+    else if ((EuroDates || (fmask & DTK_M(MONTH)))
+             && (!(fmask & DTK_M(YEAR)) && !(fmask & DTK_M(DAY)))
+             && ((val >= 1) && (val <= 31)))
+    {
+#ifdef DATEDEBUG
+        printf("DecodeNumber- match %d (%s) as day\n", val, str);
+#endif
+        *tmask = DTK_M(DAY);
+        tm->tm_mday = val;
+
+    }
+    else if ((!(fmask & DTK_M(MONTH)))
+             && ((val >= 1) && (val <= 12)))
+    {
+#ifdef DATEDEBUG
+        printf("DecodeNumber- (2) match %d (%s) as month\n", val, str);
+#endif
+        *tmask = DTK_M(MONTH);
+        tm->tm_mon = val;
+
+    }
+    else if ((!(fmask & DTK_M(DAY)))
+             && ((val >= 1) && (val <= 31)))
+    {
+#ifdef DATEDEBUG
+        printf("DecodeNumber- (2) match %d (%s) as day\n", val, str);
+#endif
+        *tmask = DTK_M(DAY);
+        tm->tm_mday = val;
+
+    }
+    else if (!(fmask & DTK_M(YEAR)))
+    {
+#ifdef DATEDEBUG
+        printf("DecodeNumber- (2) match %d (%s) as year\n", val, str);
+#endif
+        *tmask = DTK_M(YEAR);
+        tm->tm_year = val;
+        if (tm->tm_year < 70)
+            tm->tm_year += 2000;
+        else if (tm->tm_year < 100)
+            tm->tm_year += 1900;
+
+    }
+    else
+        return -1;
+
+    return 0;
+}   /* DecodeNumber() */
 
 
@@ -1136 +1137 @@
 DecodeNumberField(int len, char *str, int fmask, int *tmask, struct tm * tm, double *fsec)
 {
-        char       *cp;
-
-        /* yyyymmdd? */
-        if (len == 8)
-        {
-#ifdef DATEDEBUG
-                printf("DecodeNumberField- %s is 8 character date fmask=%08x tmask=%08x\n", str, fmask, *tmask);
-#endif
-
-                *tmask = DTK_DATE_M;
-
-                tm->tm_mday = atoi(str + 6);
-                *(str + 6) = '\0';
-                tm->tm_mon = atoi(str + 4);
-                *(str + 4) = '\0';
-                tm->tm_year = atoi(str + 0);
-
-                /* yymmdd or hhmmss? */
-        }
-        else if (len == 6)
-        {
-#ifdef DATEDEBUG
-                printf("DecodeNumberField- %s is 6 characters fmask=%08x tmask=%08x\n", str, fmask, *tmask);
-#endif
-                if (fmask & DTK_DATE_M)
-                {
-#ifdef DATEDEBUG
-                        printf("DecodeNumberField- %s is time field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
-#endif
-                        *tmask = DTK_TIME_M;
-                        tm->tm_sec = atoi(str + 4);
-                        *(str + 4) = '\0';
-                        tm->tm_min = atoi(str + 2);
-                        *(str + 2) = '\0';
-                        tm->tm_hour = atoi(str + 0);
-
-                }
-                else
-                {
-#ifdef DATEDEBUG
-                        printf("DecodeNumberField- %s is date field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
-#endif
-                        *tmask = DTK_DATE_M;
-                        tm->tm_mday = atoi(str + 4);
-                        *(str + 4) = '\0';
-                        tm->tm_mon = atoi(str + 2);
-                        *(str + 2) = '\0';
-                        tm->tm_year = atoi(str + 0);
-                }
-
-        }
-        else if (strchr(str, '.') != NULL)
-        {
-#ifdef DATEDEBUG
-                printf("DecodeNumberField- %s is time field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
-#endif
-                *tmask = DTK_TIME_M;
-                tm->tm_sec = strtod((str + 4), &cp);
-                if (cp == (str + 4))
-                        return -1;
-                if (*cp == '.')
-                        *fsec = strtod(cp, NULL);
-                *(str + 4) = '\0';
-                tm->tm_min = strtod((str + 2), &cp);
-                *(str + 2) = '\0';
-                tm->tm_hour = strtod((str + 0), &cp);
-
-        }
-        else
-                return -1;
-
-        return 0;
-}       /* DecodeNumberField() */
+    char       *cp;
+
+    /* yyyymmdd? */
+    if (len == 8)
+    {
+#ifdef DATEDEBUG
+        printf("DecodeNumberField- %s is 8 character date fmask=%08x tmask=%08x\n", str, fmask, *tmask);
+#endif
+
+        *tmask = DTK_DATE_M;
+
+        tm->tm_mday = atoi(str + 6);
+        *(str + 6) = '\0';
+        tm->tm_mon = atoi(str + 4);
+        *(str + 4) = '\0';
+        tm->tm_year = atoi(str + 0);
+
+        /* yymmdd or hhmmss? */
+    }
+    else if (len == 6)
+    {
+#ifdef DATEDEBUG
+        printf("DecodeNumberField- %s is 6 characters fmask=%08x tmask=%08x\n", str, fmask, *tmask);
+#endif
+        if (fmask & DTK_DATE_M)
+        {
+#ifdef DATEDEBUG
+            printf("DecodeNumberField- %s is time field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
+#endif
+            *tmask = DTK_TIME_M;
+            tm->tm_sec = atoi(str + 4);
+            *(str + 4) = '\0';
+            tm->tm_min = atoi(str + 2);
+            *(str + 2) = '\0';
+            tm->tm_hour = atoi(str + 0);
+
+        }
+        else
+        {
+#ifdef DATEDEBUG
+            printf("DecodeNumberField- %s is date field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
+#endif
+            *tmask = DTK_DATE_M;
+            tm->tm_mday = atoi(str + 4);
+            *(str + 4) = '\0';
+            tm->tm_mon = atoi(str + 2);
+            *(str + 2) = '\0';
+            tm->tm_year = atoi(str + 0);
+        }
+
+    }
+    else if (strchr(str, '.') != NULL)
+    {
+#ifdef DATEDEBUG
+        printf("DecodeNumberField- %s is time field fmask=%08x tmask=%08x\n", str, fmask, *tmask);
+#endif
+        *tmask = DTK_TIME_M;
+        tm->tm_sec = strtod((str + 4), &cp);
+        if (cp == (str + 4))
+            return -1;
+        if (*cp == '.')
+            *fsec = strtod(cp, NULL);
+        *(str + 4) = '\0';
+        tm->tm_min = strtod((str + 2), &cp);
+        *(str + 2) = '\0';
+        tm->tm_hour = strtod((str + 0), &cp);
+
+    }
+    else
+        return -1;
+
+    return 0;
+}   /* DecodeNumberField() */
 
 
@@ -1217 +1218 @@
 DecodeTimezone(char *str, int *tzp)
 {
-        int                     tz;
-        int                     hr,
-                                min;
-        char       *cp;
-        int                     len;
-
-        /* assume leading character is "+" or "-" */
-        hr = strtol((str + 1), &cp, 10);
-
-        /* explicit delimiter? */
-        if (*cp == ':')
-        {
-                min = strtol((cp + 1), &cp, 10);
-
-                /* otherwise, might have run things together... */
-        }
-        else if ((*cp == '\0') && ((len = strlen(str)) > 3))
-        {
-                min = strtol((str + len - 2), &cp, 10);
-                *(str + len - 2) = '\0';
-                hr = strtol((str + 1), &cp, 10);
-
-        }
-        else
-                min = 0;
-
-        tz = (hr * 60 + min) * 60;
-        if (*str == '-')
-                tz = -tz;
-
-        *tzp = -tz;
-        return *cp != '\0';
-}       /* DecodeTimezone() */
+    int         tz;
+    int         hr,
+                min;
+    char       *cp;
+    int         len;
+
+    /* assume leading character is "+" or "-" */
+    hr = strtol((str + 1), &cp, 10);
+
+    /* explicit delimiter? */
+    if (*cp == ':')
+    {
+        min = strtol((cp + 1), &cp, 10);
+
+        /* otherwise, might have run things together... */
+    }
+    else if ((*cp == '\0') && ((len = strlen(str)) > 3))
+    {
+        min = strtol((str + len - 2), &cp, 10);
+        *(str + len - 2) = '\0';
+        hr = strtol((str + 1), &cp, 10);
+
+    }
+    else
+        min = 0;
+
+    tz = (hr * 60 + min) * 60;
+    if (*str == '-')
+        tz = -tz;
+
+    *tzp = -tz;
+    return *cp != '\0';
+}   /* DecodeTimezone() */
 
 
@@ -1255 +1256 @@
  * Decode text string using lookup table.
  * Implement a cache lookup since it is likely that dates
- *      will be related in format.
+ *  will be related in format.
  */
 static int
 DecodeSpecial(int field, char *lowtoken, int *val)
 {
-        int                     type;
-        datetkn    *tp;
+    int         type;
+    datetkn    *tp;
 
 #if USE_DATE_CACHE
-        if ((datecache[field] != NULL)
-                && (strncmp(lowtoken, datecache[field]->token, TOKMAXLEN) == 0))
-                tp = datecache[field];
-        else
-        {
-#endif
-                tp = datebsearch(lowtoken, datetktbl, szdatetktbl);
+    if ((datecache[field] != NULL)
+        && (strncmp(lowtoken, datecache[field]->token, TOKMAXLEN) == 0))
+        tp = datecache[field];
+    else
+    {
+#endif
+        tp = datebsearch(lowtoken, datetktbl, szdatetktbl);
 #if USE_DATE_CACHE
-        }
-        datecache[field] = tp;
-#endif
-        if (tp == NULL)
-        {
-                type = IGNOREFIELD;
-                *val = 0;
-        }
-        else
-        {
-                type = tp->type;
-                switch (type)
-                {
-                        case TZ:
-                        case DTZ:
-                        case DTZMOD:
-                                *val = FROMVAL(tp);
-                                break;
-
-                        default:
-                                *val = tp->value;
-                                break;
-                }
-        }
-
-        return type;
-}       /* DecodeSpecial() */
+    }
+    datecache[field] = tp;
+#endif
+    if (tp == NULL)
+    {
+        type = IGNOREFIELD;
+        *val = 0;
+    }
+    else
+    {
+        type = tp->type;
+        switch (type)
+        {
+            case TZ:
+            case DTZ:
+            case DTZMOD:
+                *val = FROMVAL(tp);
+                break;
+
+            default:
+                *val = tp->value;
+                break;
+        }
+    }
+
+    return type;
+}   /* DecodeSpecial() */
 
 
@@ -1309 +1310 @@
 datebsearch(char *key, datetkn *base, unsigned int nel)
 {
-        datetkn    *last = base + nel - 1,
-                           *position;
-        int                     result;
-
-        while (last >= base)
-        {
-                position = base + ((last - base) >> 1);
-                result = key[0] - position->token[0];
-                if (result == 0)
-                {
-                        result = strncmp(key, position->token, TOKMAXLEN);
-                        if (result == 0)
-                                return position;
-                }
-                if (result < 0)
-                        last = position - 1;
-                else
-                        base = position + 1;
-        }
-        return NULL;
+    datetkn    *last = base + nel - 1,
+               *position;
+    int         result;
+
+    while (last >= base)
+    {
+        position = base + ((last - base) >> 1);
+        result = key[0] - position->token[0];
+        if (result == 0)
+        {
+            result = strncmp(key, position->token, TOKMAXLEN);
+            if (result == 0)
+                return position;
+        }
+        if (result < 0)
+            last = position - 1;
+        else
+            base = position + 1;
+    }
+    return NULL;
 }
 

trunk/src/oleaut32/safearray.c

@@ +1 @@
+/* $Id: safearray.c,v 1.3 2001-09-05 13:19:01 bird Exp $ */
 /*************************************************************************
  * OLE Automation
@@ -25 +26 @@
 
 /* Localy used methods */
-static INT  
+static INT
 endOfDim(LONG *coor, SAFEARRAYBOUND *mat, LONG dim, LONG realDim);
 
-static ULONG   
+static ULONG
 calcDisplacement(LONG *coor, SAFEARRAYBOUND *mat, LONG dim);
 
-static BOOL  
+static BOOL
 isPointer(USHORT feature);
 
-static INT   
+static INT
 getFeatures(VARTYPE vt);
 
-static BOOL  
+static BOOL
 validCoordinate(LONG *coor, SAFEARRAY *psa);
 
-static BOOL  
+static BOOL
 resizeSafeArray(SAFEARRAY *psa, LONG lDelta);
 
-static BOOL  
+static BOOL
 validArg(SAFEARRAY *psa);
 
-static ULONG   
+static ULONG
 getArraySize(SAFEARRAY *psa);
 
-static HRESULT 
+static HRESULT
 duplicateData(SAFEARRAY *psa, SAFEARRAY **ppsaOut);
 
@@ -59 +60 @@
 {
   /* this is taken from wtypes.h.  Only [S]es are supported by the SafeArray */
-VARTYPE_NOT_SUPPORTED,  /* VT_EMPTY    [V]   [P]    nothing                     */
-VARTYPE_NOT_SUPPORTED,  /* VT_NULL     [V]   [P]    SQL style Nul       */
-2,                          /* VT_I2       [V][T][P][S] 2 byte signed int */
-4,                          /* VT_I4       [V][T][P][S] 4 byte signed int */
-4,                          /* VT_R4       [V][T][P][S] 4 byte real     */
-8,                          /* VT_R8       [V][T][P][S] 8 byte real     */
+VARTYPE_NOT_SUPPORTED,  /* VT_EMPTY    [V]   [P]    nothing         */
+VARTYPE_NOT_SUPPORTED,  /* VT_NULL     [V]   [P]    SQL style Nul   */
+2,                      /* VT_I2       [V][T][P][S] 2 byte signed int */
+4,                      /* VT_I4       [V][T][P][S] 4 byte signed int */
+4,                      /* VT_R4       [V][T][P][S] 4 byte real */
+8,                      /* VT_R8       [V][T][P][S] 8 byte real */
 8,                      /* VT_CY       [V][T][P][S] currency */
-8,                          /* VT_DATE     [V][T][P][S] date */
-4,                          /* VT_BSTR     [V][T][P][S] OLE Automation string*/
-4,                          /* VT_DISPATCH [V][T][P][S] IDispatch *     */
-4,                      /* VT_ERROR    [V][T]   [S] SCODE       */
-4,                          /* VT_BOOL     [V][T][P][S] True=-1, False=0*/
-24,                     /* VT_VARIANT  [V][T][P][S] VARIANT *   */
-4,                          /* VT_UNKNOWN  [V][T]   [S] IUnknown * */
-16,                         /* VT_DECIMAL  [V][T]   [S] 16 byte fixed point     */
+8,                      /* VT_DATE     [V][T][P][S] date */
+4,                      /* VT_BSTR     [V][T][P][S] OLE Automation string*/
+4,                      /* VT_DISPATCH [V][T][P][S] IDispatch * */
+4,                      /* VT_ERROR    [V][T]   [S] SCODE   */
+4,                      /* VT_BOOL     [V][T][P][S] True=-1, False=0*/
+24,                     /* VT_VARIANT  [V][T][P][S] VARIANT *   */
+4,                      /* VT_UNKNOWN  [V][T]   [S] IUnknown * */
+16,                     /* VT_DECIMAL  [V][T]   [S] 16 byte fixed point */
 VARTYPE_NOT_SUPPORTED,                         /* no VARTYPE here..... */
-VARTYPE_NOT_SUPPORTED,  /* VT_I1          [T]       signed char */
-1,                          /* VT_UI1      [V][T][P][S] unsigned char                   */
-VARTYPE_NOT_SUPPORTED,  /* VT_UI2         [T][P]    unsigned short      */
-VARTYPE_NOT_SUPPORTED,  /* VT_UI4         [T][P]    unsigned short      */
-VARTYPE_NOT_SUPPORTED,  /* VT_I8          [T][P]    signed 64-bit int                   */
-VARTYPE_NOT_SUPPORTED,  /* VT_UI8         [T][P]    unsigned 64-bit int         */
-VARTYPE_NOT_SUPPORTED,  /* VT_INT         [T]       signed machine int          */
-VARTYPE_NOT_SUPPORTED,  /* VT_UINT        [T]       unsigned machine int        */
-VARTYPE_NOT_SUPPORTED,  /* VT_VOID        [T]       C style void                        */
-VARTYPE_NOT_SUPPORTED,  /* VT_HRESULT     [T]       Standard return type        */
-VARTYPE_NOT_SUPPORTED,  /* VT_PTR         [T]       pointer type                        */
-VARTYPE_NOT_SUPPORTED,  /* VT_SAFEARRAY   [T]       (use VT_ARRAY in VARIANT)*/
-VARTYPE_NOT_SUPPORTED,  /* VT_CARRAY      [T]       C style array                       */
-VARTYPE_NOT_SUPPORTED,  /* VT_USERDEFINED [T]       user defined type                   */
-VARTYPE_NOT_SUPPORTED,  /* VT_LPSTR       [T][P]    null terminated string      */
-VARTYPE_NOT_SUPPORTED,  /* VT_LPWSTR      [T][P]    wide null term string               */
-VARTYPE_NOT_SUPPORTED,  /* VT_FILETIME       [P]    FILETIME                    */
-VARTYPE_NOT_SUPPORTED,  /* VT_BLOB           [P]    Length prefixed bytes */
-VARTYPE_NOT_SUPPORTED,  /* VT_STREAM         [P]    Name of stream follows              */
-VARTYPE_NOT_SUPPORTED,  /* VT_STORAGE        [P]    Name of storage follows     */
-VARTYPE_NOT_SUPPORTED,  /* VT_STREAMED_OBJECT[P]    Stream contains an object*/
-VARTYPE_NOT_SUPPORTED,  /* VT_STORED_OBJECT  [P]    Storage contains object*/
-VARTYPE_NOT_SUPPORTED,  /* VT_BLOB_OBJECT    [P]    Blob contains an object*/
-VARTYPE_NOT_SUPPORTED,  /* VT_CF             [P]    Clipboard format                    */
-VARTYPE_NOT_SUPPORTED,  /* VT_CLSID          [P]    A Class ID                  */
-VARTYPE_NOT_SUPPORTED,  /* VT_VECTOR         [P]    simple counted array                */
-VARTYPE_NOT_SUPPORTED,  /* VT_ARRAY    [V]          SAFEARRAY*                  */
-VARTYPE_NOT_SUPPORTED   /* VT_BYREF    [V]          void* for local use */
+VARTYPE_NOT_SUPPORTED,  /* VT_I1          [T]       signed char */
+1,                      /* VT_UI1      [V][T][P][S] unsigned char           */
+VARTYPE_NOT_SUPPORTED,  /* VT_UI2         [T][P]    unsigned short  */
+VARTYPE_NOT_SUPPORTED,  /* VT_UI4         [T][P]    unsigned short  */
+VARTYPE_NOT_SUPPORTED,  /* VT_I8          [T][P]    signed 64-bit int           */
+VARTYPE_NOT_SUPPORTED,  /* VT_UI8         [T][P]    unsigned 64-bit int     */
+VARTYPE_NOT_SUPPORTED,  /* VT_INT         [T]       signed machine int      */
+VARTYPE_NOT_SUPPORTED,  /* VT_UINT        [T]       unsigned machine int    */
+VARTYPE_NOT_SUPPORTED,  /* VT_VOID        [T]       C style void            */
+VARTYPE_NOT_SUPPORTED,  /* VT_HRESULT     [T]       Standard return type    */
+VARTYPE_NOT_SUPPORTED,  /* VT_PTR         [T]       pointer type            */
+VARTYPE_NOT_SUPPORTED,  /* VT_SAFEARRAY   [T]       (use VT_ARRAY in VARIANT)*/
+VARTYPE_NOT_SUPPORTED,  /* VT_CARRAY      [T]       C style array           */
+VARTYPE_NOT_SUPPORTED,  /* VT_USERDEFINED [T]       user defined type           */
+VARTYPE_NOT_SUPPORTED,  /* VT_LPSTR       [T][P]    null terminated string  */
+VARTYPE_NOT_SUPPORTED,  /* VT_LPWSTR      [T][P]    wide null term string       */
+VARTYPE_NOT_SUPPORTED,  /* VT_FILETIME       [P]    FILETIME            */
+VARTYPE_NOT_SUPPORTED,  /* VT_BLOB           [P]    Length prefixed bytes */
+VARTYPE_NOT_SUPPORTED,  /* VT_STREAM         [P]    Name of stream follows      */
+VARTYPE_NOT_SUPPORTED,  /* VT_STORAGE        [P]    Name of storage follows */
+VARTYPE_NOT_SUPPORTED,  /* VT_STREAMED_OBJECT[P]    Stream contains an object*/
+VARTYPE_NOT_SUPPORTED,  /* VT_STORED_OBJECT  [P]    Storage contains object*/
+VARTYPE_NOT_SUPPORTED,  /* VT_BLOB_OBJECT    [P]    Blob contains an object*/
+VARTYPE_NOT_SUPPORTED,  /* VT_CF             [P]    Clipboard format            */
+VARTYPE_NOT_SUPPORTED,  /* VT_CLSID          [P]    A Class ID          */
+VARTYPE_NOT_SUPPORTED,  /* VT_VECTOR         [P]    simple counted array        */
+VARTYPE_NOT_SUPPORTED,  /* VT_ARRAY    [V]          SAFEARRAY*          */
+VARTYPE_NOT_SUPPORTED   /* VT_BYREF    [V]          void* for local use */
 };
 
@@ -109 +110 @@
 
 /*************************************************************************
- *              SafeArrayAllocDescriptor
+ *      SafeArrayAllocDescriptor
  * Allocate the appropriate amount of memory for the SafeArray descriptor
  */
-HRESULT WINAPI SafeArrayAllocDescriptor( 
-  UINT    cDims, 
-  SAFEARRAY **ppsaOut) 
+HRESULT WINAPI SafeArrayAllocDescriptor(
+  UINT    cDims,
+  SAFEARRAY **ppsaOut)
 {
   SAFEARRAYBOUND *sab;
@@ -124 +125 @@
 
   /* Allocate memory for SAFEARRAY struc */
-  if(( (*ppsaOut)=HeapAlloc( 
+  if(( (*ppsaOut)=HeapAlloc(
         GetProcessHeap(), HEAP_ZERO_MEMORY, allocSize)) == NULL){
     return(E_UNEXPECTED);
@@ -134 +135 @@
 
 /*************************************************************************
- *              SafeArrayAllocData
+ *      SafeArrayAllocData
  * Allocate the appropriate amount of data for the SafeArray data
  */
 HRESULT WINAPI SafeArrayAllocData(
-  SAFEARRAY *psa) 
+  SAFEARRAY *psa)
 {
   ULONG  ulWholeArraySize;   /* to store the size of the whole thing */
@@ -144 +145 @@
   dprintf(("SafeArrayAllocData %x", psa));
 
-  if(! validArg(psa)) 
+  if(! validArg(psa))
     return E_INVALIDARG;
 
@@ -150 +151 @@
 
   /* Allocate memory for the data itself */
-  if((psa->pvData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 
+  if((psa->pvData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
         psa->cbElements*ulWholeArraySize)) == NULL)
     return(E_UNEXPECTED);
 
-  TRACE("SafeArray: %lu bytes allocated for data at %p (%lu objects).\n", 
+  TRACE("SafeArray: %lu bytes allocated for data at %p (%lu objects).\n",
     psa->cbElements*ulWholeArraySize, psa->pvData, ulWholeArraySize);
 
@@ -161 +162 @@
 
 /*************************************************************************
- *              SafeArrayCreate
- * Create a SafeArray object by encapsulating AllocDescriptor and AllocData 
+ *      SafeArrayCreate
+ * Create a SafeArray object by encapsulating AllocDescriptor and AllocData
  */
 SAFEARRAY* WINAPI SafeArrayCreate(
-  VARTYPE        vt, 
-  UINT         cDims, 
+  VARTYPE        vt,
+  UINT         cDims,
   SAFEARRAYBOUND *rgsabound)
 {
@@ -184 +185 @@
     return NULL;
 
-  /* setup data members... */ 
+  /* setup data members... */
   psa->cDims     = cDims;
   psa->fFeatures = getFeatures(vt);
@@ -197 +198 @@
   }
 
-  /* allocate memory for the data... */ 
+  /* allocate memory for the data... */
   if( FAILED( hRes = SafeArrayAllocData(psa))) {
-    SafeArrayDestroyDescriptor(psa); 
+    SafeArrayDestroyDescriptor(psa);
     ERR("() : Failed to allocate the Safe Array data\n");
     return NULL;
   }
 
-  return(psa); 
-}
-
-/*************************************************************************
- *              SafeArrayDestroyDescriptor
+  return(psa);
+}
+
+/*************************************************************************
+ *      SafeArrayDestroyDescriptor
  * Frees the memory associated with the descriptor.
  */
@@ -217 +218 @@
 
   /* Check for lockness before to free... */
-  if(psa->cLocks > 0) 
+  if(psa->cLocks > 0)
     return DISP_E_ARRAYISLOCKED;
 
   /* The array is unlocked, then, deallocate memory */
-  if(HeapFree( GetProcessHeap(), 0, psa) == FALSE) 
+  if(HeapFree( GetProcessHeap(), 0, psa) == FALSE)
     return E_UNEXPECTED;
-  
+
   return(S_OK);
 }
@@ -229 +230 @@
 
 /*************************************************************************
- *              SafeArrayLock
+ *      SafeArrayLock
  * Increment the lock counter
  *
  * Doc says (MSDN Library ) that psa->pvData should be made available (!= NULL)
- * only when psa->cLocks is > 0... I don't get it since pvData is allocated 
- * before the array is locked, therefore  
+ * only when psa->cLocks is > 0... I don't get it since pvData is allocated
+ * before the array is locked, therefore
  */
 HRESULT WINAPI SafeArrayLock(
@@ -241 +242 @@
   dprintf(("SafeArrayLock %x", psa));
 
-  if(! validArg(psa))     
+  if(! validArg(psa))
     return E_INVALIDARG;
 
@@ -250 +251 @@
 
 /*************************************************************************
- *              SafeArrayUnlock
+ *      SafeArrayUnlock
  * Decrement the lock counter
  */
@@ -258 +259 @@
   dprintf(("SafeArrayUnlock %x", psa));
 
-  if(! validArg(psa)) 
-    return E_INVALIDARG;
-
-  if (psa->cLocks > 0) 
+  if(! validArg(psa))
+    return E_INVALIDARG;
+
+  if (psa->cLocks > 0)
     psa->cLocks--;
 
@@ -269 +270 @@
 
 /*************************************************************************
- *              SafeArrayPutElement
+ *      SafeArrayPutElement
  * Set the data at the given coordinate
  */
 HRESULT WINAPI SafeArrayPutElement(
-  SAFEARRAY *psa, 
-  LONG      *rgIndices, 
+  SAFEARRAY *psa,
+  LONG      *rgIndices,
   void      *pv)
 {
-  ULONG stepCountInSAData     = 0;    /* Number of array item to skip to get to 
+  ULONG stepCountInSAData     = 0;    /* Number of array item to skip to get to
                                          the desired one... */
   PVOID elementStorageAddress = NULL; /* Adress to store the data */
@@ -285 +286 @@
 
   /* Validate the index given */
-  if(! validCoordinate(rgIndices, psa)) 
+  if(! validCoordinate(rgIndices, psa))
     return DISP_E_BADINDEX;
   if(! validArg(psa))
@@ -294 +295 @@
     /* Figure out the number of items to skip */
     stepCountInSAData = calcDisplacement(rgIndices, psa->rgsabound, psa->cDims);
-  
+
     /* Figure out the number of byte to skip ... */
     elementStorageAddress = (char *) psa->pvData+(stepCountInSAData*psa->cbElements);
-  
+
     if(isPointer(psa->fFeatures)) { /* increment ref count for this pointer */
 
-      *((VOID**)elementStorageAddress) = *(VOID**)pv; 
+      *((VOID**)elementStorageAddress) = *(VOID**)pv;
       IUnknown_AddRef( *(IUnknown**)pv);
 
-    } else { 
+    } else {
 
       if(psa->fFeatures == FADF_BSTR) { /* Create a new object */
 
         if((pbstrReAllocStr = SysAllocString( (OLECHAR*)pv )) == NULL) {
-          SafeArrayUnlock(psa);  
+          SafeArrayUnlock(psa);
           return E_OUTOFMEMORY;
-        } else 
+        } else
           *((BSTR*)elementStorageAddress) = pbstrReAllocStr;
 
@@ -323 +324 @@
 
   TRACE("SafeArray: item put at adress %p.\n",elementStorageAddress);
-  return SafeArrayUnlock(psa);  
-}
-
-
-/*************************************************************************
- *              SafeArrayGetElement
+  return SafeArrayUnlock(psa);
+}
+
+
+/*************************************************************************
+ *      SafeArrayGetElement
  * Return the data element corresponding the the given coordinate
  */
 HRESULT WINAPI SafeArrayGetElement(
-  SAFEARRAY *psa, 
-  LONG      *rgIndices, 
+  SAFEARRAY *psa,
+  LONG      *rgIndices,
   void      *pv)
 {
-  ULONG stepCountInSAData     = 0;    /* Number of array item to skip to get to 
+  ULONG stepCountInSAData     = 0;    /* Number of array item to skip to get to
                                          the desired one... */
   PVOID elementStorageAddress = NULL; /* Adress to store the data */
@@ -343 +344 @@
   dprintf(("SafeArrayGetElement %x %x %x", psa, rgIndices, pv));
 
-  if(! validArg(psa)) 
-    return E_INVALIDARG;
-  
+  if(! validArg(psa))
+    return E_INVALIDARG;
+
   if(! validCoordinate(rgIndices, psa)) /* Validate the index given */
     return(DISP_E_BADINDEX);
@@ -353 +354 @@
     /* Figure out the number of items to skip */
     stepCountInSAData = calcDisplacement(rgIndices, psa->rgsabound, psa->cDims);
-  
+
     /* Figure out the number of byte to skip ... */
     elementStorageAddress = (char *) psa->pvData+(stepCountInSAData*psa->cbElements);
-  
+
     if( psa->fFeatures == FADF_BSTR) {           /* reallocate the obj */
-      if( (pbstrReturnedStr = 
+      if( (pbstrReturnedStr =
           SysAllocString( *(OLECHAR**)elementStorageAddress )) == NULL) {
         SafeArrayUnlock(psa);
         return E_OUTOFMEMORY;
-      } else 
-        *((BSTR*)pv) = pbstrReturnedStr; 
-        
+      } else
+        *((BSTR*)pv) = pbstrReturnedStr;
+
     } else if( isPointer(psa->fFeatures) )       /* simply copy the pointer */
-       pv = *((PVOID*)elementStorageAddress); 
+       pv = *((PVOID*)elementStorageAddress);
     else                                         /* copy the bytes */
       memcpy(pv, elementStorageAddress, SafeArrayGetElemsize(psa) );
@@ -375 +376 @@
   }
 
-  return( SafeArrayUnlock(psa) );  
-}
-
-/*************************************************************************
- *              SafeArrayGetUBound
+  return( SafeArrayUnlock(psa) );
+}
+
+/*************************************************************************
+ *      SafeArrayGetUBound
  * return the UP bound for a given array dimension
  */
 HRESULT WINAPI SafeArrayGetUBound(
-  SAFEARRAY *psa, 
+  SAFEARRAY *psa,
   UINT    nDim,
   LONG      *plUbound)
@@ -390 +391 @@
   dprintf(("SafeArrayGetUBound %x %x %x", psa, nDim, plUbound));
 
-  if(! validArg(psa))   
-    return E_INVALIDARG;
-
-  if(nDim > psa->cDims) 
+  if(! validArg(psa))
+    return E_INVALIDARG;
+
+  if(nDim > psa->cDims)
     return DISP_E_BADINDEX;
 
-  *plUbound = psa->rgsabound[nDim-1].lLbound + 
+  *plUbound = psa->rgsabound[nDim-1].lLbound +
               psa->rgsabound[nDim-1].cElements - 1;
 
@@ -403 +404 @@
 
 /*************************************************************************
- *              SafeArrayGetLBound
- * Return the LO bound for a given array dimension 
+ *      SafeArrayGetLBound
+ * Return the LO bound for a given array dimension
  */
 HRESULT WINAPI SafeArrayGetLBound(
   SAFEARRAY *psa,
-  UINT    nDim, 
+  UINT    nDim,
   LONG      *plLbound)
 {
-  if(! validArg(psa))   
-    return E_INVALIDARG;
-
-  if(nDim > psa->cDims) 
+  if(! validArg(psa))
+    return E_INVALIDARG;
+
+  if(nDim > psa->cDims)
     return DISP_E_BADINDEX;
 
@@ -422 +423 @@
 
 /*************************************************************************
- *              SafeArrayGetDim
+ *      SafeArrayGetDim
  * returns the number of dimension in the array
  */
 UINT WINAPI SafeArrayGetDim(
   SAFEARRAY * psa)
-{ 
+{
   /*
    * A quick test in Windows shows that the behavior here for an invalid
    * pointer is to return 0.
    */
-  if(! validArg(psa)) 
+  if(! validArg(psa))
     return 0;
 
@@ -439 +440 @@
 
 /*************************************************************************
- *              SafeArrayGetElemsize
+ *      SafeArrayGetElemsize
  * Return the size of the element in the array
  */
 UINT WINAPI SafeArrayGetElemsize(
   SAFEARRAY * psa)
-{ 
+{
   /*
    * A quick test in Windows shows that the behavior here for an invalid
    * pointer is to return 0.
    */
-  if(! validArg(psa)) 
+  if(! validArg(psa))
     return 0;
 
@@ -456 +457 @@
 
 /*************************************************************************
- *              SafeArrayAccessData
- * increment the access count and return the data 
+ *      SafeArrayAccessData
+ * increment the access count and return the data
  */
 HRESULT WINAPI SafeArrayAccessData(
-  SAFEARRAY *psa, 
+  SAFEARRAY *psa,
   void      **ppvData)
-{ 
+{
   HRESULT hRes;
 
-  if(! validArg(psa)) 
+  if(! validArg(psa))
     return E_INVALIDARG;
 
@@ -471 +472 @@
 
   switch (hRes) {
-    case S_OK: 
+    case S_OK:
       (*ppvData) = psa->pvData;
       break;
@@ -478 +479 @@
       return E_INVALIDARG;
   }
-  
+
   return S_OK;
 }
@@ -484 +485 @@
 
 /*************************************************************************
- *              SafeArrayUnaccessData
+ *      SafeArrayUnaccessData
  * Decrement the access count
  */
 HRESULT WINAPI SafeArrayUnaccessData(
   SAFEARRAY * psa)
-{ 
-  if(! validArg(psa)) 
+{
+  if(! validArg(psa))
     return E_INVALIDARG;
 
@@ -496 +497 @@
 }
 
-/************************************************************************ 
- *              SafeArrayPtrOfIndex
+/************************************************************************
+ *      SafeArrayPtrOfIndex
  * Return a pointer to the element at rgIndices
  */
 HRESULT WINAPI SafeArrayPtrOfIndex(
-  SAFEARRAY *psa, 
-  LONG      *rgIndices, 
+  SAFEARRAY *psa,
+  LONG      *rgIndices,
   void      **ppvData)
-{ 
-  ULONG stepCountInSAData     = 0;    /* Number of array item to skip to get to 
+{
+  ULONG stepCountInSAData     = 0;    /* Number of array item to skip to get to
                                          the desired one... */
 
-  if(! validArg(psa))                   
-    return E_INVALIDARG;
-
-  if(! validCoordinate(rgIndices, psa)) 
+  if(! validArg(psa))
+    return E_INVALIDARG;
+
+  if(! validCoordinate(rgIndices, psa))
     return DISP_E_BADINDEX;
 
   /* Figure out the number of items to skip */
   stepCountInSAData = calcDisplacement(rgIndices, psa->rgsabound, psa->cDims);
-  
+
   *ppvData = (char *) psa->pvData+(stepCountInSAData*psa->cbElements);
 
@@ -522 +523 @@
 }
 
-/************************************************************************ 
- *              SafeArrayDestroyData
+/************************************************************************
+ *      SafeArrayDestroyData
  * Frees the memory data bloc
  */
 HRESULT WINAPI SafeArrayDestroyData(
   SAFEARRAY *psa)
-{ 
+{
   HRESULT  hRes;
   ULONG    ulWholeArraySize; /* count spot in array  */
@@ -535 +536 @@
   BSTR   bstr;
 
-  if(! validArg(psa)) 
-    return E_INVALIDARG;
-
-  if(psa->cLocks > 0) 
+  if(! validArg(psa))
+    return E_INVALIDARG;
+
+  if(psa->cLocks > 0)
     return DISP_E_ARRAYISLOCKED;
 
@@ -546 +547 @@
 
     for(ulDataIter=0; ulDataIter < ulWholeArraySize; ulDataIter++) {
-      punk = *(IUnknown**)((char *) psa->pvData+(ulDataIter*(psa->cbElements)));        
-
-      if( punk != NULL) 
+      punk = *(IUnknown**)((char *) psa->pvData+(ulDataIter*(psa->cbElements)));
+
+      if( punk != NULL)
         IUnknown_Release(punk);
     }
@@ -557 +558 @@
       bstr = *(BSTR*)((char *) psa->pvData+(ulDataIter*(psa->cbElements)));
 
-      if( bstr != NULL) 
+      if( bstr != NULL)
         SysFreeString( bstr );
     }
   }
-      
-  /* check if this array is a Vector, in which case do not free the data 
+
+  /* check if this array is a Vector, in which case do not free the data
      block since it has been allocated by AllocDescriptor and therefore
      deserve to be freed by DestroyDescriptor */
@@ -573 +574 @@
     psa->pvData = NULL;
   }
-  
+
   return S_OK;
 }
 
-/************************************************************************ 
- *              SafeArrayCopyData
+/************************************************************************
+ *      SafeArrayCopyData
  * Copy the psaSource's data block into psaTarget if dimension and size
  * permits it.
@@ -585 +586 @@
   SAFEARRAY *psaSource,
   SAFEARRAY **psaTarget)
-{ 
+{
   USHORT   cDimCount;        /* looper */
   LONG     lDelta;           /* looper */
-  IUnknown *punk;   
+  IUnknown *punk;
   ULONG    ulWholeArraySize; /* Number of item in SA */
   BSTR   bstr;
 
-  if(! (validArg(psaSource) && validArg(*psaTarget)) ) 
+  if(! (validArg(psaSource) && validArg(*psaTarget)) )
     return E_INVALIDARG;
 
@@ -598 +599 @@
     return E_INVALIDARG;
 
-  ulWholeArraySize = getArraySize(psaSource); 
+  ulWholeArraySize = getArraySize(psaSource);
 
   /* The two arrays boundaries must be of same lenght */
   for(cDimCount=0;cDimCount < psaSource->cDims; cDimCount++)
-    if( psaSource->rgsabound[cDimCount].cElements != 
+    if( psaSource->rgsabound[cDimCount].cElements !=
       (*psaTarget)->rgsabound[cDimCount].cElements)
       return E_INVALIDARG;
 
-  if( isPointer((*psaTarget)->fFeatures) ) {         /* the target contains ptr 
+  if( isPointer((*psaTarget)->fFeatures) ) {         /* the target contains ptr
                                                         that must be released */
     for(lDelta=0;lDelta < ulWholeArraySize; lDelta++) {
@@ -612 +613 @@
         ((char *) (*psaTarget)->pvData + (lDelta * (*psaTarget)->cbElements));
 
-      if( punk != NULL) 
+      if( punk != NULL)
         IUnknown_Release(punk);
     }
 
   } else if( (*psaTarget)->fFeatures & FADF_BSTR) {  /* the target contain BSTR
-                                                        that must be freed */ 
+                                                        that must be freed */
     for(lDelta=0;lDelta < ulWholeArraySize; lDelta++) {
-      bstr = 
+      bstr =
         *(BSTR*)((char *) (*psaTarget)->pvData + (lDelta * (*psaTarget)->cbElements));
 
-      if( bstr != NULL) 
+      if( bstr != NULL)
         SysFreeString( bstr );
     }
@@ -630 +631 @@
 }
 
-/************************************************************************ 
- *              SafeArrayDestroy
+/************************************************************************
+ *      SafeArrayDestroy
  * Deallocates all memory reserved for the SafeArray
  */
 HRESULT WINAPI SafeArrayDestroy(
   SAFEARRAY * psa)
-{ 
+{
   HRESULT hRes;
 
-  if(! validArg(psa)) 
-    return E_INVALIDARG;
-
-  if(psa->cLocks > 0) 
+  if(! validArg(psa))
+    return E_INVALIDARG;
+
+  if(psa->cLocks > 0)
     return DISP_E_ARRAYISLOCKED;
 
@@ -652 +653 @@
 }
 
-/************************************************************************ 
- *              SafeArrayCopy
+/************************************************************************
+ *      SafeArrayCopy
  * Make a dupplicate of a SafeArray
  */
 HRESULT WINAPI SafeArrayCopy(
-  SAFEARRAY *psa, 
+  SAFEARRAY *psa,
   SAFEARRAY **ppsaOut)
-{ 
+{
   HRESULT hRes;
   DWORD   dAllocSize;
   ULONG   ulWholeArraySize; /* size of the thing */
 
-  if(! validArg(psa)) 
+  if(! validArg(psa))
     return E_INVALIDARG;
 
@@ -670 +671 @@
 
     /* Duplicate the SAFEARRAY struc */
-    memcpy(*ppsaOut, psa, 
+    memcpy(*ppsaOut, psa,
             sizeof(*psa)+(sizeof(*(psa->rgsabound))*(psa->cDims-1)));
 
@@ -677 +678 @@
     /* make sure the new safe array doesn't have the FADF_CREATEVECTOR flag,
        because the data has not been allocated with the descriptor. */
-    (*ppsaOut)->fFeatures &= ~FADF_CREATEVECTOR;  
- 
-    /* Get the allocated memory size for source and allocate it for target */ 
+    (*ppsaOut)->fFeatures &= ~FADF_CREATEVECTOR;
+
+    /* Get the allocated memory size for source and allocate it for target */
     ulWholeArraySize = getArraySize(psa); /* Number of item in SA */
     dAllocSize = ulWholeArraySize*psa->cbElements;
 
-    (*ppsaOut)->pvData = 
+    (*ppsaOut)->pvData =
       HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dAllocSize);
     if( (*ppsaOut)->pvData != NULL) {   /* HeapAlloc succeed */
@@ -693 +694 @@
         return hRes;
       }
-        
+
     } else { /* failed to allocate or dupplicate... */
       SafeArrayDestroyDescriptor(*ppsaOut);
@@ -705 +706 @@
 }
 
-/************************************************************************ 
- *              SafeArrayCreateVector
- * Creates a one dimension safearray where the data is next to the 
+/************************************************************************
+ *      SafeArrayCreateVector
+ * Creates a one dimension safearray where the data is next to the
  * SAFEARRAY structure.
  */
 SAFEARRAY* WINAPI SafeArrayCreateVector(
-  VARTYPE vt, 
-  LONG    lLbound, 
-  ULONG   cElements) 
-{ 
+  VARTYPE vt,
+  LONG    lLbound,
+  ULONG   cElements)
+{
   SAFEARRAY *psa;
 
@@ -723 +724 @@
 
   /* Allocate memory for the array descriptor and data contiguously  */
-  if( FAILED( psa = HeapAlloc( GetProcessHeap(), 
-                      HEAP_ZERO_MEMORY, 
+  if( FAILED( psa = HeapAlloc( GetProcessHeap(),
+                      HEAP_ZERO_MEMORY,
                       (sizeof(*psa) + (VARTYPE_SIZE[vt] * cElements))))) {
     return NULL;
   }
-                                                                                
-  /* setup data members... */ 
+
+  /* setup data members... */
   psa->cDims      = 1; /* always and forever */
   psa->fFeatures  = getFeatures(vt) | FADF_CREATEVECTOR;  /* undocumented flag used by Microsoft */
@@ -739 +740 @@
   psa->rgsabound[0].lLbound   = lLbound;
 
-  return(psa);                            
-} 
-
-/************************************************************************ 
- *              SafeArrayRedim
+  return(psa);
+}
+
+/************************************************************************
+ *      SafeArrayRedim
  * Changes the caracteristics of the last dimension of the SafeArray
  */
 HRESULT WINAPI SafeArrayRedim(
-  SAFEARRAY      *psa, 
+  SAFEARRAY      *psa,
   SAFEARRAYBOUND *psaboundNew)
-{ 
+{
   LONG   lDelta;  /* hold difference in size */
   USHORT cDims=1; /* dims counter */
 
-  if( !validArg(psa) )                    
-    return E_INVALIDARG;
-
-  if( psa->cLocks > 0 )                    
+  if( !validArg(psa) )
+    return E_INVALIDARG;
+
+  if( psa->cLocks > 0 )
     return DISP_E_ARRAYISLOCKED;
 
-  if( psa->fFeatures & FADF_FIXEDSIZE )    
-    return E_INVALIDARG;
-
-  if( SafeArrayLock(psa)==E_UNEXPECTED ) 
+  if( psa->fFeatures & FADF_FIXEDSIZE )
+    return E_INVALIDARG;
+
+  if( SafeArrayLock(psa)==E_UNEXPECTED )
     return E_UNEXPECTED;/* UNDOC error condition */
 
@@ -774 +775 @@
 
   } else /* need to enlarge (lDelta +) reduce (lDelta -) */
-    if(! resizeSafeArray(psa, lDelta)) 
+    if(! resizeSafeArray(psa, lDelta))
       return E_UNEXPECTED; /* UNDOC error condition */
 
-  /* the only modifyable dimension sits in [0] as the dimensions were reversed  
+  /* the only modifyable dimension sits in [0] as the dimensions were reversed
      at array creation time... */
   psa->rgsabound[0].cElements = psaboundNew->cElements;
@@ -789 +790 @@
  ************************************************************************/
 
-/************************************************************************ 
+/************************************************************************
  * Used to validate the SAFEARRAY type of arg
  */
 static BOOL validArg(
-  SAFEARRAY *psa) 
+  SAFEARRAY *psa)
 {
   SAFEARRAYBOUND *sab;
@@ -822 +823 @@
 }
 
-/************************************************************************ 
+/************************************************************************
  * Used to reallocate memory
  */
 static BOOL resizeSafeArray(
-  SAFEARRAY *psa, 
+  SAFEARRAY *psa,
   LONG lDelta)
 {
   ULONG    ulWholeArraySize;  /* use as multiplicator */
-  PVOID    pvNewBlock = NULL;  
+  PVOID    pvNewBlock = NULL;
   IUnknown *punk;
   BSTR   bstr;
@@ -838 +839 @@
   if(lDelta < 0) {                    /* array needs to be shorthen  */
     if( isPointer(psa->fFeatures))    /* ptr that need to be released */
-            for(;lDelta < 0; lDelta++) {
-              punk = *(IUnknown**)
+        for(;lDelta < 0; lDelta++) {
+          punk = *(IUnknown**)
           ((char *) psa->pvData+((ulWholeArraySize+lDelta)*psa->cbElements));
-        
+
         if( punk != NULL )
           IUnknown_Release(punk);
-            }
+        }
 
     else if(psa->fFeatures & FADF_BSTR)  /* BSTR that need to be freed */
-            for(;lDelta < 0; lDelta++) {
+        for(;lDelta < 0; lDelta++) {
         bstr = *(BSTR*)
           ((char *) psa->pvData+((ulWholeArraySize+lDelta)*psa->cbElements));
@@ -858 +859 @@
   if (!(psa->fFeatures & FADF_CREATEVECTOR))
   {
-    /* Ok now, if we are enlarging the array, we *MUST* move the whole block 
+    /* Ok now, if we are enlarging the array, we *MUST* move the whole block
        pointed to by pvData.   If we are shorthening the array, this move is
-       optional but we do it anyway becuase the benefit is that we are 
+       optional but we do it anyway becuase the benefit is that we are
        releasing to the system the unused memory */
 
-    if((pvNewBlock = HeapReAlloc(GetProcessHeap(), 0, psa->pvData, 
-       (ulWholeArraySize + lDelta) * psa->cbElements)) == NULL) 
+    if((pvNewBlock = HeapReAlloc(GetProcessHeap(), 0, psa->pvData,
+       (ulWholeArraySize + lDelta) * psa->cbElements)) == NULL)
         return FALSE; /* TODO If we get here it means:
                          SHRINK situation :  we've deleted the undesired
@@ -873 +874 @@
   else
   {
-    /* Allocate a new block, because the previous data has been allocated with 
+    /* Allocate a new block, because the previous data has been allocated with
        the descriptor in SafeArrayCreateVector function. */
 
     if((pvNewBlock = HeapAlloc(GetProcessHeap(), 0,
-       ulWholeArraySize * psa->cbElements)) == NULL) 
+       ulWholeArraySize * psa->cbElements)) == NULL)
         return FALSE;
 
@@ -887 +888 @@
 }
 
-/************************************************************************ 
- * Used to set the fFeatures data member of the SAFEARRAY structure. 
+/************************************************************************
+ * Used to set the fFeatures data member of the SAFEARRAY structure.
  */
 static INT getFeatures(
-  VARTYPE vt) 
+  VARTYPE vt)
 {
   switch(vt) {
@@ -901 +902 @@
 }
 
-/************************************************************************ 
- * Used to figure out if the fFeatures data member of the SAFEARRAY 
- * structure contain any information about the type of data stored... 
+/************************************************************************
+ * Used to figure out if the fFeatures data member of the SAFEARRAY
+ * structure contain any information about the type of data stored...
  */
 static BOOL isPointer(
-  USHORT feature) 
+  USHORT feature)
 {
   switch(feature) {
@@ -915 +916 @@
 }
 
-/************************************************************************ 
- * Used to calculate the displacement when accessing or modifying 
+/************************************************************************
+ * Used to calculate the displacement when accessing or modifying
  * safearray data set.
  *
@@ -926 +927 @@
  */
 static ULONG calcDisplacement(
-  LONG           *coor, 
-  SAFEARRAYBOUND *mat, 
-  LONG           dim) 
+  LONG           *coor,
+  SAFEARRAYBOUND *mat,
+  LONG           dim)
 {
   ULONG res = 0;
   LONG  iterDim;
 
-  for(iterDim=0; iterDim<dim; iterDim++) 
+  for(iterDim=0; iterDim<dim; iterDim++)
     /* the -mat[dim] bring coor[dim] relative to 0 for calculation */
-    res += ((coor[iterDim]-mat[iterDim].lLbound) * 
+    res += ((coor[iterDim]-mat[iterDim].lLbound) *
             endOfDim(coor, mat, iterDim+1, dim));
 
@@ -942 +943 @@
 }
 
-/************************************************************************ 
- * Recursivity agent for calcDisplacement method.  Used within Put and 
+/************************************************************************
+ * Recursivity agent for calcDisplacement method.  Used within Put and
  * Get methods.
  */
 static INT endOfDim(
-  LONG           *coor, 
-  SAFEARRAYBOUND *mat, 
-  LONG           dim, 
-  LONG           realDim) 
-{
-  if(dim==realDim) 
+  LONG           *coor,
+  SAFEARRAYBOUND *mat,
+  LONG           dim,
+  LONG           realDim)
+{
+  if(dim==realDim)
     return 1;
-  else 
+  else
     return (endOfDim(coor, mat, dim+1, realDim) * mat[dim].cElements);
 }
 
 
-/************************************************************************ 
- * Method used to validate the coordinate received in Put and Get 
+/************************************************************************
+ * Method used to validate the coordinate received in Put and Get
  * methods.
  */
 static BOOL validCoordinate(
-  LONG      *coor, 
-  SAFEARRAY *psa) 
+  LONG      *coor,
+  SAFEARRAY *psa)
 {
   INT   iter=0;
@@ -977 +978 @@
     if((hRes = SafeArrayGetUBound(psa, iter, &lUBound)) != S_OK)
       return FALSE;
- 
-    if(lLBound == lUBound) 
-      return FALSE; 
-   
+
+    if(lLBound == lUBound)
+      return FALSE;
+
     if((coor[iter] >= lLBound) && (coor[iter] <= lUBound))
       return TRUE;
@@ -987 +988 @@
   }
   return FALSE;
-}  
-
-/************************************************************************ 
+}
+
+/************************************************************************
  * Method used to calculate the number of cells of the SA
  */
 static ULONG getArraySize(
-  SAFEARRAY *psa) 
-{
-  USHORT cCount; 
+  SAFEARRAY *psa)
+{
+  USHORT cCount;
   ULONG  ulWholeArraySize = 1;
 
@@ -1001 +1002 @@
     ulWholeArraySize *= psa->rgsabound[cCount].cElements;
 
-  return ulWholeArraySize;  
-}
-
-
-/************************************************************************ 
+  return ulWholeArraySize;
+}
+
+
+/************************************************************************
  * Method used to handle data space dupplication for Copy32 and CopyData32
  */
 static HRESULT duplicateData(
-  SAFEARRAY *psa, 
-  SAFEARRAY **ppsaOut) 
+  SAFEARRAY *psa,
+  SAFEARRAY **ppsaOut)
 {
   ULONG    ulWholeArraySize; /* size of the thing */
@@ -1018 +1019 @@
 
   ulWholeArraySize = getArraySize(psa); /* Number of item in SA */
-  
+
   SafeArrayLock(*ppsaOut);
 
-  if( isPointer(psa->fFeatures) ) {  /* If datatype is object increment 
+  if( isPointer(psa->fFeatures) ) {  /* If datatype is object increment
                                         object's reference count */
 
@@ -1032 +1033 @@
 
     /* Copy the source array data into target array */
-    memcpy((*ppsaOut)->pvData, psa->pvData, 
+    memcpy((*ppsaOut)->pvData, psa->pvData,
       ulWholeArraySize*psa->cbElements);
 
-  } else if( psa->fFeatures & FADF_BSTR ) { /* if datatype is BSTR allocate 
+  } else if( psa->fFeatures & FADF_BSTR ) { /* if datatype is BSTR allocate
                                                the BSTR in the new array */
 
@@ -1046 +1047 @@
       }
 
-      *((BSTR*)((char *) (*ppsaOut)->pvData+(lDelta * psa->cbElements))) = 
+      *((BSTR*)((char *) (*ppsaOut)->pvData+(lDelta * psa->cbElements))) =
         pbstrReAllocStr;
     }
@@ -1052 +1053 @@
   } else { /* Simply copy the source array data into target array */
 
-    memcpy((*ppsaOut)->pvData, psa->pvData, 
+    memcpy((*ppsaOut)->pvData, psa->pvData,
       ulWholeArraySize*psa->cbElements);
   }
@@ -1062 +1063 @@
 
 
-/************************************************************************ 
- *              SafeArrayGetVarType
+/************************************************************************
+ *      SafeArrayGetVarType
  * Returns the VARTYPE stored in the given safearray
  */
@@ -1099 +1100 @@
     hr = S_OK;
   }
-  
+
   TRACE("HRESULT = %08lx", hr);
   return hr;

trunk/src/oleaut32/typelib.c

@@ +1 @@
+/* $Id: typelib.c,v 1.6 2001-09-05 13:19:01 bird Exp $ */
 /*
- *      TYPELIB
- *
- *      Copyright 1997  Marcus Meissner
- *                    1999  Rein Klazes
- *                    2000  Francois Jacques
+ *  TYPELIB
+ *
+ *  Copyright 1997  Marcus Meissner
+ *            1999  Rein Klazes
+ *            2000  Francois Jacques
  * --------------------------------------------------------------------------------------
  * Known problems (2000, Francois Jacques)
  *
  * - Tested using OLEVIEW (Platform SDK tool) only.
- *   
- * - dual interface dispinterfaces. vtable-interface ITypeInfo instances are 
- *   creating by doing a straight copy of the dispinterface instance and just changing 
+ *
+ * - dual interface dispinterfaces. vtable-interface ITypeInfo instances are
+ *   creating by doing a straight copy of the dispinterface instance and just changing
  *   its typekind. Pointed structures aren't copied - only the address of the pointers.
  *   So when you release the dispinterface, you delete the vtable-interface structures
  *   as well... fortunately, clean up of structures is not implemented.
- * 
+ *
  * - locale stuff is partially implemented but hasn't been tested.
  *
@@ -39 +40 @@
  * -. some methods just return pointers to internal data structures, this is
  *      partly laziness, partly I want to check how windows does it.
- * 
+ *
  */
 #ifdef __WIN32OS2__
@@ -84 +85 @@
 #ifndef __WIN32OS2__
 /****************************************************************************
- *              QueryPathOfRegTypeLib   [TYPELIB.14]
+ *      QueryPathOfRegTypeLib   [TYPELIB.14]
  *
  * the path is "Classes\Typelib\<guid>\<major>.<minor>\<lcid>\win16\"
  * RETURNS
- *      path of typelib
+ *  path of typelib
  */
 HRESULT WINAPI
-QueryPathOfRegTypeLib16(        
-        REFGUID guid,   /* [in] referenced guid */
-        WORD wMaj,      /* [in] major version */
-        WORD wMin,      /* [in] minor version */
-        LCID lcid,      /* [in] locale id */
-        LPBSTR16 path   /* [out] path of typelib */
+QueryPathOfRegTypeLib16(
+    REFGUID guid,   /* [in] referenced guid */
+    WORD wMaj,  /* [in] major version */
+    WORD wMin,  /* [in] minor version */
+    LCID lcid,  /* [in] locale id */
+    LPBSTR16 path   /* [out] path of typelib */
 ) {
-        char    xguid[80];
-        char    typelibkey[100],pathname[260];
-        DWORD   plen;
-
-        TRACE("\n");
-
-        if (HIWORD(guid)) {
+    char    xguid[80];
+    char    typelibkey[100],pathname[260];
+    DWORD   plen;
+
+        TRACE("\n");
+
+    if (HIWORD(guid)) {
             sprintf( typelibkey, "SOFTWARE\\Classes\\Typelib\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\%d.%d\\%lx\\win16",
                      guid->Data1, guid->Data2, guid->Data3,
@@ -110 +111 @@
                      guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7],
                      wMaj,wMin,lcid);
-        } else {
-                sprintf(xguid,"<guid 0x%08lx>",(DWORD)guid);
-                FIXME("(%s,%d,%d,0x%04lx,%p),can't handle non-string guids.\n",xguid,wMaj,wMin,(DWORD)lcid,path);
-                return E_FAIL;
-        }
-        plen = sizeof(pathname);
-        if (RegQueryValueA(HKEY_LOCAL_MACHINE,typelibkey,pathname,&plen)) {
-                /* try again without lang specific id */
-                if (SUBLANGID(lcid))
-                        return QueryPathOfRegTypeLib16(guid,wMaj,wMin,PRIMARYLANGID(lcid),path);
-                FIXME("key %s not found\n",typelibkey);
-                return E_FAIL;
-        }
-        *path = SysAllocString16(pathname);
-        return S_OK;
+    } else {
+        sprintf(xguid,"<guid 0x%08lx>",(DWORD)guid);
+        FIXME("(%s,%d,%d,0x%04lx,%p),can't handle non-string guids.\n",xguid,wMaj,wMin,(DWORD)lcid,path);
+        return E_FAIL;
+    }
+    plen = sizeof(pathname);
+    if (RegQueryValueA(HKEY_LOCAL_MACHINE,typelibkey,pathname,&plen)) {
+        /* try again without lang specific id */
+        if (SUBLANGID(lcid))
+            return QueryPathOfRegTypeLib16(guid,wMaj,wMin,PRIMARYLANGID(lcid),path);
+        FIXME("key %s not found\n",typelibkey);
+        return E_FAIL;
+    }
+    *path = SysAllocString16(pathname);
+    return S_OK;
 }
 #endif
- 
+
 /****************************************************************************
- *              QueryPathOfRegTypeLib   [OLEAUT32.164]
+ *      QueryPathOfRegTypeLib   [OLEAUT32.164]
  * RETURNS
- *      path of typelib
+ *  path of typelib
  */
 HRESULT WINAPI
-QueryPathOfRegTypeLib(  
-        REFGUID guid,   /* [in] referenced guid */
-        WORD wMaj,      /* [in] major version */
-        WORD wMin,      /* [in] minor version */
-        LCID lcid,      /* [in] locale id */
-        LPBSTR path )   /* [out] path of typelib */
+QueryPathOfRegTypeLib(
+    REFGUID guid,   /* [in] referenced guid */
+    WORD wMaj,  /* [in] major version */
+    WORD wMin,  /* [in] minor version */
+    LCID lcid,  /* [in] locale id */
+    LPBSTR path )   /* [out] path of typelib */
 {
     /* don't need to ZeroMemory those arrays since sprintf and RegQueryValue add
@@ -171 +172 @@
             "SOFTWARE\\Classes\\Typelib\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\%d.%d\\%lx\\win32",
             guid->Data1,    guid->Data2,    guid->Data3,
-            guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3], 
+            guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
             guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7],
             wMaj,
@@ -211 +212 @@
         }
     }
-        
+
     if (hr != S_OK)
-                TRACE_(typelib)("%s not found\n", szTypeLibKey);
-        
+        TRACE_(typelib)("%s not found\n", szTypeLibKey);
+
     return hr;
 }
@@ -226 +227 @@
  */
 HRESULT WINAPI CreateTypeLib(
-        SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib** ppctlib
+    SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib** ppctlib
 ) {
     FIXME("(%d,%s,%p), stub!\n",syskind,debugstr_w(szFile),ppctlib);
@@ -256 +257 @@
 
 /******************************************************************************
- *              LoadTypeLib     [OLEAUT32.161]
+ *      LoadTypeLib [OLEAUT32.161]
  * Loads and registers a type library
  * NOTES
@@ -277 +278 @@
 
 /******************************************************************************
- *              LoadTypeLibEx   [OLEAUT32.183]
+ *      LoadTypeLibEx   [OLEAUT32.183]
  * Loads and optionally registers a type library
  *
@@ -292 +293 @@
     HRESULT res;
     TRACE("(%s,%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
-    
+
     p=HEAP_strdupWtoA(GetProcessHeap(),0,szFile);
-    
+
     res= TLB_ReadTypeLib(p, (ITypeLib2**)pptLib);
 
@@ -323 +324 @@
 
 /******************************************************************************
- *              LoadRegTypeLib  [OLEAUT32.162]
- */
-HRESULT WINAPI LoadRegTypeLib(  
-        REFGUID rguid,          /* [in] referenced guid */
-        WORD wVerMajor,         /* [in] major version */
-        WORD wVerMinor,         /* [in] minor version */
-        LCID lcid,              /* [in] locale id */
-        ITypeLib **ppTLib)      /* [out] path of typelib */
+ *      LoadRegTypeLib  [OLEAUT32.162]
+ */
+HRESULT WINAPI LoadRegTypeLib(
+    REFGUID rguid,      /* [in] referenced guid */
+    WORD wVerMajor,     /* [in] major version */
+    WORD wVerMinor,     /* [in] minor version */
+    LCID lcid,      /* [in] locale id */
+    ITypeLib **ppTLib)  /* [out] path of typelib */
 {
     BSTR bstr=NULL;
@@ -344 +345 @@
 
     return res;
-}       
+}
 
 
 /******************************************************************************
- *              RegisterTypeLib [OLEAUT32.163]
- * Adds information about a type library to the System Registry           
+ *      RegisterTypeLib [OLEAUT32.163]
+ * Adds information about a type library to the System Registry
  * NOTES
  *    Docs: ITypeLib FAR * ptlib
@@ -363 +364 @@
      OLECHAR * szFullPath, /* [in] full Path of the library*/
      OLECHAR * szHelpDir)  /* [in] dir to the helpfile for the library,
-                                                         may be NULL*/
+                             may be NULL*/
 {
     HRESULT res;
@@ -444 +445 @@
 
 /******************************************************************************
- *      UnRegisterTypeLib       [OLEAUT32.186]
- * Removes information about a type library from the System Registry           
+ *  UnRegisterTypeLib   [OLEAUT32.186]
+ * Removes information about a type library from the System Registry
  * NOTES
  *
@@ -453 +454 @@
  */
 HRESULT WINAPI UnRegisterTypeLib(
-    REFGUID libid,      /* [in] Guid of the library */
-        WORD wVerMajor, /* [in] major version */
-        WORD wVerMinor, /* [in] minor version */
-        LCID lcid,      /* [in] locale id */
-        SYSKIND syskind)
-{   
+    REFGUID libid,  /* [in] Guid of the library */
+    WORD wVerMajor, /* [in] major version */
+    WORD wVerMinor, /* [in] minor version */
+    LCID lcid,  /* [in] locale id */
+    SYSKIND syskind)
+{
     TRACE("(IID: %s): stub\n",debugstr_guid(libid));
-    return S_OK;        /* FIXME: pretend everything is OK */
+    return S_OK;    /* FIXME: pretend everything is OK */
 }
 
 #ifndef __WIN32OS2__
 /****************************************************************************
- *      OaBuildVersion                          (TYPELIB.15)
+ *  OaBuildVersion              (TYPELIB.15)
  *
  * known TYPELIB.DLL versions:
  *
- * OLE 2.01 no OaBuildVersion() avail   1993    --      ---
- * OLE 2.02                             1993-94 02     3002
- * OLE 2.03                                     23      730
- * OLE 2.03                                     03     3025
- * OLE 2.03 W98 SE orig. file !!        1993-95 10     3024
- * OLE 2.1   NT                         1993-95 ??      ???
- * OLE 2.3.1 W95                                23      700
- * OLE2 4.0  NT4SP6                     1993-98 40     4277
+ * OLE 2.01 no OaBuildVersion() avail   1993    --  ---
+ * OLE 2.02             1993-94 02     3002
+ * OLE 2.03                 23  730
+ * OLE 2.03                 03     3025
+ * OLE 2.03 W98 SE orig. file !!    1993-95 10     3024
+ * OLE 2.1   NT             1993-95 ??  ???
+ * OLE 2.3.1 W95                23  700
+ * OLE2 4.0  NT4SP6         1993-98 40     4277
  */
 DWORD WINAPI OaBuildVersion16(void)
@@ -488 +489 @@
     {
     case 0x80000a03:  /* WIN31 */
-                return MAKELONG(3027, 3); /* WfW 3.11 */
+        return MAKELONG(3027, 3); /* WfW 3.11 */
     case 0x80000004:  /* WIN95 */
-                return MAKELONG(700, 23); /* Win95A */
+        return MAKELONG(700, 23); /* Win95A */
     case 0x80000a04:  /* WIN98 */
-                return MAKELONG(3024, 10); /* W98 SE */
+        return MAKELONG(3024, 10); /* W98 SE */
     case 0x00000004:  /* NT4 */
-                return MAKELONG(4277, 40); /* NT4 SP6 */
+        return MAKELONG(4277, 40); /* NT4 SP6 */
     default:
-        FIXME("Version value not known yet. Please investigate it!\n");
-                return 0;
+    FIXME("Version value not known yet. Please investigate it!\n");
+        return 0;
     }
 }
@@ -507 +508 @@
 /*======================= ITypeLib implementation =======================*/
 
-typedef struct tagTLBCustData 
+typedef struct tagTLBCustData
 {
     GUID guid;
@@ -521 +522 @@
     BSTR name;                  /* name; */
 
-        LCID lcid;                                      /* lcid of imported typelib */
-
-        WORD wVersionMajor;         /* major version number */
+    LCID lcid;                  /* lcid of imported typelib */
+
+    WORD wVersionMajor;         /* major version number */
     WORD wVersionMinor;         /* minor version number */
 
@@ -536 +537 @@
     UINT ref;
     TLIBATTR LibAttr;            /* guid,lcid,syskind,version,flags */
-    
+
     /* strings can be stored in tlb as multibyte strings BUT they are *always*
-         * exported to the application as a UNICODE string.
-         */
-        BSTR Name;
+     * exported to the application as a UNICODE string.
+     */
+    BSTR Name;
     BSTR DocString;
     BSTR HelpFile;
@@ -579 +580 @@
     int ctCustData;
     TLBCustData * pCustData;        /* linked list to cust data; */
-        TLBRefType * pRefType;                  /* linked list to referenced types */
+    TLBRefType * pRefType;          /* linked list to referenced types */
 } TLBParDesc;
 
@@ -594 +595 @@
     int ctCustData;
     TLBCustData * pCustData;        /* linked list to cust data; */
-    struct tagTLBFuncDesc * next; 
+    struct tagTLBFuncDesc * next;
 } TLBFuncDesc;
 
@@ -607 +608 @@
     int ctCustData;
     TLBCustData * pCustData;/* linked list to cust data; */
-    struct tagTLBVarDesc * next; 
+    struct tagTLBVarDesc * next;
 } TLBVarDesc;
 
@@ -618 +619 @@
     ITypeLibImpl * pTypeLib;        /* back pointer to typelib */
     int index;                  /* index in this typelib; */
-    /* type libs seem to store the doc strings in ascii 
+    /* type libs seem to store the doc strings in ascii
      * so why should we do it in unicode?
      */
@@ -633 +634 @@
 
     /* Implemented Interfaces  */
-    TLBRefType * impltypelist;      
+    TLBRefType * impltypelist;
     int ctCustData;
     TLBCustData * pCustData;        /* linked list to cust data; */
@@ -645 +646 @@
 typedef struct tagTLBContext
 {
-        unsigned int oStart;  /* start of TLB in file */
-        unsigned int pos;     /* current pos */
-        unsigned int length;  /* total length */
-        void *mapping;        /* memory mapping */
-        TLBSegDir * pTblDir;
-        ITypeLibImpl* pLibInfo;
+    unsigned int oStart;  /* start of TLB in file */
+    unsigned int pos;     /* current pos */
+    unsigned int length;  /* total length */
+    void *mapping;        /* memory mapping */
+    TLBSegDir * pTblDir;
+    ITypeLibImpl* pLibInfo;
 } TLBContext;
 
@@ -744 +745 @@
 static void dump_TLBFuncDesc(TLBFuncDesc * pfd)
 {
-        while (pfd)
-        {
-          dump_TLBFuncDescOne(pfd);
-          pfd = pfd->next;
-        };
+    while (pfd)
+    {
+      dump_TLBFuncDescOne(pfd);
+      pfd = pfd->next;
+    };
 }
 static void dump_TLBVarDesc(TLBVarDesc * pvd)
 {
-        while (pvd)
-        {
-          TRACE_(typelib)("%s\n", debugstr_w(pvd->Name));
-          pvd = pvd->next;
-        };
+    while (pvd)
+    {
+      TRACE_(typelib)("%s\n", debugstr_w(pvd->Name));
+      pvd = pvd->next;
+    };
 }
 static void dump_TLBRefType(TLBRefType * prt)
 {
-        while (prt)
-        {
-          TRACE_(typelib)("%s\n", debugstr_guid(&(prt->guid)));
-          TRACE_(typelib)("  href:0x%08lx\n", prt->reference);
-          prt = prt->next;
-        };
+    while (prt)
+    {
+      TRACE_(typelib)("%s\n", debugstr_guid(&(prt->guid)));
+      TRACE_(typelib)("  href:0x%08lx\n", prt->reference);
+      prt = prt->next;
+    };
 }
 
@@ -771 +772 @@
 {
     char szVarType[15];
-    
+
     TRACE("(%p)\n", pvar);
- 
+
     if (!pvar)  return;
- 
+
     ZeroMemory(szVarType, sizeof(szVarType));
-               
+
     /* FIXME : we could have better trace here, depending on the VARTYPE
      * of the variant
@@ -784 +785 @@
 
     TRACE("VARTYPE: %s\n", szVarType);
-    
+
     switch (V_VT(pvar))
     {
@@ -790 +791 @@
             TRACE("%3.3e\n", V_UNION(pvar, fltVal));
             break;
-            
+
         case VT_R8:
             TRACE("%3.3e\n", V_UNION(pvar, dblVal));
             break;
-            
+
         default:
             TRACE("%ld\n", V_UNION(pvar, lVal));
             break;
-    }       
+    }
 
     if (V_VT(pvar) & VT_BYREF)
@@ -807 +808 @@
 {
     int index = 0;
-    
+
     TRACE("args=%u named args=%u\n", pdp->cArgs, pdp->cNamedArgs);
 
@@ -819 +820 @@
 static char * typekind_desc[] =
 {
-        "TKIND_ENUM",
-        "TKIND_RECORD",
-        "TKIND_MODULE",
-        "TKIND_INTERFACE",
-        "TKIND_DISPATCH",
-        "TKIND_COCLASS",
-        "TKIND_ALIAS",
-        "TKIND_UNION",
-        "TKIND_MAX"
+    "TKIND_ENUM",
+    "TKIND_RECORD",
+    "TKIND_MODULE",
+    "TKIND_INTERFACE",
+    "TKIND_DISPATCH",
+    "TKIND_COCLASS",
+    "TKIND_ALIAS",
+    "TKIND_UNION",
+    "TKIND_MAX"
 };
 
@@ -846 +847 @@
 static char * typekind_desc[] =
 {
-        "TKIND_ENUM",
-        "TKIND_RECORD",
-        "TKIND_MODULE",
-        "TKIND_INTERFACE",
-        "TKIND_DISPATCH",
-        "TKIND_COCLASS",
-        "TKIND_ALIAS",
-        "TKIND_UNION",
-        "TKIND_MAX"
+    "TKIND_ENUM",
+    "TKIND_RECORD",
+    "TKIND_MODULE",
+    "TKIND_INTERFACE",
+    "TKIND_DISPATCH",
+    "TKIND_COCLASS",
+    "TKIND_ALIAS",
+    "TKIND_UNION",
+    "TKIND_MAX"
 };
 #define  dump_TypeInfo(a)
@@ -936 +937 @@
 
     TLB_Read(&niName, sizeof(niName), pcx,
-                                pcx->pTblDir->pNametab.offset+offset);
+                pcx->pTblDir->pNametab.offset+offset);
     niName.namelen &= 0xFF; /* FIXME: correct ? */
     name=TLB_Alloc((niName.namelen & 0xff) +1);
@@ -996 +997 @@
 }
 /*
- * read a value and fill a VARIANT structure 
+ * read a value and fill a VARIANT structure
  */
 static void TLB_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
@@ -1009 +1010 @@
         return;
     }
-    TLB_Read(&(V_VT(pVar)), sizeof(VARTYPE), pcx, 
+    TLB_Read(&(V_VT(pVar)), sizeof(VARTYPE), pcx,
         pcx->pTblDir->pCustData.offset + offset );
     TRACE_(typelib)("Vartype = %x\n", V_VT(pVar));
@@ -1018 +1019 @@
         case VT_I4  :
         case VT_R4  :
-        case VT_ERROR   : 
-        case VT_BOOL    : 
-        case VT_I1  : 
-        case VT_UI1 : 
-        case VT_UI2 : 
-        case VT_UI4 : 
-        case VT_INT : 
-        case VT_UINT    : 
+        case VT_ERROR   :
+        case VT_BOOL    :
+        case VT_I1  :
+        case VT_UI1 :
+        case VT_UI2 :
+        case VT_UI4 :
+        case VT_INT :
+        case VT_UINT    :
         case VT_VOID    : /* FIXME: is this right? */
-        case VT_HRESULT : 
+        case VT_HRESULT :
             size=4; break;
         case VT_R8  :
         case VT_CY  :
-        case VT_DATE    : 
-        case VT_I8  : 
-        case VT_UI8 : 
+        case VT_DATE    :
+        case VT_I8  :
+        case VT_UI8 :
         case VT_DECIMAL :  /* FIXME: is this right? */
         case VT_FILETIME :
@@ -1041 +1042 @@
             char * ptr;
             TLB_Read(&size, sizeof(INT), pcx, DO_NOT_SEEK );
-            if(size <= 0) {
-                FIXME("BSTR length = %d?\n", size);
-            } else {
+        if(size <= 0) {
+            FIXME("BSTR length = %d?\n", size);
+        } else {
                 ptr=TLB_Alloc(size);/* allocate temp buffer */
-                TLB_Read(ptr, size, pcx, DO_NOT_SEEK); /* read string (ANSI) */
-                V_UNION(pVar, bstrVal)=SysAllocStringLen(NULL,size);
-                /* FIXME: do we need a AtoW conversion here? */
-                V_UNION(pVar, bstrVal[size])=L'\0';
-                while(size--) V_UNION(pVar, bstrVal[size])=ptr[size];
-                TLB_Free(ptr);
-            }
-        }
-        size=-4; break;
+        TLB_Read(ptr, size, pcx, DO_NOT_SEEK); /* read string (ANSI) */
+        V_UNION(pVar, bstrVal)=SysAllocStringLen(NULL,size);
+        /* FIXME: do we need a AtoW conversion here? */
+        V_UNION(pVar, bstrVal[size])=L'\0';
+        while(size--) V_UNION(pVar, bstrVal[size])=ptr[size];
+        TLB_Free(ptr);
+        }
+    }
+    size=-4; break;
     /* FIXME: this will not work AT ALL when the variant contains a pointer */
         case VT_DISPATCH :
-        case VT_VARIANT : 
-        case VT_UNKNOWN : 
-        case VT_PTR : 
+        case VT_VARIANT :
+        case VT_UNKNOWN :
+        case VT_PTR :
         case VT_SAFEARRAY :
-        case VT_CARRAY  : 
-        case VT_USERDEFINED : 
-        case VT_LPSTR   : 
-        case VT_LPWSTR  : 
-        case VT_BLOB    : 
-        case VT_STREAM  : 
-        case VT_STORAGE : 
-        case VT_STREAMED_OBJECT : 
-        case VT_STORED_OBJECT   : 
-        case VT_BLOB_OBJECT : 
-        case VT_CF  : 
-        case VT_CLSID   : 
-        default: 
-            size=0; 
+        case VT_CARRAY  :
+        case VT_USERDEFINED :
+        case VT_LPSTR   :
+        case VT_LPWSTR  :
+        case VT_BLOB    :
+        case VT_STREAM  :
+        case VT_STORAGE :
+        case VT_STREAMED_OBJECT :
+        case VT_STORED_OBJECT   :
+        case VT_BLOB_OBJECT :
+        case VT_CF  :
+        case VT_CLSID   :
+        default:
+            size=0;
             FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
                 V_VT(pVar));
@@ -1096 +1097 @@
         count++;
         pNew=TLB_Alloc(sizeof(TLBCustData));
-        TLB_Read(&entry, sizeof(entry), pcx, 
+        TLB_Read(&entry, sizeof(entry), pcx,
             pcx->pTblDir->pCDGuids.offset+offset);
         TLB_ReadGuid(&(pNew->guid), entry.GuidOffset , pcx);
@@ -1118 +1119 @@
 }
 
-static void 
-TLB_DoFuncs(TLBContext*     pcx, 
-            int             cFuncs, 
+static void
+TLB_DoFuncs(TLBContext*     pcx,
+            int             cFuncs,
             int             cVars,
-            int             offset, 
+            int             offset,
             TLBFuncDesc**   pptfd)
 {
-    /* 
+    /*
      * member information is stored in a data structure at offset
      * indicated by the memoffset field of the typeinfo structure
      * There are several distinctive parts.
-     * the first part starts with a field that holds the total length 
+     * the first part starts with a field that holds the total length
      * of this (first) part excluding this field. Then follow the records,
      * for each member there is one record.
      *
      * First entry is always the length of the record (excluding this
-     * length word). 
-     * Rest of the record depends on the type of the member. If there is 
+     * length word).
+     * Rest of the record depends on the type of the member. If there is
      * a field indicating the member type (function variable intereface etc)
      * I have not found it yet. At this time we depend on the information
@@ -1142 +1143 @@
      * Second follows an array sized nrMEM*sizeof(INT) with a memeber id
      * for each member;
-     * 
-     * Third is a equal sized array with file offsets to the name entry 
+     *
+     * Third is a equal sized array with file offsets to the name entry
      * of each member.
-     * 
+     *
      * Forth and last (?) part is an array with offsets to the records in the
      * first part of this file segment.
@@ -1165 +1166 @@
 
         /* name, eventually add to a hash table */
-        TLB_Read(&nameoffset, 
-                 sizeof(INT), 
-                 pcx, 
+        TLB_Read(&nameoffset,
+                 sizeof(INT),
+                 pcx,
                  offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
 
@@ -1174 +1175 @@
         /* read the function information record */
         TLB_Read(&reclength, sizeof(INT), pcx, recoffset);
-        
+
         reclength &= 0x1ff;
 
-        TLB_Read(pFuncRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ; 
+        TLB_Read(pFuncRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ;
 
         /* do the attributes */
@@ -1186 +1187 @@
         {
             (*pptfd)->helpcontext = pFuncRec->OptAttr[0] ;
-            
+
             if ( nrattributes > 1 )
             {
@@ -1209 +1210 @@
                         if ( nrattributes > 6 && pFuncRec->FKCCIC & 0x80 )
                         {
-                            TLB_CustData(pcx, 
+                            TLB_CustData(pcx,
                                          pFuncRec->OptAttr[6],
                                          &(*pptfd)->pCustData);
@@ -1219 +1220 @@
 
         /* fill the FuncDesc Structure */
-        TLB_Read( & (*pptfd)->funcdesc.memid, 
-                  sizeof(INT), pcx, 
+        TLB_Read( & (*pptfd)->funcdesc.memid,
+                  sizeof(INT), pcx,
                   offset + infolen + ( i + 1) * sizeof(INT));
 
@@ -1231 +1232 @@
         (*pptfd)->funcdesc.wFuncFlags =   LOWORD(pFuncRec->Flags) ;
 
-        TLB_GetTdesc(pcx, 
-                     pFuncRec->DataType,   
+        TLB_GetTdesc(pcx,
+                     pFuncRec->DataType,
                      &(*pptfd)->funcdesc.elemdescFunc.tdesc) ;
 
@@ -1241 +1242 @@
             TLBParameterInfo paraminfo;
 
-            (*pptfd)->funcdesc.lprgelemdescParam = 
+            (*pptfd)->funcdesc.lprgelemdescParam =
                 TLB_Alloc(pFuncRec->nrargs * sizeof(ELEMDESC));
 
-            (*pptfd)->pParamDesc = 
+            (*pptfd)->pParamDesc =
                 TLB_Alloc(pFuncRec->nrargs * sizeof(TLBParDesc));
 
             TLB_Read(&paraminfo,
-                     sizeof(paraminfo), 
-                     pcx, 
+                     sizeof(paraminfo),
+                     pcx,
                      recoffset + reclength -
                         pFuncRec->nrargs * sizeof(TLBParameterInfo));
@@ -1257 +1258 @@
                 TYPEDESC* lpArgTypeDesc = 0;
 
-                TLB_GetTdesc(pcx, 
-                             paraminfo.DataType,   
+                TLB_GetTdesc(pcx,
+                             paraminfo.DataType,
                              &(*pptfd)->funcdesc.lprgelemdescParam[j].tdesc) ;
 
@@ -1265 +1266 @@
                 (*pptfd)->pParamDesc[j].Name = (void *) paraminfo.oName;
 
-                /* SEEK value = jump to offset, 
+                /* SEEK value = jump to offset,
                  * from there jump to the end of record,
                  * go back by (j-1) arguments
@@ -1271 +1272 @@
                 TLB_Read( &paraminfo ,
                           sizeof(TLBParameterInfo), pcx,
-                          recoffset + reclength - ((pFuncRec->nrargs - j - 1) 
+                          recoffset + reclength - ((pFuncRec->nrargs - j - 1)
                                                    * sizeof(TLBParameterInfo)));
-                lpArgTypeDesc = 
+                lpArgTypeDesc =
                     & ((*pptfd)->funcdesc.lprgelemdescParam[j].tdesc);
 
@@ -1289 +1290 @@
 
                     case VT_USERDEFINED:
-                        (*pptfd)->pParamDesc[j].pRefType = 
+                        (*pptfd)->pParamDesc[j].pRefType =
                         TLB_Alloc(sizeof(TLBRefType));
 
-                        TLB_DoRefType(pcx, 
-                                      lpArgTypeDesc->u.hreftype, 
+                        TLB_DoRefType(pcx,
+                                      lpArgTypeDesc->u.hreftype,
                                       & ( (*pptfd)->pParamDesc[j].pRefType ));
 
@@ -1311 +1312 @@
                 TYPEDESC* lpArgTypeDesc;
 
-                (*pptfd)->funcdesc.elemdescFunc = 
+                (*pptfd)->funcdesc.elemdescFunc =
                 (*pptfd)->funcdesc.lprgelemdescParam[j];
 
@@ -1324 +1325 @@
                         break;
                     case VT_CARRAY:
-                        lpArgTypeDesc = 
+                        lpArgTypeDesc =
                         & (lpArgTypeDesc->u.lpadesc->tdescElem);
 
@@ -1330 +1331 @@
 
                     case VT_USERDEFINED:
-                        (*pptfd)->pParamDesc[j].pRefType 
+                        (*pptfd)->pParamDesc[j].pRefType
                         = TLB_Alloc(sizeof(TLBRefType));
 
-                        TLB_DoRefType(pcx, 
-                                      lpArgTypeDesc->u.hreftype, 
+                        TLB_DoRefType(pcx,
+                                      lpArgTypeDesc->u.hreftype,
                                       &((*pptfd)->pParamDesc[j].pRefType));
 
@@ -1354 +1355 @@
 
                 /* default value */
-                if ( (PARAMFLAG_FHASDEFAULT & 
+                if ( (PARAMFLAG_FHASDEFAULT &
                       (*pptfd)->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags) &&
                      ((pFuncRec->FKCCIC) & 0x1000) )
                 {
-                    INT* pInt = (INT *)((char *)pFuncRec + 
-                                   reclength - 
+                    INT* pInt = (INT *)((char *)pFuncRec +
+                                   reclength -
                                    (pFuncRec->nrargs * 4 + 1) * sizeof(INT) );
 
@@ -1367 +1368 @@
                     pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
 
-                    TLB_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue), 
+                    TLB_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue),
                         pInt[j], pcx);
                 }
@@ -1373 +1374 @@
                 if ( nrattributes > 7 + j && pFuncRec->FKCCIC & 0x80 )
                 {
-                    TLB_CustData(pcx, 
+                    TLB_CustData(pcx,
                                  pFuncRec->OptAttr[7+j],
                                  &(*pptfd)->pParamDesc[j].pCustData);
@@ -1400 +1401 @@
 
     TLB_Read(&infolen,sizeof(INT), pcx, offset);
-    TLB_Read(&recoffset,sizeof(INT), pcx, offset + infolen + 
+    TLB_Read(&recoffset,sizeof(INT), pcx, offset + infolen +
         ((cFuncs+cVars)*2+cFuncs + 1)*sizeof(INT));
     recoffset += offset+sizeof(INT);
@@ -1406 +1407 @@
         *pptvd=TLB_Alloc(sizeof(TLBVarDesc));
     /* name, eventually add to a hash table */
-        TLB_Read(&nameoffset, sizeof(INT), pcx, 
+        TLB_Read(&nameoffset, sizeof(INT), pcx,
             offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
         (*pptvd)->Name=TLB_ReadName(pcx, nameoffset);
@@ -1412 +1413 @@
         TLB_Read(&reclength, sizeof(INT), pcx, recoffset);
         reclength &=0xff;
-        TLB_Read(pVarRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ; 
+        TLB_Read(pVarRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ;
     /* Optional data */
         if(reclength >(6*sizeof(INT)) )
@@ -1422 +1423 @@
             (*pptvd)->HelpStringContext=pVarRec->HelpStringContext;
     /* fill the VarDesc Structure */
-        TLB_Read(&(*pptvd)->vardesc.memid, sizeof(INT), pcx, 
+        TLB_Read(&(*pptvd)->vardesc.memid, sizeof(INT), pcx,
             offset + infolen + ( i + 1) * sizeof(INT));
         (*pptvd)->vardesc.varkind = pVarRec->VarKind;
         (*pptvd)->vardesc.wVarFlags = pVarRec->Flags;
-        TLB_GetTdesc(pcx, pVarRec->DataType,    
+        TLB_GetTdesc(pcx, pVarRec->DataType,
             &(*pptvd)->vardesc.elemdescVar.tdesc) ;
 /*   (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) fixme?? */
@@ -1443 +1444 @@
  * If comes from import, its an offset+1 in the ImpInfo table
  * */
-static void TLB_DoRefType(TLBContext *pcx, 
+static void TLB_DoRefType(TLBContext *pcx,
                           int offset, TLBRefType ** pprtd)
 {
@@ -1457 +1458 @@
         TRACE_(typelib)("offset %x, masked offset %x\n", offset, offset + (offset & 0xfffffffc));
 
-        TLB_Read(&impinfo, sizeof(impinfo), pcx, 
+        TLB_Read(&impinfo, sizeof(impinfo), pcx,
             pcx->pTblDir->pImpInfo.offset + (offset & 0xfffffffc));
         for(j=0;pImpLib;j++){   /* search the known offsets of all import libraries */
@@ -1538 +1539 @@
     ptiRet->TypeAttr.cbSizeVft=tiBase.cbSizeVft; /* FIXME: this is only the non inherited part */
     if(ptiRet->TypeAttr.typekind == TKIND_ALIAS)
-        TLB_GetTdesc(pcx, tiBase.datatype1, 
+        TLB_GetTdesc(pcx, tiBase.datatype1,
             &ptiRet->TypeAttr.tdescAlias) ;
 
@@ -1556 +1557 @@
     /* functions */
     if(ptiRet->TypeAttr.cFuncs >0 )
-        TLB_DoFuncs(pcx, ptiRet->TypeAttr.cFuncs ,ptiRet->TypeAttr.cVars, 
+        TLB_DoFuncs(pcx, ptiRet->TypeAttr.cFuncs ,ptiRet->TypeAttr.cVars,
         tiBase.memoffset, & ptiRet->funclist);
     /* variables */
     if(ptiRet->TypeAttr.cVars >0 )
-        TLB_DoVars(pcx, ptiRet->TypeAttr.cFuncs ,ptiRet->TypeAttr.cVars, 
+        TLB_DoVars(pcx, ptiRet->TypeAttr.cFuncs ,ptiRet->TypeAttr.cVars,
         tiBase.memoffset, & ptiRet->varlist);
     if(ptiRet->TypeAttr.cImplTypes >0 ){
@@ -1566 +1567 @@
         {
         case TKIND_COCLASS:
-            TLB_DoImplTypes(pcx, ptiRet->TypeAttr.cImplTypes , 
+            TLB_DoImplTypes(pcx, ptiRet->TypeAttr.cImplTypes ,
                 tiBase.datatype1, & ptiRet->impltypelist);
             break;
         case TKIND_DISPATCH:
             ptiRet->impltypelist=TLB_Alloc(sizeof(TLBRefType));
-            
+
             if (tiBase.datatype1 != -1)
             {
@@ -1580 +1581 @@
               char* szStdOle     = "stdole2.tlb\0";
               int   nStdOleLen = strlen(szStdOle);
-                            
+
               ptiRet->impltypelist->guid             = IID_IDispatch;
               ptiRet->impltypelist->reference        = -1;
               ptiRet->impltypelist->pImpTLInfo       = TLB_Alloc(sizeof(TLBImpLib));
-              ptiRet->impltypelist->pImpTLInfo->guid = IID_StdOle;             
+              ptiRet->impltypelist->pImpTLInfo->guid = IID_StdOle;
               ptiRet->impltypelist->pImpTLInfo->name = SysAllocStringLen(NULL, nStdOleLen  + 1);
-              
+
               MultiByteToWideChar(CP_ACP,
                                   MB_PRECOMPOSED,
@@ -1593 +1594 @@
                                   ptiRet->impltypelist->pImpTLInfo->name,
                                   SysStringLen(ptiRet->impltypelist->pImpTLInfo->name));
-                                  
+
               ptiRet->impltypelist->pImpTLInfo->lcid          = 0;
               ptiRet->impltypelist->pImpTLInfo->wVersionMajor = 2;
@@ -1617 +1618 @@
 
 /****************************************************************************
- *      TLB_ReadTypeLib
+ *  TLB_ReadTypeLib
  *
  * find the type of the typelib file and map the typelib resource into
@@ -1639 +1640 @@
 
     /* is it a DLL? */
-        for (i=0 ; i < nStrLen ; ++i)
-        {
-            pszFileName[i] = tolower(pszFileName[i]);
-        }
+    for (i=0 ; i < nStrLen ; ++i)
+    {
+        pszFileName[i] = tolower(pszFileName[i]);
+    }
     pszTypeLibIndex = strstr(pszFileName, ".dll");
 
@@ -1656 +1657 @@
       /* yes -> it's a index! store DLL name, without the trailing back-slash */
       size_t nMemToAlloc = pszTypeLibIndex - pszFileName;
-      
+
       pszDllName = HeapAlloc(GetProcessHeap(),
-                          HEAP_ZERO_MEMORY, 
+                          HEAP_ZERO_MEMORY,
                           nMemToAlloc + 1);
-                          
+
       strncpy(pszDllName, pszFileName, nMemToAlloc);
-      
+
       /* move index string pointer pass the backslash */
       while (*pszTypeLibIndex == '\\')
@@ -1671 +1672 @@
       /* No index, reset variable to 1 */
       pszDllName = HeapAlloc(GetProcessHeap(),
-                          HEAP_ZERO_MEMORY, 
+                          HEAP_ZERO_MEMORY,
                           nStrLen + 1);
-                          
+
       strncpy(pszDllName, pszFileName, nStrLen);
-      
+
       pszTypeLibIndex = "1\0";
     }
@@ -1699 +1700 @@
                 /* retrieve file size */
                 DWORD dwTLBLength = GetFileSize(hFile, NULL);
-    
+
             *ppTypeLib = ITypeLib2_Constructor(pBase, dwTLBLength);
             ITypeLib2_AddRef(*ppTypeLib);
@@ -1725 +1726 @@
             LPVOID pBase = LockResource(hGlobal);
             DWORD  dwTLBLength = SizeofResource(hinstDLL, hrsrc);
-            
+
             if (pBase)
             {
@@ -1760 +1761 @@
 
 /****************************************************************************
- *      ITypeLib2_Constructor
+ *  ITypeLib2_Constructor
  *
  * loading a typelib from a in-memory image
@@ -1786 +1787 @@
     cx.pLibInfo = pTypeLibImpl;
     cx.length = dwTLBLength;
-    
+
     /* read header */
     TLB_Read((void*)&tlbHeader, sizeof(tlbHeader), &cx, 0);
@@ -1792 +1793 @@
     TRACE("\tmagic1=0x%08x ,magic2=0x%08x\n",tlbHeader.magic1,tlbHeader.magic2 );
     if (memcmp(&tlbHeader.magic1,TLBMAGIC2,4)) {
-        FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
-        return NULL;
+    FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
+    return NULL;
     }
     /* there is a small number of information here until the next important
@@ -1802 +1803 @@
     /* now read the segment directory */
     TRACE("read segment directory (at %ld)\n",lPSegDir);
-    TLB_Read((void*)&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);  
+    TLB_Read((void*)&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);
     cx.pTblDir = &tlbSegDir;
 
@@ -1809 +1810 @@
     {
         ERR("cannot find the table directory, ptr=0x%lx\n",lPSegDir);
-        HeapFree(GetProcessHeap(),0,pTypeLibImpl);
-        return NULL;
+    HeapFree(GetProcessHeap(),0,pTypeLibImpl);
+    return NULL;
     }
 
@@ -1852 +1853 @@
         TLB_Read(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
         for(i=0; i<cTD; )
-        {
+    {
             /* FIXME: add several sanity checks here */
             pTypeLibImpl->pTypeDesc[i].vt = td[0] & VT_TYPEMASK;
             if(td[0] == VT_PTR || td[0] == VT_SAFEARRAY)
-            {
-                /* FIXME: check safearray */
+        {
+            /* FIXME: check safearray */
                 if(td[3] < 0)
                     pTypeLibImpl->pTypeDesc[i].u.lptdesc= & stndTypeDesc[td[2]];
@@ -1863 +1864 @@
                     pTypeLibImpl->pTypeDesc[i].u.lptdesc= & pTypeLibImpl->pTypeDesc[td[2]/8];
             }
-            else if(td[0] == VT_CARRAY)
+        else if(td[0] == VT_CARRAY)
             {
-                /* array descr table here */
-                pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)((int) td[2]);  /* temp store offset in*/
+            /* array descr table here */
+            pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)((int) td[2]);  /* temp store offset in*/
             }
             else if(td[0] == VT_USERDEFINED)
-            {
+        {
                 pTypeLibImpl->pTypeDesc[i].u.hreftype = MAKELONG(td[2],td[3]);
             }
-            if(++i<cTD) TLB_Read(td, sizeof(td), &cx, DO_NOT_SEEK);
+        if(++i<cTD) TLB_Read(td, sizeof(td), &cx, DO_NOT_SEEK);
         }
 
         /* second time around to fill the array subscript info */
         for(i=0;i<cTD;i++)
-        {
+    {
             if(pTypeLibImpl->pTypeDesc[i].vt != VT_CARRAY) continue;
             if(tlbSegDir.pArrayDescriptions.offset>0)
-            {
+        {
                 TLB_Read(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) pTypeLibImpl->pTypeDesc[i].u.lpadesc);
                 pTypeLibImpl->pTypeDesc[i].u.lpadesc = TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
@@ -1892 +1893 @@
 
                 for(j = 0; j<td[2]; j++)
-                {
-                    TLB_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements, 
+        {
+                    TLB_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements,
                         sizeof(INT), &cx, DO_NOT_SEEK);
-                    TLB_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound, 
+                    TLB_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound,
                         sizeof(INT), &cx, DO_NOT_SEEK);
                 }
             }
-            else
-            {
+        else
+        {
                 pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL;
                 ERR("didn't find array description data\n");
@@ -1915 +1916 @@
 
         while(offset < tlbSegDir.pImpFiles.offset +tlbSegDir.pImpFiles.length)
-        {
+    {
             *ppImpLib = TLB_Alloc(sizeof(TLBImpLib));
             (*ppImpLib)->offset = offset - tlbSegDir.pImpFiles.offset;
             TLB_Read(&oGuid, sizeof(INT), &cx, offset);
 
-                        TLB_Read(&(*ppImpLib)->lcid,          sizeof(LCID),   &cx, DO_NOT_SEEK);
+            TLB_Read(&(*ppImpLib)->lcid,          sizeof(LCID),   &cx, DO_NOT_SEEK);
             TLB_Read(&(*ppImpLib)->wVersionMajor, sizeof(WORD),   &cx, DO_NOT_SEEK);
             TLB_Read(&(*ppImpLib)->wVersionMinor, sizeof(WORD),   &cx, DO_NOT_SEEK);
@@ -1959 +1960 @@
  */
 static HRESULT WINAPI ITypeLib2_fnQueryInterface(
-        ITypeLib2 * iface,
-        REFIID riid,
-        VOID **ppvObject)
+    ITypeLib2 * iface,
+    REFIID riid,
+    VOID **ppvObject)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -1968 +1969 @@
 
     *ppvObject=NULL;
-    if(IsEqualIID(riid, &IID_IUnknown) || 
+    if(IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid,&IID_ITypeLib)||
        IsEqualIID(riid,&IID_ITypeLib2))
@@ -2003 +2004 @@
 
     --(This->ref);
-    
+
     TRACE("(%p)->(%u)\n",This, This->ref);
 
@@ -2035 +2036 @@
           This->HelpStringDll = NULL;
       }
-    
+
       ITypeInfo_Release((ITypeInfo*) This->pTypeInfo);
       HeapFree(GetProcessHeap(),0,This);
@@ -2045 +2046 @@
 
 /* ITypeLib::GetTypeInfoCount
- * 
+ *
  * Returns the number of type descriptions in the type library
  */
@@ -2061 +2062 @@
 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
     ITypeLib2 *iface,
-    UINT index, 
+    UINT index,
     ITypeInfo **ppTInfo)
 {
     int i;
-    
+
     ICOM_THIS( ITypeLibImpl, iface);
     ITypeInfoImpl *pTypeInfo = This->pTypeInfo;
@@ -2072 +2073 @@
 
     if (!ppTInfo) return E_INVALIDARG;
-    
+
     /* search element n in list */
     for(i=0; i < index; i++)
@@ -2082 +2083 @@
         return TYPE_E_ELEMENTNOTFOUND;
       }
-    }   
+    }
 
     *ppTInfo = (ITypeInfo *) pTypeInfo;
-    
+
     ITypeInfo_AddRef(*ppTInfo);
     TRACE("-- found (%p)\n",*ppTInfo);
@@ -2108 +2109 @@
 
     if(!pTKind) return E_INVALIDARG;
-    
+
     /* search element n in list */
     for(i=0; i < index; i++)
@@ -2155 +2156 @@
     }
 
-    TRACE("-- found (%p, %s)\n", 
-          pTypeInfo, 
+    TRACE("-- found (%p, %s)\n",
+          pTypeInfo,
           debugstr_w(pTypeInfo->Name));
 
@@ -2170 +2171 @@
  */
 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
-        ITypeLib2 *iface, 
-        LPTLIBATTR *ppTLibAttr)
+    ITypeLib2 *iface,
+    LPTLIBATTR *ppTLibAttr)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2187 +2188 @@
  */
 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
-        ITypeLib2 *iface,
-        ITypeComp **ppTComp)
+    ITypeLib2 *iface,
+    ITypeComp **ppTComp)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2207 +2208 @@
     BSTR *pBstrName,
     BSTR *pBstrDocString,
-    DWORD *pdwHelpContext, 
+    DWORD *pdwHelpContext,
     BSTR *pBstrHelpFile)
 {
     ICOM_THIS( ITypeLibImpl, iface);
-    
+
     HRESULT result = E_INVALIDARG;
-    
+
     ITypeInfo *pTInfo;
 
-   
+
     TRACE("(%p) index %d Name(%p) DocString(%p) HelpContext(%p) HelpFile(%p)\n",
         This, index,
-        pBstrName, pBstrDocString, 
+        pBstrName, pBstrDocString,
         pdwHelpContext, pBstrHelpFile);
-   
+
     if(index<0)
-    { 
+    {
        /* documentation for the typelib */
        if(pBstrName && This->Name)
@@ -2237 +2238 @@
            if (!(*pBstrDocString)) return STG_E_INSUFFICIENTMEMORY;
        }
-    
+
        if(pdwHelpContext)
        {
@@ -2251 +2252 @@
        result = S_OK;
     }
-    else 
+    else
     {
         /* for a typeinfo */
@@ -2258 +2259 @@
         if(SUCCEEDED(result))
         {
-            result = ITypeInfo_GetDocumentation(pTInfo, 
-                                          MEMBERID_NIL,  
+            result = ITypeInfo_GetDocumentation(pTInfo,
+                                          MEMBERID_NIL,
                                           pBstrName,
-                                          pBstrDocString, 
+                                          pBstrDocString,
                                           pdwHelpContext, pBstrHelpFile);
-            
+
             ITypeInfo_Release(pTInfo);
         }
@@ -2277 +2278 @@
  */
 static HRESULT WINAPI ITypeLib2_fnIsName(
-        ITypeLib2 *iface,
-        LPOLESTR szNameBuf,
-        ULONG lHashVal,
-        BOOL *pfName)
+    ITypeLib2 *iface,
+    LPOLESTR szNameBuf,
+    ULONG lHashVal,
+    BOOL *pfName)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2290 +2291 @@
 
     TRACE("(%p)->(%s,%08lx,%p)\n", This, debugstr_w(szNameBuf), lHashVal,
-          pfName);
+      pfName);
 
     *pfName=TRUE;
@@ -2303 +2304 @@
         for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next)
             if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
-       
+
     }
     *pfName=FALSE;
@@ -2310 +2311 @@
     TRACE("(%p)slow! search for %s: %s found!\n", This,
           debugstr_w(szNameBuf), *pfName?"NOT":"");
-    
+
     return S_OK;
 }
@@ -2321 +2322 @@
  */
 static HRESULT WINAPI ITypeLib2_fnFindName(
-        ITypeLib2 *iface,
-        LPOLESTR szNameBuf,
-        ULONG lHashVal,
-        ITypeInfo **ppTInfo,
-        MEMBERID *rgMemId,
-        UINT16 *pcFound)
+    ITypeLib2 *iface,
+    LPOLESTR szNameBuf,
+    ULONG lHashVal,
+    ITypeInfo **ppTInfo,
+    MEMBERID *rgMemId,
+    UINT16 *pcFound)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2333 +2334 @@
     TLBVarDesc *pVInfo;
     int i,j = 0;
-   
+
     UINT nNameBufLen = SysStringLen(szNameBuf);
 
@@ -2356 +2357 @@
 
     *pcFound=j;
-    
+
     return S_OK;
 }
@@ -2366 +2367 @@
  */
 static VOID WINAPI ITypeLib2_fnReleaseTLibAttr(
-        ITypeLib2 *iface,
-        TLIBATTR *pTLibAttr)
+    ITypeLib2 *iface,
+    TLIBATTR *pTLibAttr)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2379 +2380 @@
  */
 static HRESULT WINAPI ITypeLib2_fnGetCustData(
-        ITypeLib2 * iface,
-        REFGUID guid, 
+    ITypeLib2 * iface,
+    REFGUID guid,
         VARIANT *pVarVal)
 {
@@ -2390 +2391 @@
       if( IsEqualIID(guid, &pCData->guid)) break;
     }
-    
+
     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
 
@@ -2409 +2410 @@
  */
 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
-        ITypeLib2 * iface, 
+    ITypeLib2 * iface,
         ULONG *pcUniqueNames,
-        ULONG *pcchUniqueNames)
+    ULONG *pcchUniqueNames)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2430 +2431 @@
  */
 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
-        ITypeLib2 * iface, 
+    ITypeLib2 * iface,
         INT index,
-        LCID lcid,
-        BSTR *pbstrHelpString,
+    LCID lcid,
+    BSTR *pbstrHelpString,
         DWORD *pdwHelpStringContext,
-        BSTR *pbstrHelpStringDll)
+    BSTR *pbstrHelpStringDll)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2463 +2464 @@
       /* for a typeinfo */
       result=ITypeLib2_GetTypeInfo(iface, index, &pTInfo);
-      
+
       if(SUCCEEDED(result))
-      { 
+      {
         ITypeInfo2 * pTInfo2;
-        result = ITypeInfo_QueryInterface(pTInfo, 
-                                          &IID_ITypeInfo2, 
+        result = ITypeInfo_QueryInterface(pTInfo,
+                                          &IID_ITypeInfo2,
                                           (LPVOID*) &pTInfo2);
 
         if(SUCCEEDED(result))
         {
-          result = ITypeInfo2_GetDocumentation2(pTInfo2, 
-                                           MEMBERID_NIL, 
+          result = ITypeInfo2_GetDocumentation2(pTInfo2,
+                                           MEMBERID_NIL,
                                            lcid,
-                                           pbstrHelpString, 
-                                           pdwHelpStringContext, 
+                                           pbstrHelpString,
+                                           pdwHelpStringContext,
                                            pbstrHelpStringDll);
-  
+
           ITypeInfo2_Release(pTInfo2);
         }
-            
+
         ITypeInfo_Release(pTInfo);
       }
@@ -2491 +2492 @@
 /* ITypeLib2::GetAllCustData
  *
- * Gets all custom data items for the library. 
+ * Gets all custom data items for the library.
  *
  */
 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
-        ITypeLib2 * iface,
+    ITypeLib2 * iface,
         CUSTDATA *pCustData)
 {
@@ -2501 +2502 @@
     TLBCustData *pCData;
     int i;
-    TRACE("(%p) returning %d items\n", This, This->ctCustData); 
+    TRACE("(%p) returning %d items\n", This, This->ctCustData);
     pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
     if(pCustData->prgCustData ){
@@ -2556 +2557 @@
  */
 static HRESULT WINAPI ITypeInfo_fnQueryInterface(
-        ITypeInfo2 *iface,
-        REFIID riid,
-        VOID **ppvObject)
+    ITypeInfo2 *iface,
+    REFIID riid,
+    VOID **ppvObject)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2565 +2566 @@
 
     *ppvObject=NULL;
-    if(IsEqualIID(riid, &IID_IUnknown) || 
+    if(IsEqualIID(riid, &IID_IUnknown) ||
             IsEqualIID(riid,&IID_ITypeInfo)||
             IsEqualIID(riid,&IID_ITypeInfo2))
@@ -2598 +2599 @@
 
     --(This->ref);
-    
+
     TRACE("(%p)->(%u)\n",This, This->ref);
 
@@ -2605 +2606 @@
       FIXME("destroy child objects\n");
 
-      TRACE("destroying ITypeInfo(%p)\n",This); 
+      TRACE("destroying ITypeInfo(%p)\n",This);
       if (This->Name)
       {
@@ -2611 +2612 @@
           This->Name = 0;
       }
-      
+
       if (This->DocString)
       {
@@ -2670 +2671 @@
     ICOM_THIS( ITypeInfoImpl, iface);
     int i;
-    TLBFuncDesc * pFDesc; 
+    TLBFuncDesc * pFDesc;
     TRACE("(%p) index %d\n", This, index);
     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++, pFDesc=pFDesc->next)
@@ -2684 +2685 @@
 /* ITypeInfo::GetVarDesc
  *
- * Retrieves a VARDESC structure that describes the specified variable. 
+ * Retrieves a VARDESC structure that describes the specified variable.
  *
  */
@@ -2692 +2693 @@
     ICOM_THIS( ITypeInfoImpl, iface);
     int i;
-    TLBVarDesc * pVDesc; 
+    TLBVarDesc * pVDesc;
     TRACE("(%p) index %d\n", This, index);
     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next)
@@ -2714 +2715 @@
 {
     ICOM_THIS( ITypeInfoImpl, iface);
-    TLBFuncDesc * pFDesc; 
-    TLBVarDesc * pVDesc; 
+    TLBFuncDesc * pFDesc;
+    TLBVarDesc * pVDesc;
     int i;
     TRACE("(%p) memid=0x%08lx Maxname=%d\n", This, memid, cMaxNames);
@@ -2725 +2726 @@
       {
         if(!i)
-                  *rgBstrNames=SysAllocString(pFDesc->Name);
+          *rgBstrNames=SysAllocString(pFDesc->Name);
         else
           rgBstrNames[i]=SysAllocString(pFDesc->pParamDesc[i-1].Name);
@@ -2748 +2749 @@
           result=ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->reference, &pTInfo);
           if(SUCCEEDED(result))
-          {
+      {
             result=ITypeInfo_GetNames(pTInfo, memid, rgBstrNames, cMaxNames, pcNames);
             ITypeInfo_Release(pTInfo);
@@ -2756 +2757 @@
         }
         else
-        {
+    {
           WARN("no names found\n");
-        }
+    }
         *pcNames=0;
         return TYPE_E_ELEMENTNOTFOUND;
@@ -2776 +2777 @@
  */
 static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType(
-        ITypeInfo2 *iface,
+    ITypeInfo2 *iface,
         UINT index,
-        HREFTYPE  *pRefType)
+    HREFTYPE  *pRefType)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
@@ -2793 +2794 @@
       */
       if( This->TypeAttr.typekind != TKIND_DISPATCH) return E_INVALIDARG;
-      
+
       if (This->TypeAttr.wTypeFlags & TYPEFLAG_FDISPATCHABLE &&
           This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL )
@@ -2812 +2813 @@
         pIref = pIref->next;
       }
-      
+
       if (!pIref) return TYPE_E_ELEMENTNOTFOUND;
-      
+
       *pRefType = pIref->reference;
-      
+
       TRACE("-- 0x%08lx %s\n",pIref->reference, debugstr_guid(&pIref->guid) );
     }
-    
+
     return S_OK;
-   
+
 }
 
 /* ITypeInfo::GetImplTypeFlags
- * 
- * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface 
+ *
+ * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface
  * or base interface in a type description.
  */
@@ -2854 +2855 @@
 {
     ICOM_THIS( ITypeInfoImpl, iface);
-    TLBFuncDesc * pFDesc; 
-    TLBVarDesc * pVDesc; 
+    TLBFuncDesc * pFDesc;
+    TLBVarDesc * pVDesc;
     HRESULT ret=S_OK;
-        UINT nNameLen = SysStringLen(*rgszNames);
-        
+    UINT nNameLen = SysStringLen(*rgszNames);
+
     TRACE("(%p) Name %s cNames %d\n", This, debugstr_w(*rgszNames),
             cNames);
@@ -2866 +2867 @@
             if(cNames) *pMemId=pFDesc->funcdesc.memid;
             for(i=1; i < cNames; i++){
-                                UINT nParamLen = SysStringLen(rgszNames[i]);
+                UINT nParamLen = SysStringLen(rgszNames[i]);
                 for(j=0; j<pFDesc->funcdesc.cParams; j++)
                     if(memcmp(rgszNames[i],pFDesc->pParamDesc[j].Name, nParamLen))
@@ -2877 +2878 @@
             return ret;
         }
-    }   
+    }
     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
         if( !memcmp(*rgszNames, pVDesc->Name, nNameLen)) {
@@ -2884 +2885 @@
         }
     }
-    /* not found, see if this is and interface with an inheritance */       
-    if(This->TypeAttr.typekind==TKIND_INTERFACE && 
+    /* not found, see if this is and interface with an inheritance */
+    if(This->TypeAttr.typekind==TKIND_INTERFACE &&
             This->TypeAttr.cImplTypes ){
         /* recursive search */
         ITypeInfo *pTInfo;
-        ret=ITypeInfo_GetRefTypeInfo(iface, 
+        ret=ITypeInfo_GetRefTypeInfo(iface,
                 This->impltypelist->reference, &pTInfo);
         if(SUCCEEDED(ret)){
@@ -2903 +2904 @@
 
 /* ITypeInfo::Invoke
- * 
+ *
  * Invokes a method, or accesses a property of an object, that implements the
  * interface described by the type description.
@@ -2911 +2912 @@
 
     if (TRACE_ON(ole)) {
-        int i;
-        MESSAGE("Calling %p(",func);
-        for (i=0;i<nrargs;i++) MESSAGE("%08lx,",args[i]);
-        MESSAGE(")\n");
+    int i;
+    MESSAGE("Calling %p(",func);
+    for (i=0;i<nrargs;i++) MESSAGE("%08lx,",args[i]);
+    MESSAGE(")\n");
     }
 
@@ -2920 +2921 @@
     case CC_STDCALL:
 
-        switch (nrargs) {
-        case 0: {
+    switch (nrargs) {
+    case 0: {
 #ifdef __WIN32OS2__
-                DWORD (* WINAPI xfunc)() = func;
+        DWORD (* WINAPI xfunc)() = func;
 #else
-                DWORD (WINAPI *xfunc)() = func;
+        DWORD (WINAPI *xfunc)() = func;
 #endif
-                res = xfunc();
-                break;
-        }
-        case 1: {
+        res = xfunc();
+        break;
+    }
+    case 1: {
 #ifdef __WIN32OS2__
-                DWORD (* WINAPI xfunc)(DWORD) = func;
+        DWORD (* WINAPI xfunc)(DWORD) = func;
 #else
-                DWORD (WINAPI *xfunc)(DWORD) = func;
+        DWORD (WINAPI *xfunc)(DWORD) = func;
 #endif
-                res = xfunc(args[0]);
-                break;
-        }
-        case 2: {
+        res = xfunc(args[0]);
+        break;
+    }
+    case 2: {
 #ifdef __WIN32OS2__
-                DWORD (* WINAPI xfunc)(DWORD,DWORD) = func;
+        DWORD (* WINAPI xfunc)(DWORD,DWORD) = func;
 #else
-                DWORD (WINAPI *xfunc)(DWORD,DWORD) = func;
+        DWORD (WINAPI *xfunc)(DWORD,DWORD) = func;
 #endif
-                res = xfunc(args[0],args[1]);
-                break;
-        }
-        case 3: {
+        res = xfunc(args[0],args[1]);
+        break;
+    }
+    case 3: {
 #ifdef __WIN32OS2__
-                DWORD (* WINAPI xfunc)(DWORD,DWORD,DWORD) = func;
+        DWORD (* WINAPI xfunc)(DWORD,DWORD,DWORD) = func;
 #else
-                DWORD (WINAPI *xfunc)(DWORD,DWORD,DWORD) = func;
+        DWORD (WINAPI *xfunc)(DWORD,DWORD,DWORD) = func;
 #endif
-                res = xfunc(args[0],args[1],args[2]);
-                break;
-        }
-        default:
-                FIXME("unsupported number of arguments %d in stdcall\n",nrargs);
-                res = -1;
-                break;
-        }
-        break;
+        res = xfunc(args[0],args[1],args[2]);
+        break;
+    }
     default:
-        FIXME("unsupported calling convention %d\n",callconv);
-        res = -1;
-        break;
+        FIXME("unsupported number of arguments %d in stdcall\n",nrargs);
+        res = -1;
+        break;
+    }
+    break;
+    default:
+    FIXME("unsupported calling convention %d\n",callconv);
+    res = -1;
+    break;
     }
     TRACE("returns %08lx\n",res);
@@ -2983 +2984 @@
 {
     ICOM_THIS( ITypeInfoImpl, iface);
-    TLBFuncDesc * pFDesc; 
-    TLBVarDesc * pVDesc; 
+    TLBFuncDesc * pFDesc;
+    TLBVarDesc * pVDesc;
     int i;
 
@@ -2993 +2994 @@
 
     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
-        if (pFDesc->funcdesc.memid == memid) {
-            if (pFDesc->funcdesc.invkind & (dwFlags & ~DISPATCH_METHOD))
-                break;
-        }
+    if (pFDesc->funcdesc.memid == memid) {
+        if (pFDesc->funcdesc.invkind & (dwFlags & ~DISPATCH_METHOD))
+        break;
+    }
     if (pFDesc) {
-        dump_TLBFuncDescOne(pFDesc);
-        switch (pFDesc->funcdesc.funckind) {
-        case FUNC_PUREVIRTUAL:
-        case FUNC_VIRTUAL: {
-            DWORD res;
-            DWORD *args = (DWORD*)HeapAlloc(GetProcessHeap(),0,sizeof(DWORD)*(pFDesc->funcdesc.cParams+1));
-            DWORD *args2 = (DWORD*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DWORD)*(pFDesc->funcdesc.cParams));
-            args[0] = (DWORD)pIUnk;
-
-            for (i=0;i<pFDesc->funcdesc.cParams;i++) {
-                if (i<pDispParams->cArgs) {
-                    TRACE("set %d to disparg type %d vs %d\n",i,
-                            V_VT(pDispParams->rgvarg+i),
-                            pFDesc->funcdesc.lprgelemdescParam[i].tdesc.vt
-                    );
-                    args[i+1] = V_UNION(pDispParams->rgvarg+i,lVal);
-                } else {
-                    TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i].tdesc);
-                    TRACE("set %d to pointer for get (type is %d)\n",i,tdesc->vt);
-                    /*FIXME: give pointers for the rest, so propertyget works*/
-                    args[i+1] = (DWORD)&args2[i];
-
-                    /* If pointer to variant, pass reference to variant
-                     * in result variant array.
-                     */
-                    if ((tdesc->vt == VT_PTR) &&
-                        (tdesc->u.lptdesc->vt == VT_VARIANT) &&
-                        pVarResult
-                    )
-                        args[i+1] = (DWORD)(pVarResult+(i-pDispParams->cArgs));
-                }
-            }
-            if (pFDesc->funcdesc.cParamsOpt)
-                FIXME("Does not support optional parameters (%d)\n",
-                        pFDesc->funcdesc.cParamsOpt
-                );
-
-            res = _invoke((*(DWORD***)pIUnk)[pFDesc->funcdesc.oVft/4],
-                    pFDesc->funcdesc.callconv,
-                    pFDesc->funcdesc.cParams+1,
-                    args
-            );
-            if (pVarResult && (dwFlags & (DISPATCH_PROPERTYGET))) {
-                for (i=0;i<pFDesc->funcdesc.cParams-pDispParams->cArgs;i++) {
-                    TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i].tdesc);
-                    /* If we are a pointer to a variant, we are done already */
-                    if ((tdesc->vt==VT_PTR)&&(tdesc->u.lptdesc->vt==VT_VARIANT))
-                        continue;
-
-                    VariantInit(&pVarResult[i]);
-                    V_UNION(pVarResult+i,intVal) = args2[i];
-
-                    if (tdesc->vt == VT_PTR)
-                        tdesc = tdesc->u.lptdesc;
-                    V_VT(pVarResult+i) = tdesc->vt;
-
-                    /* HACK: VB5 likes this.
-                     * I do not know why. There is 1 example in MSDN which uses
-                     * this which appears broken (mixes int vals and
-                     * IDispatch*.).
-                     */
-                    if ((tdesc->vt == VT_PTR) && (dwFlags & DISPATCH_METHOD))
-                        V_VT(pVarResult+i) = VT_DISPATCH;
-                    TRACE("storing into variant: [%d] type %d, val %08x\n",
-                            i,V_VT(pVarResult+i),V_UNION(pVarResult+i,intVal)
-                    );
-                }
-            }
-            HeapFree(GetProcessHeap(),0,args2);
-            HeapFree(GetProcessHeap(),0,args);
-            return S_OK;
-        }
-        case FUNC_DISPATCH:  {
-           IDispatch *disp;
-           HRESULT hr;
-
-           hr = IUnknown_QueryInterface((LPUNKNOWN)pIUnk,&IID_IDispatch,(LPVOID*)&disp);
-           if (hr) {
-               FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
-               return hr;
-           }
-           FIXME("Calling Invoke in IDispatch iface. untested!\n");
-           hr = IDispatch_Invoke(
-               disp,memid,&IID_NULL,LOCALE_USER_DEFAULT,dwFlags,pDispParams,
-               pVarResult,pExcepInfo,pArgErr
-           );
-           if (hr)
-               FIXME("IDispatch::Invoke failed with %08lx. (Could be not a real error?)\n",hr);
-           IDispatch_Release(disp);
-           return hr;
-        }
-        default:
-           FIXME("Unknown function invocation type %d\n",pFDesc->funcdesc.funckind);
-           return E_FAIL;
-        }
+    dump_TLBFuncDescOne(pFDesc);
+    switch (pFDesc->funcdesc.funckind) {
+    case FUNC_PUREVIRTUAL:
+    case FUNC_VIRTUAL: {
+        DWORD res;
+        DWORD *args = (DWORD*)HeapAlloc(GetProcessHeap(),0,sizeof(DWORD)*(pFDesc->funcdesc.cParams+1));
+        DWORD *args2 = (DWORD*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DWORD)*(pFDesc->funcdesc.cParams));
+        args[0] = (DWORD)pIUnk;
+
+        for (i=0;i<pFDesc->funcdesc.cParams;i++) {
+        if (i<pDispParams->cArgs) {
+            TRACE("set %d to disparg type %d vs %d\n",i,
+                V_VT(pDispParams->rgvarg+i),
+                pFDesc->funcdesc.lprgelemdescParam[i].tdesc.vt
+            );
+            args[i+1] = V_UNION(pDispParams->rgvarg+i,lVal);
+        } else {
+            TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i].tdesc);
+            TRACE("set %d to pointer for get (type is %d)\n",i,tdesc->vt);
+            /*FIXME: give pointers for the rest, so propertyget works*/
+            args[i+1] = (DWORD)&args2[i];
+
+            /* If pointer to variant, pass reference to variant
+             * in result variant array.
+             */
+            if ((tdesc->vt == VT_PTR) &&
+            (tdesc->u.lptdesc->vt == VT_VARIANT) &&
+            pVarResult
+            )
+            args[i+1] = (DWORD)(pVarResult+(i-pDispParams->cArgs));
+        }
+        }
+        if (pFDesc->funcdesc.cParamsOpt)
+        FIXME("Does not support optional parameters (%d)\n",
+            pFDesc->funcdesc.cParamsOpt
+        );
+
+        res = _invoke((*(DWORD***)pIUnk)[pFDesc->funcdesc.oVft/4],
+            pFDesc->funcdesc.callconv,
+            pFDesc->funcdesc.cParams+1,
+            args
+        );
+        if (pVarResult && (dwFlags & (DISPATCH_PROPERTYGET))) {
+        for (i=0;i<pFDesc->funcdesc.cParams-pDispParams->cArgs;i++) {
+            TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i].tdesc);
+            /* If we are a pointer to a variant, we are done already */
+            if ((tdesc->vt==VT_PTR)&&(tdesc->u.lptdesc->vt==VT_VARIANT))
+            continue;
+
+            VariantInit(&pVarResult[i]);
+            V_UNION(pVarResult+i,intVal) = args2[i];
+
+            if (tdesc->vt == VT_PTR)
+            tdesc = tdesc->u.lptdesc;
+            V_VT(pVarResult+i) = tdesc->vt;
+
+            /* HACK: VB5 likes this.
+             * I do not know why. There is 1 example in MSDN which uses
+             * this which appears broken (mixes int vals and
+             * IDispatch*.).
+             */
+            if ((tdesc->vt == VT_PTR) && (dwFlags & DISPATCH_METHOD))
+            V_VT(pVarResult+i) = VT_DISPATCH;
+            TRACE("storing into variant: [%d] type %d, val %08x\n",
+                i,V_VT(pVarResult+i),V_UNION(pVarResult+i,intVal)
+            );
+        }
+        }
+        HeapFree(GetProcessHeap(),0,args2);
+        HeapFree(GetProcessHeap(),0,args);
+        return S_OK;
+    }
+    case FUNC_DISPATCH:  {
+       IDispatch *disp;
+       HRESULT hr;
+
+       hr = IUnknown_QueryInterface((LPUNKNOWN)pIUnk,&IID_IDispatch,(LPVOID*)&disp);
+       if (hr) {
+           FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
+           return hr;
+       }
+       FIXME("Calling Invoke in IDispatch iface. untested!\n");
+       hr = IDispatch_Invoke(
+           disp,memid,&IID_NULL,LOCALE_USER_DEFAULT,dwFlags,pDispParams,
+           pVarResult,pExcepInfo,pArgErr
+       );
+       if (hr)
+           FIXME("IDispatch::Invoke failed with %08lx. (Could be not a real error?)\n",hr);
+       IDispatch_Release(disp);
+       return hr;
+    }
+    default:
+       FIXME("Unknown function invocation type %d\n",pFDesc->funcdesc.funckind);
+       return E_FAIL;
+    }
     } else {
-        FIXME("variable based invoking not supported yet.\n");
-        for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
-            if (pVDesc->vardesc.memid == memid) {
-                FIXME("varseek: Found memid name %s\n",debugstr_w(((LPWSTR)pVDesc->Name)));
-                dump_TLBVarDesc(pVDesc);
-                break;
-            }
-        }
+    FIXME("variable based invoking not supported yet.\n");
+    for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
+        if (pVDesc->vardesc.memid == memid) {
+        FIXME("varseek: Found memid name %s\n",debugstr_w(((LPWSTR)pVDesc->Name)));
+        dump_TLBVarDesc(pVDesc);
+        break;
+        }
+    }
     }
     FIXME("Did not find member id %d!\n",(int)memid);
@@ -3108 +3109 @@
 
 /* ITypeInfo::GetDocumentation
- * 
+ *
  * Retrieves the documentation string, the complete Help file name and path,
  * and the context ID for the Help topic for a specified type description.
@@ -3117 +3118 @@
 {
     ICOM_THIS( ITypeInfoImpl, iface);
-    TLBFuncDesc * pFDesc; 
-    TLBVarDesc * pVDesc; 
+    TLBFuncDesc * pFDesc;
+    TLBVarDesc * pVDesc;
     TRACE("(%p) memid %ld Name(%p) DocString(%p)"
           " HelpContext(%p) HelpFile(%p)\n",
@@ -3146 +3147 @@
 
 /*  ITypeInfo::GetDllEntry
- * 
+ *
  * Retrieves a description or specification of an entry point for a function
  * in a DLL.
@@ -3160 +3161 @@
 
 /* ITypeInfo::GetRefTypeInfo
- * 
+ *
  * If a type description references other type descriptions, it retrieves
  * the referenced type descriptions.
  */
 static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
-        ITypeInfo2 *iface,
+    ITypeInfo2 *iface,
         HREFTYPE hRefType,
-        ITypeInfo  **ppTInfo)
+    ITypeInfo  **ppTInfo)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
@@ -3183 +3184 @@
       }
     }
-        else if (hRefType == -1 && 
+    else if (hRefType == -1 &&
              (((ITypeInfoImpl*) This)->TypeAttr.typekind   == TKIND_DISPATCH) &&
              (((ITypeInfoImpl*) This)->TypeAttr.wTypeFlags &  TYPEFLAG_FDUAL))
     {
-          /* when we meet a DUAL dispinterface, we must create the interface 
-          * version of it.
-          */
-          ITypeInfoImpl* pTypeInfoImpl = (ITypeInfoImpl*) ITypeInfo_Constructor();
-
-                
-          /* the interface version contains the same information as the dispinterface
-           * copy the contents of the structs.
-           */
-          *pTypeInfoImpl = *This;
-          pTypeInfoImpl->ref = 1;
-                
-          /* change the type to interface */
-          pTypeInfoImpl->TypeAttr.typekind = TKIND_INTERFACE;
-                
+      /* when we meet a DUAL dispinterface, we must create the interface
+      * version of it.
+      */
+      ITypeInfoImpl* pTypeInfoImpl = (ITypeInfoImpl*) ITypeInfo_Constructor();
+
+
+      /* the interface version contains the same information as the dispinterface
+       * copy the contents of the structs.
+       */
+      *pTypeInfoImpl = *This;
+      pTypeInfoImpl->ref = 1;
+
+      /* change the type to interface */
+      pTypeInfoImpl->TypeAttr.typekind = TKIND_INTERFACE;
+
       *ppTInfo = (ITypeInfo*) pTypeInfoImpl;
 
-          ITypeInfo_AddRef((ITypeInfo*) pTypeInfoImpl);
+      ITypeInfo_AddRef((ITypeInfo*) pTypeInfoImpl);
 
       result = S_OK;
-        }
+    }
     else
     {
       /* imported type lib */
       TLBRefType   *pRefType     = NULL;
-      
+
       /* search in implemented types */
-      for( pRefType = This->impltypelist; 
+      for( pRefType = This->impltypelist;
            pRefType && (pRefType->reference != hRefType);
            pRefType = pRefType->next);
-      
+
       if(!pRefType)
-      {                       
+      {
         TYPEATTR*       pMyTypeAttr  = &This->TypeAttr;
         unsigned short  cFuncs       = pMyTypeAttr->cFuncs;
         unsigned short  cVars        = pMyTypeAttr->cVars;
-        
-        /* search in arguments */      
+
+        /* search in arguments */
         if (cFuncs > 0)
         {
           unsigned short  cFuncIndex   = 0;
-  
+
           TLBFuncDesc*    pCurrFunc    = This->funclist;
-          
+
           for (cFuncIndex = 0; !pRefType && cFuncIndex < cFuncs ; ++cFuncIndex)
           {
             FUNCDESC*  pCurrFuncDesc = &pCurrFunc->funcdesc;
-            
+
             short      cParams       = pCurrFuncDesc->cParams;
             short      cParamIndex   = 0;
-              
-            for (cParamIndex = 0 ; 
-                 !pRefType && cParamIndex < cParams ; 
+
+            for (cParamIndex = 0 ;
+                 !pRefType && cParamIndex < cParams ;
                  ++cParamIndex)
             {
               TLBParDesc* pCurrParamDesc = &(pCurrFunc->pParamDesc[cParamIndex]);
-             
+
               if ( pCurrParamDesc->pRefType && pCurrParamDesc->pRefType->reference == hRefType)
               {
@@ -3250 +3251 @@
               }
             }
-            
+
             pCurrFunc = pCurrFunc->next;
           }
@@ -3261 +3262 @@
         }
       }
-      
+
       /* href-referenced typeinfo found! */
       if (pRefType || hRefType == -1)
       {
         ITypeLibImpl *pTypeLib = pRefType->pImpTLInfo->pImpTypeLib;
-        
-        if(pTypeLib) 
+
+        if(pTypeLib)
         {
           TRACE("typeinfo in imported typelib that is already loaded\n");
-                  
-          result = ITypeLib2_GetTypeInfoOfGuid((LPTYPELIB)pTypeLib, 
-                                           &pRefType->guid, 
+
+          result = ITypeLib2_GetTypeInfoOfGuid((LPTYPELIB)pTypeLib,
+                                           &pRefType->guid,
                                            ppTInfo);
         }
@@ -3282 +3283 @@
                       pRefType->pImpTLInfo->lcid,
                       (LPTYPELIB *)&pTypeLib);
-          
+
           if(!SUCCEEDED(result))
-                  {
+          {
             BSTR libnam=SysAllocString(pRefType->pImpTLInfo->name);
             TRACE("typeinfo in imported typelib that isn't already loaded\n");
             result=LoadTypeLib(libnam, (LPTYPELIB *)&pTypeLib);
             SysFreeString(libnam);
-          } 
+          }
           if(SUCCEEDED(result))
           {
             result=ITypeLib2_GetTypeInfoOfGuid((LPTYPELIB)pTypeLib, &pRefType->guid, ppTInfo);
             pRefType->pImpTLInfo->pImpTypeLib = pTypeLib;
-                        ITypeLib2_AddRef((ITypeLib*) pTypeLib);
-          }        
+            ITypeLib2_AddRef((ITypeLib*) pTypeLib);
+          }
         }
       }
@@ -3306 +3307 @@
 
 /* ITypeInfo::AddressOfMember
- * 
+ *
  * Retrieves the addresses of static functions or variables, such as those
  * defined in a DLL.
@@ -3319 +3320 @@
 
 /* ITypeInfo::CreateInstance
- * 
- * Creates a new instance of a type that describes a component object class 
+ *
+ * Creates a new instance of a type that describes a component object class
  * (coclass).
  */
-static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface, 
-        IUnknown *pUnk, REFIID riid, VOID  **ppvObj) 
+static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface,
+        IUnknown *pUnk, REFIID riid, VOID  **ppvObj)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
@@ -3336 +3337 @@
  */
 static HRESULT WINAPI ITypeInfo_fnGetMops( ITypeInfo2 *iface, MEMBERID memid,
-                                BSTR  *pBstrMops)
+                BSTR  *pBstrMops)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
@@ -3344 +3345 @@
 
 /* ITypeInfo::GetContainingTypeLib
- * 
+ *
  * Retrieves the containing type library and the index of the type description
  * within that type library.
@@ -3379 +3380 @@
  */
 static HRESULT WINAPI ITypeInfo_fnReleaseFuncDesc(
-        ITypeInfo2 *iface,
+    ITypeInfo2 *iface,
         FUNCDESC *pFuncDesc)
 {
@@ -3417 +3418 @@
  * Returns the type flags without any allocations. This returns a DWORD type
  * flag, which expands the type flags without growing the TYPEATTR (type
- * attribute). 
+ * attribute).
  *
  */
@@ -3442 +3443 @@
     HRESULT result;
     /* FIXME: should check for invKind??? */
-    for(i=0, pFuncInfo=This->funclist;pFuncInfo && 
+    for(i=0, pFuncInfo=This->funclist;pFuncInfo &&
             memid != pFuncInfo->funcdesc.memid; i++, pFuncInfo=pFuncInfo->next);
     if(pFuncInfo){
@@ -3459 +3460 @@
  *
  * Binds to a specific member based on a known DISPID, where the member name
- * is not known (for example, when binding to a default member). 
+ * is not known (for example, when binding to a default member).
  *
  */
@@ -3469 +3470 @@
     int i;
     HRESULT result;
-    for(i=0, pVarInfo=This->varlist; pVarInfo && 
+    for(i=0, pVarInfo=This->varlist; pVarInfo &&
             memid != pVarInfo->vardesc.memid; i++, pVarInfo=pVarInfo->next)
         ;
@@ -3489 +3490 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
-        ITypeInfo2 * iface,
-        REFGUID guid,
-        VARIANT *pVarVal)
+    ITypeInfo2 * iface,
+    REFGUID guid,
+    VARIANT *pVarVal)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
@@ -3515 +3516 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
-        ITypeInfo2 * iface,
-        UINT index,
-        REFGUID guid,
-        VARIANT *pVarVal)
+    ITypeInfo2 * iface,
+    UINT index,
+    REFGUID guid,
+    VARIANT *pVarVal)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData=NULL;
-    TLBFuncDesc * pFDesc; 
+    TLBFuncDesc * pFDesc;
     int i;
     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
@@ -3546 +3547 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
-        ITypeInfo2 * iface,
-        UINT indexFunc,
-        UINT indexParam,
-        REFGUID guid,
-        VARIANT *pVarVal)
-{   
+    ITypeInfo2 * iface,
+    UINT indexFunc,
+    UINT indexParam,
+    REFGUID guid,
+    VARIANT *pVarVal)
+{
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData=NULL;
-    TLBFuncDesc * pFDesc; 
+    TLBFuncDesc * pFDesc;
     int i;
 
@@ -3560 +3561 @@
 
     if(pFDesc && indexParam >=0 && indexParam<pFDesc->funcdesc.cParams)
-        for(pCData=pFDesc->pParamDesc[indexParam].pCustData; pCData; 
+        for(pCData=pFDesc->pParamDesc[indexParam].pCustData; pCData;
                 pCData = pCData->next)
             if( IsEqualIID(guid, &pCData->guid)) break;
@@ -3580 +3581 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
-        ITypeInfo2 * iface,
-        UINT index,
-        REFGUID guid,
-        VARIANT *pVarVal)
-{   
+    ITypeInfo2 * iface,
+    UINT index,
+    REFGUID guid,
+    VARIANT *pVarVal)
+{
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData=NULL;
-    TLBVarDesc * pVDesc; 
+    TLBVarDesc * pVDesc;
     int i;
 
@@ -3616 +3617 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
-        ITypeInfo2 * iface,
-        UINT index,
-        REFGUID guid,
-        VARIANT *pVarVal)
-{   
+    ITypeInfo2 * iface,
+    UINT index,
+    REFGUID guid,
+    VARIANT *pVarVal)
+{
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData=NULL;
-    TLBRefType * pRDesc; 
+    TLBRefType * pRDesc;
     int i;
 
@@ -3635 +3636 @@
       }
     }
-    
+
     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
 
@@ -3648 +3649 @@
 
 /* ITypeInfo2::GetDocumentation2
- * 
+ *
  * Retrieves the documentation string, the complete Help file name and path,
  * the localization context to use, and the context ID for the library Help
@@ -3655 +3656 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
-        ITypeInfo2 * iface,
-        MEMBERID memid,
-        LCID lcid,
-        BSTR *pbstrHelpString,
-        DWORD *pdwHelpStringContext,
-        BSTR *pbstrHelpStringDll)
+    ITypeInfo2 * iface,
+    MEMBERID memid,
+    LCID lcid,
+    BSTR *pbstrHelpString,
+    DWORD *pdwHelpStringContext,
+    BSTR *pbstrHelpStringDll)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
-    TLBFuncDesc * pFDesc; 
-    TLBVarDesc * pVDesc; 
+    TLBFuncDesc * pFDesc;
+    TLBVarDesc * pVDesc;
     TRACE("(%p) memid %ld lcid(0x%lx)  HelpString(%p) "
           "HelpStringContext(%p) HelpStringDll(%p)\n",
@@ -3711 +3712 @@
 /* ITypeInfo2::GetAllCustData
  *
- * Gets all custom data items for the Type info. 
+ * Gets all custom data items for the Type info.
  *
  */
 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
-        ITypeInfo2 * iface,
-        CUSTDATA *pCustData)
+    ITypeInfo2 * iface,
+    CUSTDATA *pCustData)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
@@ -3722 +3723 @@
     int i;
 
-    TRACE("(%p) returning %d items\n", This, This->ctCustData); 
+    TRACE("(%p) returning %d items\n", This, This->ctCustData);
 
     pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
@@ -3744 +3745 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
-        ITypeInfo2 * iface,
-        UINT index,
-        CUSTDATA *pCustData)
+    ITypeInfo2 * iface,
+    UINT index,
+    CUSTDATA *pCustData)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData;
-    TLBFuncDesc * pFDesc; 
+    TLBFuncDesc * pFDesc;
     int i;
-    TRACE("(%p) index %d\n", This, index); 
+    TRACE("(%p) index %d\n", This, index);
     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
             pFDesc=pFDesc->next)
@@ -3786 +3787 @@
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData=NULL;
-    TLBFuncDesc * pFDesc; 
+    TLBFuncDesc * pFDesc;
     int i;
-    TRACE("(%p) index %d\n", This, indexFunc); 
+    TRACE("(%p) index %d\n", This, indexFunc);
     for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,
             pFDesc=pFDesc->next)
         ;
     if(pFDesc && indexParam >=0 && indexParam<pFDesc->funcdesc.cParams){
-        pCustData->prgCustData = 
+        pCustData->prgCustData =
             TLB_Alloc(pFDesc->pParamDesc[indexParam].ctCustData *
                     sizeof(CUSTDATAITEM));
@@ -3823 +3824 @@
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData;
-    TLBVarDesc * pVDesc; 
+    TLBVarDesc * pVDesc;
     int i;
-    TRACE("(%p) index %d\n", This, index); 
+    TRACE("(%p) index %d\n", This, index);
     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++,
             pVDesc=pVDesc->next)
@@ -3855 +3856 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
-        ITypeInfo2 * iface,
-        UINT index,
-        CUSTDATA *pCustData)
+    ITypeInfo2 * iface,
+    UINT index,
+    CUSTDATA *pCustData)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData;
-    TLBRefType * pRDesc; 
+    TLBRefType * pRDesc;
     int i;
-    TRACE("(%p) index %d\n", This, index); 
+    TRACE("(%p) index %d\n", This, index);
     for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++,
             pRDesc=pRDesc->next)
@@ -3887 +3888 @@
 }
 
-static ICOM_VTABLE(ITypeInfo2) tinfvt = 
+static ICOM_VTABLE(ITypeInfo2) tinfvt =
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE

trunk/src/oleaut32/variant.c

@@ +1 @@
+/* $Id: variant.c,v 1.5 2001-09-05 13:19:02 bird Exp $ */
 /*
  * VARIANT
@@ -28 +29 @@
 
 #include "config.h"
- 
+
 #include <string.h>
 #include <stdlib.h>
@@ -106 +107 @@
 
 /******************************************************************************
- *         DateTimeStringToTm   [INTERNAL]
+ *     DateTimeStringToTm   [INTERNAL]
  *
  * Converts a string representation of a date and/or time to a tm structure.
@@ -122 +123 @@
 static BOOL DateTimeStringToTm( OLECHAR* strIn, DWORD dwFlags, struct tm* pTm )
 {
-        BOOL res = FALSE;
-        double          fsec;
-        int             tzp;
-        int             dtype;
-        int             nf;
-        char       *field[MAXDATEFIELDS];
-        int             ftype[MAXDATEFIELDS];
-        char            lowstr[MAXDATELEN + 1];
-        char* strDateTime = NULL;
-
-        /* Convert the string to ASCII since this is the only format
-         * postgesql can handle.
-         */
-        strDateTime = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
-
-        if( strDateTime != NULL )
-        {
-                /* Make sure we don't go over the maximum length
-                 * accepted by postgesql.
-                 */
-                if( strlen( strDateTime ) <= MAXDATELEN )
-                {
-                        if( ParseDateTime( strDateTime, lowstr, field, ftype, MAXDATEFIELDS, &nf) == 0 )
-                        {
-                                if( dwFlags & VAR_DATEVALUEONLY )
-                                {
-                                        /* Get the date information.
-                                         * It returns 0 if date information was
-                                         * present and 1 if only time information was present.
-                                         * -1 if an error occures.
-                                         */
-                                        if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) == 0 )
-                                        {
-                                                /* Eliminate the time information since we
-                                                 * were asked to get date information only.
-                                                 */
-                                                pTm->tm_sec = 0;
-                                                pTm->tm_min = 0;
-                                                pTm->tm_hour = 0;
-                                                res = TRUE;
-                                        }
-                                }
-                                if( dwFlags & VAR_TIMEVALUEONLY )
-                                {
-                                        /* Get time information only.
-                                         */
-                                        if( DecodeTimeOnly(field, ftype, nf, &dtype, pTm, &fsec) == 0 )
-                                        {
-                                                res = TRUE;
-                                        }
-                                }
-                                else
-                                {
-                                        /* Get both date and time information.
-                                         * It returns 0 if date information was
-                                         * present and 1 if only time information was present.
-                                         * -1 if an error occures.
-                                         */
-                                        if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) != -1 )
-                                        {
-                                                res = TRUE;
-                                        }
-                                }
-                        }
-                }
-                HeapFree( GetProcessHeap(), 0, strDateTime );
-        }
-
-        return res;
-}
-
-
-
-
-
-
-/******************************************************************************
- *         TmToDATE     [INTERNAL]
+    BOOL res = FALSE;
+    double      fsec;
+    int         tzp;
+    int         dtype;
+    int         nf;
+    char       *field[MAXDATEFIELDS];
+    int         ftype[MAXDATEFIELDS];
+    char        lowstr[MAXDATELEN + 1];
+    char* strDateTime = NULL;
+
+    /* Convert the string to ASCII since this is the only format
+     * postgesql can handle.
+     */
+    strDateTime = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
+
+    if( strDateTime != NULL )
+    {
+        /* Make sure we don't go over the maximum length
+         * accepted by postgesql.
+         */
+        if( strlen( strDateTime ) <= MAXDATELEN )
+        {
+            if( ParseDateTime( strDateTime, lowstr, field, ftype, MAXDATEFIELDS, &nf) == 0 )
+            {
+                if( dwFlags & VAR_DATEVALUEONLY )
+                {
+                    /* Get the date information.
+                     * It returns 0 if date information was
+                     * present and 1 if only time information was present.
+                     * -1 if an error occures.
+                     */
+                    if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) == 0 )
+                    {
+                        /* Eliminate the time information since we
+                         * were asked to get date information only.
+                         */
+                        pTm->tm_sec = 0;
+                        pTm->tm_min = 0;
+                        pTm->tm_hour = 0;
+                        res = TRUE;
+                    }
+                }
+                if( dwFlags & VAR_TIMEVALUEONLY )
+                {
+                    /* Get time information only.
+                     */
+                    if( DecodeTimeOnly(field, ftype, nf, &dtype, pTm, &fsec) == 0 )
+                    {
+                        res = TRUE;
+                    }
+                }
+                else
+                {
+                    /* Get both date and time information.
+                     * It returns 0 if date information was
+                     * present and 1 if only time information was present.
+                     * -1 if an error occures.
+                     */
+                    if( DecodeDateTime(field, ftype, nf, &dtype, pTm, &fsec, &tzp) != -1 )
+                    {
+                        res = TRUE;
+                    }
+                }
+            }
+        }
+        HeapFree( GetProcessHeap(), 0, strDateTime );
+    }
+
+    return res;
+}
+
+
+
+
+
+
+/******************************************************************************
+ *     TmToDATE     [INTERNAL]
  *
  * The date is implemented using an 8 byte floating-point number.
@@ -216 +217 @@
  * The tm structure is as follows:
  * struct tm {
- *                int tm_sec;      seconds after the minute - [0,59]
- *                int tm_min;      minutes after the hour - [0,59]
- *                int tm_hour;     hours since midnight - [0,23]
- *                int tm_mday;     day of the month - [1,31]
- *                int tm_mon;      months since January - [0,11]
- *                int tm_year;     years
- *                int tm_wday;     days since Sunday - [0,6]
- *                int tm_yday;     days since January 1 - [0,365]
- *                int tm_isdst;    daylight savings time flag
- *                };
+ *        int tm_sec;      seconds after the minute - [0,59]
+ *        int tm_min;      minutes after the hour - [0,59]
+ *        int tm_hour;     hours since midnight - [0,23]
+ *        int tm_mday;     day of the month - [1,31]
+ *        int tm_mon;      months since January - [0,11]
+ *        int tm_year;     years
+ *        int tm_wday;     days since Sunday - [0,6]
+ *        int tm_yday;     days since January 1 - [0,365]
+ *        int tm_isdst;    daylight savings time flag
+ *        };
  *
  * Note: This function does not use the tm_wday, tm_yday, tm_wday,
@@ -235 +236 @@
 static BOOL TmToDATE( struct tm* pTm, DATE *pDateOut )
 {
-        if( (pTm->tm_year - 1900) >= 0 )
-        {
-                int leapYear = 0;
-                
-                /* Start at 1. This is the way DATE is defined.
-                 * January 1, 1900 at Midnight is 1.00.
-                 * January 1, 1900 at 6AM is 1.25.
-                 * and so on.
-                 */
-                *pDateOut = 1;
-
-                /* Add the number of days corresponding to
-                 * tm_year.
-                 */
-                *pDateOut += (pTm->tm_year - 1900) * 365;
-
-                /* Add the leap days in the previous years between now and 1900.
-                 * Note a leap year is one that is a multiple of 4
-                 * but not of a 100.  Except if it is a multiple of
-                 * 400 then it is a leap year.
-                 */
-                *pDateOut += ( (pTm->tm_year - 1) / 4 ) - ( 1900 / 4 );
-                *pDateOut -= ( (pTm->tm_year - 1) / 100 ) - ( 1900 / 100 );
-                *pDateOut += ( (pTm->tm_year - 1) / 400 ) - ( 1900 / 400 );
-
-                /* Set the leap year flag if the
-                 * current year specified by tm_year is a
-                 * leap year. This will be used to add a day
-                 * to the day count.
-                 */
-                if( isleap( pTm->tm_year ) )
-                        leapYear = 1;
-                
-                /* Add the number of days corresponding to
-                 * the month.
-                 */
-                switch( pTm->tm_mon )
-                {
-                case 2:
-                        *pDateOut += 31;
-                        break;
-                case 3:
-                        *pDateOut += ( 59 + leapYear );
-                        break;
-                case 4:
-                        *pDateOut += ( 90 + leapYear );
-                        break;
-                case 5:
-                        *pDateOut += ( 120 + leapYear );
-                        break;
-                case 6:
-                        *pDateOut += ( 151 + leapYear );
-                        break;
-                case 7:
-                        *pDateOut += ( 181 + leapYear );
-                        break;
-                case 8:
-                        *pDateOut += ( 212 + leapYear );
-                        break;
-                case 9:
-                        *pDateOut += ( 243 + leapYear );
-                        break;
-                case 10:
-                        *pDateOut += ( 273 + leapYear );
-                        break;
-                case 11:
-                        *pDateOut += ( 304 + leapYear );
-                        break;
-                case 12:
-                        *pDateOut += ( 334 + leapYear );
-                        break;
-                }
-                /* Add the number of days in this month.
-                 */
-                *pDateOut += pTm->tm_mday;
-        
-                /* Add the number of seconds, minutes, and hours
-                 * to the DATE. Note these are the fracionnal part
-                 * of the DATE so seconds / number of seconds in a day.
-                 */
-                *pDateOut += pTm->tm_hour / 24.0;
-                *pDateOut += pTm->tm_min / 1440.0;
-                *pDateOut += pTm->tm_sec / 86400.0;
-                return TRUE;
-        }
-        return FALSE;
-}
-
-/******************************************************************************
- *         DateToTm     [INTERNAL]
+    if( (pTm->tm_year - 1900) >= 0 )
+    {
+        int leapYear = 0;
+
+        /* Start at 1. This is the way DATE is defined.
+         * January 1, 1900 at Midnight is 1.00.
+         * January 1, 1900 at 6AM is 1.25.
+         * and so on.
+         */
+        *pDateOut = 1;
+
+        /* Add the number of days corresponding to
+         * tm_year.
+         */
+        *pDateOut += (pTm->tm_year - 1900) * 365;
+
+        /* Add the leap days in the previous years between now and 1900.
+         * Note a leap year is one that is a multiple of 4
+         * but not of a 100.  Except if it is a multiple of
+         * 400 then it is a leap year.
+         */
+        *pDateOut += ( (pTm->tm_year - 1) / 4 ) - ( 1900 / 4 );
+        *pDateOut -= ( (pTm->tm_year - 1) / 100 ) - ( 1900 / 100 );
+        *pDateOut += ( (pTm->tm_year - 1) / 400 ) - ( 1900 / 400 );
+
+        /* Set the leap year flag if the
+         * current year specified by tm_year is a
+         * leap year. This will be used to add a day
+         * to the day count.
+         */
+        if( isleap( pTm->tm_year ) )
+            leapYear = 1;
+
+        /* Add the number of days corresponding to
+         * the month.
+         */
+        switch( pTm->tm_mon )
+        {
+        case 2:
+            *pDateOut += 31;
+            break;
+        case 3:
+            *pDateOut += ( 59 + leapYear );
+            break;
+        case 4:
+            *pDateOut += ( 90 + leapYear );
+            break;
+        case 5:
+            *pDateOut += ( 120 + leapYear );
+            break;
+        case 6:
+            *pDateOut += ( 151 + leapYear );
+            break;
+        case 7:
+            *pDateOut += ( 181 + leapYear );
+            break;
+        case 8:
+            *pDateOut += ( 212 + leapYear );
+            break;
+        case 9:
+            *pDateOut += ( 243 + leapYear );
+            break;
+        case 10:
+            *pDateOut += ( 273 + leapYear );
+            break;
+        case 11:
+            *pDateOut += ( 304 + leapYear );
+            break;
+        case 12:
+            *pDateOut += ( 334 + leapYear );
+            break;
+        }
+        /* Add the number of days in this month.
+         */
+        *pDateOut += pTm->tm_mday;
+
+        /* Add the number of seconds, minutes, and hours
+         * to the DATE. Note these are the fracionnal part
+         * of the DATE so seconds / number of seconds in a day.
+         */
+        *pDateOut += pTm->tm_hour / 24.0;
+        *pDateOut += pTm->tm_min / 1440.0;
+        *pDateOut += pTm->tm_sec / 86400.0;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+/******************************************************************************
+ *     DateToTm     [INTERNAL]
  *
  * This function converts a windows DATE to a tm structure.
@@ -339 +340 @@
 static BOOL DateToTm( DATE dateIn, DWORD dwFlags, struct tm* pTm )
 {
-        /* Do not process dates smaller than January 1, 1900.
-         * Which corresponds to 2.0 in the windows DATE format.
-         */
-        if( dateIn >= 2.0 )
-        {
-                double decimalPart = 0.0;
-                double wholePart = 0.0;
-
-                memset(pTm,0,sizeof(*pTm));
-        
-                /* Because of the nature of DATE format which
-                 * associates 2.0 to January 1, 1900. We will
-                 * remove 1.0 from the whole part of the DATE
-                 * so that in the following code 1.0
-                 * will correspond to January 1, 1900.
-                 * This simplifies the processing of the DATE value.
-                 */
-                dateIn -= 1.0;
-
-                wholePart = (double) floor( dateIn );
-                decimalPart = fmod( dateIn, wholePart );
-
-                if( !(dwFlags & VAR_TIMEVALUEONLY) )
-                {
-                        int nDay = 0;
-                        int leapYear = 0;
-                        double yearsSince1900 = 0;
-                        /* Start at 1900, this is where the DATE time 0.0 starts.
-                         */
-                        pTm->tm_year = 1900;
-                        /* find in what year the day in the "wholePart" falls into.
-                         * add the value to the year field.
-                         */
-                        yearsSince1900 = floor( (wholePart / DAYS_IN_ONE_YEAR) + 0.001 );
-                        pTm->tm_year += yearsSince1900;
-                        /* determine if this is a leap year.
-                         */
-                        if( isleap( pTm->tm_year ) )
-                        {
-                                leapYear = 1;
-                                wholePart++;
-                        }
-
-                        /* find what day of that year the "wholePart" corresponds to.
-                         * Note: nDay is in [1-366] format
-                         */
-                        nDay = (int) ( wholePart - floor( yearsSince1900 * DAYS_IN_ONE_YEAR ) );
-                        /* Set the tm_yday value.
-                         * Note: The day must be converted from [1-366] to [0-365]
-                         */
-                        /*pTm->tm_yday = nDay - 1;*/
-                        /* find which month this day corresponds to.
-                         */
-                        if( nDay <= 31 )
-                        {
-                                pTm->tm_mday = nDay;
-                                pTm->tm_mon = 0;
-                        }
-                        else if( nDay <= ( 59 + leapYear ) )
-                        {
-                                pTm->tm_mday = nDay - 31;
-                                pTm->tm_mon = 1;
-                        }
-                        else if( nDay <= ( 90 + leapYear ) )
-                        {
-                                pTm->tm_mday = nDay - ( 59 + leapYear );
-                                pTm->tm_mon = 2;
-                        }
-                        else if( nDay <= ( 120 + leapYear ) )
-                        {
-                                pTm->tm_mday = nDay - ( 90 + leapYear );
-                                pTm->tm_mon = 3;
-                        }
-                        else if( nDay <= ( 151 + leapYear ) )
-                        {
-                                pTm->tm_mday = nDay - ( 120 + leapYear );
-                                pTm->tm_mon = 4;
-                        }
-                        else if( nDay <= ( 181 + leapYear ) )
-                        {
-                                pTm->tm_mday = nDay - ( 151 + leapYear );
-                                pTm->tm_mon = 5;
-                        }
-                        else if( nDay <= ( 212 + leapYear ) )
-                        {
-                                pTm->tm_mday = nDay - ( 181 + leapYear );
-                                pTm->tm_mon = 6;
-                        }
-                        else if( nDay <= ( 243 + leapYear ) )
-                        {
-                                pTm->tm_mday = nDay - ( 212 + leapYear );
-                                pTm->tm_mon = 7;
-                        }
-                        else if( nDay <= ( 273 + leapYear ) )
-                        {
-                                pTm->tm_mday = nDay - ( 243 + leapYear );
-                                pTm->tm_mon = 8;
-                        }
-                        else if( nDay <= ( 304 + leapYear ) )
-                        {
-                                pTm->tm_mday = nDay - ( 273 + leapYear );
-                                pTm->tm_mon = 9;
-                        }
-                        else if( nDay <= ( 334 + leapYear ) )
-                        {
-                                pTm->tm_mday = nDay - ( 304 + leapYear );
-                                pTm->tm_mon = 10;
-                        }
-                        else if( nDay <= ( 365 + leapYear ) )
-                        {
-                                pTm->tm_mday = nDay - ( 334 + leapYear );
-                                pTm->tm_mon = 11;
-                        }
-                }
-                if( !(dwFlags & VAR_DATEVALUEONLY) )
-                {
-                        /* find the number of seconds in this day.
-                         * fractional part times, hours, minutes, seconds.
-                         */
-                        pTm->tm_hour = (int) ( decimalPart * 24 );
-                        pTm->tm_min = (int) ( ( ( decimalPart * 24 ) - pTm->tm_hour ) * 60 );
-                        pTm->tm_sec = (int) ( ( ( decimalPart * 24 * 60 ) - ( pTm->tm_hour * 60 ) - pTm->tm_min ) * 60 );
-                }
-                return TRUE;
-        }
-        return FALSE;
-}
-
-
-
-/******************************************************************************
- *         SizeOfVariantData    [INTERNAL]
+    /* Do not process dates smaller than January 1, 1900.
+     * Which corresponds to 2.0 in the windows DATE format.
+     */
+    if( dateIn >= 2.0 )
+    {
+        double decimalPart = 0.0;
+        double wholePart = 0.0;
+
+        memset(pTm,0,sizeof(*pTm));
+
+        /* Because of the nature of DATE format which
+         * associates 2.0 to January 1, 1900. We will
+         * remove 1.0 from the whole part of the DATE
+         * so that in the following code 1.0
+         * will correspond to January 1, 1900.
+         * This simplifies the processing of the DATE value.
+         */
+        dateIn -= 1.0;
+
+        wholePart = (double) floor( dateIn );
+        decimalPart = fmod( dateIn, wholePart );
+
+        if( !(dwFlags & VAR_TIMEVALUEONLY) )
+        {
+            int nDay = 0;
+            int leapYear = 0;
+            double yearsSince1900 = 0;
+            /* Start at 1900, this is where the DATE time 0.0 starts.
+             */
+            pTm->tm_year = 1900;
+            /* find in what year the day in the "wholePart" falls into.
+             * add the value to the year field.
+             */
+            yearsSince1900 = floor( (wholePart / DAYS_IN_ONE_YEAR) + 0.001 );
+            pTm->tm_year += yearsSince1900;
+            /* determine if this is a leap year.
+             */
+            if( isleap( pTm->tm_year ) )
+            {
+                leapYear = 1;
+                wholePart++;
+            }
+
+            /* find what day of that year the "wholePart" corresponds to.
+             * Note: nDay is in [1-366] format
+             */
+            nDay = (int) ( wholePart - floor( yearsSince1900 * DAYS_IN_ONE_YEAR ) );
+            /* Set the tm_yday value.
+             * Note: The day must be converted from [1-366] to [0-365]
+             */
+            /*pTm->tm_yday = nDay - 1;*/
+            /* find which month this day corresponds to.
+             */
+            if( nDay <= 31 )
+            {
+                pTm->tm_mday = nDay;
+                pTm->tm_mon = 0;
+            }
+            else if( nDay <= ( 59 + leapYear ) )
+            {
+                pTm->tm_mday = nDay - 31;
+                pTm->tm_mon = 1;
+            }
+            else if( nDay <= ( 90 + leapYear ) )
+            {
+                pTm->tm_mday = nDay - ( 59 + leapYear );
+                pTm->tm_mon = 2;
+            }
+            else if( nDay <= ( 120 + leapYear ) )
+            {
+                pTm->tm_mday = nDay - ( 90 + leapYear );
+                pTm->tm_mon = 3;
+            }
+            else if( nDay <= ( 151 + leapYear ) )
+            {
+                pTm->tm_mday = nDay - ( 120 + leapYear );
+                pTm->tm_mon = 4;
+            }
+            else if( nDay <= ( 181 + leapYear ) )
+            {
+                pTm->tm_mday = nDay - ( 151 + leapYear );
+                pTm->tm_mon = 5;
+            }
+            else if( nDay <= ( 212 + leapYear ) )
+            {
+                pTm->tm_mday = nDay - ( 181 + leapYear );
+                pTm->tm_mon = 6;
+            }
+            else if( nDay <= ( 243 + leapYear ) )
+            {
+                pTm->tm_mday = nDay - ( 212 + leapYear );
+                pTm->tm_mon = 7;
+            }
+            else if( nDay <= ( 273 + leapYear ) )
+            {
+                pTm->tm_mday = nDay - ( 243 + leapYear );
+                pTm->tm_mon = 8;
+            }
+            else if( nDay <= ( 304 + leapYear ) )
+            {
+                pTm->tm_mday = nDay - ( 273 + leapYear );
+                pTm->tm_mon = 9;
+            }
+            else if( nDay <= ( 334 + leapYear ) )
+            {
+                pTm->tm_mday = nDay - ( 304 + leapYear );
+                pTm->tm_mon = 10;
+            }
+            else if( nDay <= ( 365 + leapYear ) )
+            {
+                pTm->tm_mday = nDay - ( 334 + leapYear );
+                pTm->tm_mon = 11;
+            }
+        }
+        if( !(dwFlags & VAR_DATEVALUEONLY) )
+        {
+            /* find the number of seconds in this day.
+             * fractional part times, hours, minutes, seconds.
+             */
+            pTm->tm_hour = (int) ( decimalPart * 24 );
+            pTm->tm_min = (int) ( ( ( decimalPart * 24 ) - pTm->tm_hour ) * 60 );
+            pTm->tm_sec = (int) ( ( ( decimalPart * 24 * 60 ) - ( pTm->tm_hour * 60 ) - pTm->tm_min ) * 60 );
+        }
+        return TRUE;
+    }
+    return FALSE;
+}
+
+
+
+/******************************************************************************
+ *     SizeOfVariantData    [INTERNAL]
  *
  * This function finds the size of the data referenced by a Variant based
@@ -528 +529 @@
 }
 /******************************************************************************
- *         StringDupAtoBstr             [INTERNAL]
- * 
+ *     StringDupAtoBstr     [INTERNAL]
+ *
  */
 static BSTR StringDupAtoBstr( char* strIn )
 {
-        BSTR bstr = NULL;
-        OLECHAR* pNewString = NULL;
-        pNewString = HEAP_strdupAtoW( GetProcessHeap(), 0, strIn );
-        bstr = SysAllocString( pNewString );
-        HeapFree( GetProcessHeap(), 0, pNewString );
-        return bstr;
-}
-
-/******************************************************************************
- *              round           [INTERNAL]
+    BSTR bstr = NULL;
+    OLECHAR* pNewString = NULL;
+    pNewString = HEAP_strdupAtoW( GetProcessHeap(), 0, strIn );
+    bstr = SysAllocString( pNewString );
+    HeapFree( GetProcessHeap(), 0, pNewString );
+    return bstr;
+}
+
+/******************************************************************************
+ *      round       [INTERNAL]
  *
  * Round the double value to the nearest integer value.
@@ -556 +557 @@
    nSign = (d >= 0.0) ? 1 : -1;
     d = fabs( d );
-    
-        /* Remove the decimals.
-         */
+
+    /* Remove the decimals.
+     */
    integerValue = floor( d );
 
@@ -573 +574 @@
     decimals = d - integerValue;
 
-        /* Note: Ceil returns the smallest integer that is greater that x.
-         * and floor returns the largest integer that is less than or equal to x.
-         */
+    /* Note: Ceil returns the smallest integer that is greater that x.
+     * and floor returns the largest integer that is less than or equal to x.
+     */
     if( decimals > 0.5 )
     {
@@ -603 +604 @@
     }
 
-        return roundedValue * nSign;
-}
-
-/******************************************************************************
- *              RemoveCharacterFromString               [INTERNAL]
+    return roundedValue * nSign;
+}
+
+/******************************************************************************
+ *      RemoveCharacterFromString       [INTERNAL]
  *
  * Removes any of the characters in "strOfCharToRemove" from the "str" argument.
@@ -613 +614 @@
 static void RemoveCharacterFromString( LPSTR str, LPSTR strOfCharToRemove )
 {
-        LPSTR pNewString = NULL;
-        LPSTR strToken = NULL;
-
-
-        /* Check if we have a valid argument
-         */
-        if( str != NULL )
-        {
-                pNewString = strdup( str );
-                str[0] = '\0';
-                strToken = strtok( pNewString, strOfCharToRemove );
-                while( strToken != NULL ) { 
-                        strcat( str, strToken );
-                        strToken = strtok( NULL, strOfCharToRemove );
-                }
-                free( pNewString );
-        }
-        return;
-}
-
-/******************************************************************************
- *              GetValidRealString              [INTERNAL]
+    LPSTR pNewString = NULL;
+    LPSTR strToken = NULL;
+
+
+    /* Check if we have a valid argument
+     */
+    if( str != NULL )
+    {
+        pNewString = strdup( str );
+        str[0] = '\0';
+        strToken = strtok( pNewString, strOfCharToRemove );
+        while( strToken != NULL ) {
+            strcat( str, strToken );
+            strToken = strtok( NULL, strOfCharToRemove );
+        }
+        free( pNewString );
+    }
+    return;
+}
+
+/******************************************************************************
+ *      GetValidRealString      [INTERNAL]
  *
  * Checks if the string is of proper format to be converted to a real value.
@@ -640 +641 @@
 static BOOL IsValidRealString( LPSTR strRealString )
 {
-        /* Real values that have a decimal point are required to either have
-         * digits before or after the decimal point.  We will assume that
-         * we do not have any digits at either position. If we do encounter
-         * some we will disable this flag.
-         */
-        BOOL bDigitsRequired = TRUE;
-        /* Processed fields in the string representation of the real number.
-         */
-        BOOL bWhiteSpaceProcessed = FALSE;
-        BOOL bFirstSignProcessed = FALSE;
-        BOOL bFirstDigitsProcessed = FALSE;
-        BOOL bDecimalPointProcessed = FALSE;
-        BOOL bSecondDigitsProcessed = FALSE;
-        BOOL bExponentProcessed = FALSE;
-        BOOL bSecondSignProcessed = FALSE;
-        BOOL bThirdDigitsProcessed = FALSE;
-        /* Assume string parameter "strRealString" is valid and try to disprove it.
-         */
-        BOOL bValidRealString = TRUE;
-
-        /* Used to count the number of tokens in the "strRealString".
-         */
-        LPSTR strToken = NULL;
-        int nTokens = 0;
-        LPSTR pChar = NULL;
-        
-        /* Check if we have a valid argument
-         */
-        if( strRealString == NULL )
-        {
-                bValidRealString = FALSE;
-        }
-
-        if( bValidRealString == TRUE )
-        {
-                /* Make sure we only have ONE token in the string.
-                 */
-                strToken = strtok( strRealString, " " );
-                while( strToken != NULL ) { 
-                        nTokens++;              
-                        strToken = strtok( NULL, " " ); 
-                }
-
-                if( nTokens != 1 )
-                {
-                        bValidRealString = FALSE;
-                }
-        }
-
-
-        /* Make sure this token contains only valid characters.
-         * The string argument to atof has the following form:
-         * [whitespace] [sign] [digits] [.digits] [ {d | D | e | E }[sign]digits]
-         * Whitespace consists of space and|or <TAB> characters, which are ignored.
+    /* Real values that have a decimal point are required to either have
+     * digits before or after the decimal point.  We will assume that
+     * we do not have any digits at either position. If we do encounter
+     * some we will disable this flag.
+     */
+    BOOL bDigitsRequired = TRUE;
+    /* Processed fields in the string representation of the real number.
+     */
+    BOOL bWhiteSpaceProcessed = FALSE;
+    BOOL bFirstSignProcessed = FALSE;
+    BOOL bFirstDigitsProcessed = FALSE;
+    BOOL bDecimalPointProcessed = FALSE;
+    BOOL bSecondDigitsProcessed = FALSE;
+    BOOL bExponentProcessed = FALSE;
+    BOOL bSecondSignProcessed = FALSE;
+    BOOL bThirdDigitsProcessed = FALSE;
+    /* Assume string parameter "strRealString" is valid and try to disprove it.
+     */
+    BOOL bValidRealString = TRUE;
+
+    /* Used to count the number of tokens in the "strRealString".
+     */
+    LPSTR strToken = NULL;
+    int nTokens = 0;
+    LPSTR pChar = NULL;
+
+    /* Check if we have a valid argument
+     */
+    if( strRealString == NULL )
+    {
+        bValidRealString = FALSE;
+    }
+
+    if( bValidRealString == TRUE )
+    {
+        /* Make sure we only have ONE token in the string.
+         */
+        strToken = strtok( strRealString, " " );
+        while( strToken != NULL ) {
+            nTokens++;
+            strToken = strtok( NULL, " " );
+        }
+
+        if( nTokens != 1 )
+        {
+            bValidRealString = FALSE;
+        }
+    }
+
+
+    /* Make sure this token contains only valid characters.
+     * The string argument to atof has the following form:
+     * [whitespace] [sign] [digits] [.digits] [ {d | D | e | E }[sign]digits]
+     * Whitespace consists of space and|or <TAB> characters, which are ignored.
      * Sign is either plus '+' or minus '-'.
      * Digits are one or more decimal digits.
@@ -700 +701 @@
      * The decimal digits may be followed by an exponent.
      * An Exponent consists of an introductory letter ( D, d, E, or e) and
-         * an optionally signed decimal integer.
-         */
-        pChar = strRealString;
-        while( bValidRealString == TRUE && *pChar != '\0' )
-        {
-                switch( *pChar )
-                {
-                /* If whitespace...
-                 */
-                case ' ':
-                case '\t':
-                        if( bWhiteSpaceProcessed ||
-                                bFirstSignProcessed ||
-                                bFirstDigitsProcessed ||
-                                bDecimalPointProcessed ||
-                                bSecondDigitsProcessed ||
-                                bExponentProcessed ||
-                                bSecondSignProcessed ||
-                                bThirdDigitsProcessed )
-                        {
-                                bValidRealString = FALSE;
-                        }
-                        break;
-                /* If sign...
-                 */
-                case '+':
-                case '-':
-                        if( bFirstSignProcessed == FALSE )
-                        {
-                                if( bFirstDigitsProcessed ||
-                                        bDecimalPointProcessed ||
-                                        bSecondDigitsProcessed ||
-                                        bExponentProcessed ||
-                                        bSecondSignProcessed ||
-                                        bThirdDigitsProcessed )
-                                {
-                                        bValidRealString = FALSE;
-                                }
-                                bWhiteSpaceProcessed = TRUE;
-                                bFirstSignProcessed = TRUE;
-                        }
-                        else if( bSecondSignProcessed == FALSE )
-                        {
+     * an optionally signed decimal integer.
+     */
+    pChar = strRealString;
+    while( bValidRealString == TRUE && *pChar != '\0' )
+    {
+        switch( *pChar )
+        {
+        /* If whitespace...
+         */
+        case ' ':
+        case '\t':
+            if( bWhiteSpaceProcessed ||
+                bFirstSignProcessed ||
+                bFirstDigitsProcessed ||
+                bDecimalPointProcessed ||
+                bSecondDigitsProcessed ||
+                bExponentProcessed ||
+                bSecondSignProcessed ||
+                bThirdDigitsProcessed )
+            {
+                bValidRealString = FALSE;
+            }
+            break;
+        /* If sign...
+         */
+        case '+':
+        case '-':
+            if( bFirstSignProcessed == FALSE )
+            {
+                if( bFirstDigitsProcessed ||
+                    bDecimalPointProcessed ||
+                    bSecondDigitsProcessed ||
+                    bExponentProcessed ||
+                    bSecondSignProcessed ||
+                    bThirdDigitsProcessed )
+                {
+                    bValidRealString = FALSE;
+                }
+                bWhiteSpaceProcessed = TRUE;
+                bFirstSignProcessed = TRUE;
+            }
+            else if( bSecondSignProcessed == FALSE )
+            {
                 /* Note: The exponent must be present in
-                                 * order to accept the second sign...
-                                 */
-                                if( bExponentProcessed == FALSE ||
-                                        bThirdDigitsProcessed ||
-                                        bDigitsRequired )
-                                {
-                                        bValidRealString = FALSE;
-                                }
-                                bFirstSignProcessed = TRUE;
-                                bWhiteSpaceProcessed = TRUE;
-                                bFirstDigitsProcessed = TRUE;
-                                bDecimalPointProcessed = TRUE;
-                                bSecondDigitsProcessed = TRUE;
-                                bSecondSignProcessed = TRUE;
-                        }
-                        break;
-
-                /* If decimals...
-                 */
-                case '0':
-                case '1':
-                case '2':
-                case '3':
-                case '4':
-                case '5':
-                case '6':
-                case '7':
-                case '8':
-                case '9': 
-                        if( bFirstDigitsProcessed == FALSE )
-                        {
-                                if( bDecimalPointProcessed ||
-                                        bSecondDigitsProcessed ||
-                                        bExponentProcessed ||
-                                        bSecondSignProcessed ||
-                                        bThirdDigitsProcessed )
-                                {
-                                        bValidRealString = FALSE;
-                                }
-                                bFirstSignProcessed = TRUE;
-                                bWhiteSpaceProcessed = TRUE;
-                                /* We have found some digits before the decimal point
-                                 * so disable the "Digits required" flag.
-                                 */
-                                bDigitsRequired = FALSE;
-                        }
-                        else if( bSecondDigitsProcessed == FALSE )
-                        {
-                                if( bExponentProcessed ||
-                                        bSecondSignProcessed ||
-                                        bThirdDigitsProcessed )
-                                {
-                                        bValidRealString = FALSE;
-                                }
-                                bFirstSignProcessed = TRUE;
-                                bWhiteSpaceProcessed = TRUE;
-                                bFirstDigitsProcessed = TRUE;
-                                bDecimalPointProcessed = TRUE;
-                                /* We have found some digits after the decimal point
-                                 * so disable the "Digits required" flag.
-                                 */
-                                bDigitsRequired = FALSE;
-                        }
-                        else if( bThirdDigitsProcessed == FALSE )
-                        {
-                                /* Getting here means everything else should be processed.
+                 * order to accept the second sign...
+                 */
+                if( bExponentProcessed == FALSE ||
+                    bThirdDigitsProcessed ||
+                    bDigitsRequired )
+                {
+                    bValidRealString = FALSE;
+                }
+                bFirstSignProcessed = TRUE;
+                bWhiteSpaceProcessed = TRUE;
+                bFirstDigitsProcessed = TRUE;
+                bDecimalPointProcessed = TRUE;
+                bSecondDigitsProcessed = TRUE;
+                bSecondSignProcessed = TRUE;
+            }
+            break;
+
+        /* If decimals...
+         */
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+            if( bFirstDigitsProcessed == FALSE )
+            {
+                if( bDecimalPointProcessed ||
+                    bSecondDigitsProcessed ||
+                    bExponentProcessed ||
+                    bSecondSignProcessed ||
+                    bThirdDigitsProcessed )
+                {
+                    bValidRealString = FALSE;
+                }
+                bFirstSignProcessed = TRUE;
+                bWhiteSpaceProcessed = TRUE;
+                /* We have found some digits before the decimal point
+                 * so disable the "Digits required" flag.
+                 */
+                bDigitsRequired = FALSE;
+            }
+            else if( bSecondDigitsProcessed == FALSE )
+            {
+                if( bExponentProcessed ||
+                    bSecondSignProcessed ||
+                    bThirdDigitsProcessed )
+                {
+                    bValidRealString = FALSE;
+                }
+                bFirstSignProcessed = TRUE;
+                bWhiteSpaceProcessed = TRUE;
+                bFirstDigitsProcessed = TRUE;
+                bDecimalPointProcessed = TRUE;
+                /* We have found some digits after the decimal point
+                 * so disable the "Digits required" flag.
+                 */
+                bDigitsRequired = FALSE;
+            }
+            else if( bThirdDigitsProcessed == FALSE )
+            {
+                /* Getting here means everything else should be processed.
                  * If we get anything else than a decimal following this
                  * digit it will be flagged by the other cases, so
-                                 * we do not really need to do anything in here.
-                                 */
-                        }
-                        break;
-                /* If DecimalPoint...
-                 */
-                case '.': 
-                        if( bDecimalPointProcessed ||
-                                bSecondDigitsProcessed ||
-                                bExponentProcessed ||
-                                bSecondSignProcessed ||
-                                bThirdDigitsProcessed )
-                        {
-                                bValidRealString = FALSE;
-                        }
-                        bFirstSignProcessed = TRUE;
-                        bWhiteSpaceProcessed = TRUE;
-                        bFirstDigitsProcessed = TRUE;
-                        bDecimalPointProcessed = TRUE;
-                        break;
-                /* If Exponent...
-                 */
-                case 'e':
-                case 'E':
-                case 'd':
-                case 'D':
-                        if( bExponentProcessed ||
-                                bSecondSignProcessed ||
-                                bThirdDigitsProcessed ||
-                                bDigitsRequired )
-                        {
-                                bValidRealString = FALSE;
-                        }
-                        bFirstSignProcessed = TRUE;
-                        bWhiteSpaceProcessed = TRUE;
-                        bFirstDigitsProcessed = TRUE;
-                        bDecimalPointProcessed = TRUE;
-                        bSecondDigitsProcessed = TRUE;
-                        bExponentProcessed = TRUE;
-                        break;
-                default:
-                        bValidRealString = FALSE;
-                        break;
-                }
-                /* Process next character.
-                 */
-                pChar++;
-        }
-
-        /* If the required digits were not present we have an invalid
-         * string representation of a real number.
-         */
-        if( bDigitsRequired == TRUE )
-        {
-                bValidRealString = FALSE;
-        }
-
-        return bValidRealString;
-}
-
-
-/******************************************************************************
- *              Coerce  [INTERNAL]
+                 * we do not really need to do anything in here.
+                 */
+            }
+            break;
+        /* If DecimalPoint...
+         */
+        case '.':
+            if( bDecimalPointProcessed ||
+                bSecondDigitsProcessed ||
+                bExponentProcessed ||
+                bSecondSignProcessed ||
+                bThirdDigitsProcessed )
+            {
+                bValidRealString = FALSE;
+            }
+            bFirstSignProcessed = TRUE;
+            bWhiteSpaceProcessed = TRUE;
+            bFirstDigitsProcessed = TRUE;
+            bDecimalPointProcessed = TRUE;
+            break;
+        /* If Exponent...
+         */
+        case 'e':
+        case 'E':
+        case 'd':
+        case 'D':
+            if( bExponentProcessed ||
+                bSecondSignProcessed ||
+                bThirdDigitsProcessed ||
+                bDigitsRequired )
+            {
+                bValidRealString = FALSE;
+            }
+            bFirstSignProcessed = TRUE;
+            bWhiteSpaceProcessed = TRUE;
+            bFirstDigitsProcessed = TRUE;
+            bDecimalPointProcessed = TRUE;
+            bSecondDigitsProcessed = TRUE;
+            bExponentProcessed = TRUE;
+            break;
+        default:
+            bValidRealString = FALSE;
+            break;
+        }
+        /* Process next character.
+         */
+        pChar++;
+    }
+
+    /* If the required digits were not present we have an invalid
+     * string representation of a real number.
+     */
+    if( bDigitsRequired == TRUE )
+    {
+        bValidRealString = FALSE;
+    }
+
+    return bValidRealString;
+}
+
+
+/******************************************************************************
+ *      Coerce  [INTERNAL]
  *
  * This function dispatches execution to the proper conversion API
@@ -880 +881 @@
  *
  * FIXME: Passing down dwFlags to the conversion functions is wrong, this
- *        is a different flagmask. Check MSDN.
+ *    is a different flagmask. Check MSDN.
  */
 static HRESULT Coerce( VARIANTARG* pd, LCID lcid, ULONG dwFlags, VARIANTARG* ps, VARTYPE vt )
 {
-        HRESULT res = S_OK;
-        unsigned short vtFrom = 0;
-        vtFrom = V_VT(ps) & VT_TYPEMASK;
-
-        
-        /* Note: Since "long" and "int" values both have 4 bytes and are
-         * both signed integers "int" will be treated as "long" in the
-         * following code.
-         * The same goes for their unsigned versions.
-         */
-
-        /* Trivial Case: If the coercion is from two types that are 
-         * identical then we can blindly copy from one argument to another.*/
-        if ((vt==vtFrom))
-        {
-           return VariantCopy(pd,ps);
-        }
-
-        /* Cases requiring thought*/
-        switch( vt )
-        {
+    HRESULT res = S_OK;
+    unsigned short vtFrom = 0;
+    vtFrom = V_VT(ps) & VT_TYPEMASK;
+
+
+    /* Note: Since "long" and "int" values both have 4 bytes and are
+     * both signed integers "int" will be treated as "long" in the
+     * following code.
+     * The same goes for their unsigned versions.
+     */
+
+    /* Trivial Case: If the coercion is from two types that are
+     * identical then we can blindly copy from one argument to another.*/
+    if ((vt==vtFrom))
+    {
+       return VariantCopy(pd,ps);
+    }
+
+    /* Cases requiring thought*/
+    switch( vt )
+    {
 
     case( VT_EMPTY ):
@@ -916 +917 @@
         }
         break;
-        case( VT_I1 ):
-                switch( vtFrom )
+    case( VT_I1 ):
+        switch( vtFrom )
         {
         case( VT_I1 ):
             res = VariantCopy( pd, ps );
             break;
-                case( VT_I2 ):
-                        res = VarI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,cVal) );
-                        break;
-                case( VT_INT ):
-                case( VT_I4 ):
-                        res = VarI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,cVal) );
-                        break;
-                case( VT_UI1 ):
-                        res = VarI1FromUI1( V_UNION(ps,bVal), &V_UNION(pd,cVal) );
-                        break;
-                case( VT_UI2 ):
-                        res = VarI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cVal) );
-                        break;
-                case( VT_UINT ):
-                case( VT_UI4 ):
-                        res = VarI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cVal) );
-                        break;
-                case( VT_R4 ):
-                        res = VarI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,cVal) );
-                        break;
-                case( VT_R8 ):
-                        res = VarI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,cVal) );
-                        break;
-                case( VT_DATE ):
-                        res = VarI1FromDate( V_UNION(ps,date), &V_UNION(pd,cVal) );
-                        break;
-                case( VT_BOOL ):
-                        res = VarI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,cVal) );
-                        break;
-                case( VT_BSTR ):
-                        res = VarI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cVal) );
-                        break;
-                case( VT_CY ):
-                        res = VarI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,cVal) );
-                        break;
-                case( VT_DISPATCH ):
-                        /*res = VarI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cVal) );*/
-                case( VT_DECIMAL ):
-                        /*res = VarI1FromDec( V_UNION(ps,decVal), &V_UNION(pd,cVal) );*/
-                case( VT_UNKNOWN ):
-                default:
-                        res = DISP_E_TYPEMISMATCH;
-                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                        break;
-                }
-                break;
-
-        case( VT_I2 ):
-                switch( vtFrom )
-                {
-                case( VT_I1 ):
-                        res = VarI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,iVal) );
-                        break;
+        case( VT_I2 ):
+            res = VarI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,cVal) );
+            break;
+        case( VT_INT ):
+        case( VT_I4 ):
+            res = VarI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,cVal) );
+            break;
+        case( VT_UI1 ):
+            res = VarI1FromUI1( V_UNION(ps,bVal), &V_UNION(pd,cVal) );
+            break;
+        case( VT_UI2 ):
+            res = VarI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cVal) );
+            break;
+        case( VT_UINT ):
+        case( VT_UI4 ):
+            res = VarI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cVal) );
+            break;
+        case( VT_R4 ):
+            res = VarI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,cVal) );
+            break;
+        case( VT_R8 ):
+            res = VarI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,cVal) );
+            break;
+        case( VT_DATE ):
+            res = VarI1FromDate( V_UNION(ps,date), &V_UNION(pd,cVal) );
+            break;
+        case( VT_BOOL ):
+            res = VarI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,cVal) );
+            break;
+        case( VT_BSTR ):
+            res = VarI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cVal) );
+            break;
+        case( VT_CY ):
+            res = VarI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,cVal) );
+            break;
+        case( VT_DISPATCH ):
+            /*res = VarI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cVal) );*/
+        case( VT_DECIMAL ):
+            /*res = VarI1FromDec( V_UNION(ps,decVal), &V_UNION(pd,cVal) );*/
+        case( VT_UNKNOWN ):
+        default:
+            res = DISP_E_TYPEMISMATCH;
+            FIXME("Coercion from %d to %d\n", vtFrom, vt );
+            break;
+        }
+        break;
+
+    case( VT_I2 ):
+        switch( vtFrom )
+        {
+        case( VT_I1 ):
+            res = VarI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,iVal) );
+            break;
         case( VT_I2 ):
             res = VariantCopy( pd, ps );
             break;
-                case( VT_INT ):
-                case( VT_I4 ):
-                        res = VarI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,iVal) );
-                        break;
-                case( VT_UI1 ):
-                        res = VarI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,iVal) );
-                        break;
-                case( VT_UI2 ):
-                        res = VarI2FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,iVal) );
-                        break;
-                case( VT_UINT ):
-                case( VT_UI4 ):
-                        res = VarI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,iVal) );
-                        break;
-                case( VT_R4 ):
-                        res = VarI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,iVal) );
-                        break;
-                case( VT_R8 ):
-                        res = VarI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,iVal) );
-                        break;
-                case( VT_DATE ):
-                        res = VarI2FromDate( V_UNION(ps,date), &V_UNION(pd,iVal) );
-                        break;
-                case( VT_BOOL ):
-                        res = VarI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,iVal) );
-                        break;
-                case( VT_BSTR ):
-                        res = VarI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,iVal) );
-                        break;
-                case( VT_CY ):
-                        res = VarI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,iVal) );
-                        break;
-                case( VT_DISPATCH ):
-                        /*res = VarI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,iVal) );*/
-                case( VT_DECIMAL ):
-                        /*res = VarI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,iVal) );*/
-                case( VT_UNKNOWN ):
-                default:
-                        res = DISP_E_TYPEMISMATCH;
-                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                        break;
-                }
-                break;
-
-        case( VT_INT ):
-        case( VT_I4 ):
-                switch( vtFrom )
-                {
-                case( VT_I1 ):
-                        res = VarI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,lVal) );
-                        break;
-                case( VT_I2 ):
-                        res = VarI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,lVal) );
+        case( VT_INT ):
+        case( VT_I4 ):
+            res = VarI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,iVal) );
+            break;
+        case( VT_UI1 ):
+            res = VarI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,iVal) );
+            break;
+        case( VT_UI2 ):
+            res = VarI2FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,iVal) );
+            break;
+        case( VT_UINT ):
+        case( VT_UI4 ):
+            res = VarI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,iVal) );
+            break;
+        case( VT_R4 ):
+            res = VarI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,iVal) );
+            break;
+        case( VT_R8 ):
+            res = VarI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,iVal) );
+            break;
+        case( VT_DATE ):
+            res = VarI2FromDate( V_UNION(ps,date), &V_UNION(pd,iVal) );
+            break;
+        case( VT_BOOL ):
+            res = VarI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,iVal) );
+            break;
+        case( VT_BSTR ):
+            res = VarI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,iVal) );
+            break;
+        case( VT_CY ):
+            res = VarI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,iVal) );
+            break;
+        case( VT_DISPATCH ):
+            /*res = VarI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,iVal) );*/
+        case( VT_DECIMAL ):
+            /*res = VarI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,iVal) );*/
+        case( VT_UNKNOWN ):
+        default:
+            res = DISP_E_TYPEMISMATCH;
+            FIXME("Coercion from %d to %d\n", vtFrom, vt );
+            break;
+        }
+        break;
+
+    case( VT_INT ):
+    case( VT_I4 ):
+        switch( vtFrom )
+        {
+        case( VT_I1 ):
+            res = VarI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,lVal) );
+            break;
+        case( VT_I2 ):
+            res = VarI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,lVal) );
             break;
         case( VT_INT ):
@@ -1039 +1040 @@
             res = VariantCopy( pd, ps );
             break;
-                case( VT_UI1 ):
-                        res = VarI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,lVal) );
-                        break;
-                case( VT_UI2 ):
-                        res = VarI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,lVal) );
-                        break;
-                case( VT_UINT ):
-                case( VT_UI4 ):
-                        res = VarI4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,lVal) );
-                        break;
-                case( VT_R4 ):
-                        res = VarI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,lVal) );
-                        break;
-                case( VT_R8 ):
-                        res = VarI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,lVal) );
-                        break;
-                case( VT_DATE ):
-                        res = VarI4FromDate( V_UNION(ps,date), &V_UNION(pd,lVal) );
-                        break;
-                case( VT_BOOL ):
-                        res = VarI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,lVal) );
-                        break;
-                case( VT_BSTR ):
-                        res = VarI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,lVal) );
-                        break;
-                case( VT_CY ):
-                        res = VarI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,lVal) );
-                        break;
-                case( VT_DISPATCH ):
-                        /*res = VarI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,lVal) );*/
-                case( VT_DECIMAL ):
-                        /*res = VarI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,lVal) );*/
-                case( VT_UNKNOWN ):
-                default:
-                        res = DISP_E_TYPEMISMATCH;
-                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                        break;
-                }
-                break;
-
-        case( VT_UI1 ):
-                switch( vtFrom )
-                {
-                case( VT_I1 ):
-                        res = VarUI1FromI1( V_UNION(ps,cVal), &V_UNION(pd,bVal) );
-                        break;
-                case( VT_I2 ):
-                        res = VarUI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,bVal) );
-                        break;
-                case( VT_INT ):
-                case( VT_I4 ):
-                        res = VarUI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,bVal) );
-                        break;
+        case( VT_UI1 ):
+            res = VarI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,lVal) );
+            break;
+        case( VT_UI2 ):
+            res = VarI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,lVal) );
+            break;
+        case( VT_UINT ):
+        case( VT_UI4 ):
+            res = VarI4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,lVal) );
+            break;
+        case( VT_R4 ):
+            res = VarI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,lVal) );
+            break;
+        case( VT_R8 ):
+            res = VarI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,lVal) );
+            break;
+        case( VT_DATE ):
+            res = VarI4FromDate( V_UNION(ps,date), &V_UNION(pd,lVal) );
+            break;
+        case( VT_BOOL ):
+            res = VarI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,lVal) );
+            break;
+        case( VT_BSTR ):
+            res = VarI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,lVal) );
+            break;
+        case( VT_CY ):
+            res = VarI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,lVal) );
+            break;
+        case( VT_DISPATCH ):
+            /*res = VarI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,lVal) );*/
+        case( VT_DECIMAL ):
+            /*res = VarI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,lVal) );*/
+        case( VT_UNKNOWN ):
+        default:
+            res = DISP_E_TYPEMISMATCH;
+            FIXME("Coercion from %d to %d\n", vtFrom, vt );
+            break;
+        }
+        break;
+
+    case( VT_UI1 ):
+        switch( vtFrom )
+        {
+        case( VT_I1 ):
+            res = VarUI1FromI1( V_UNION(ps,cVal), &V_UNION(pd,bVal) );
+            break;
+        case( VT_I2 ):
+            res = VarUI1FromI2( V_UNION(ps,iVal), &V_UNION(pd,bVal) );
+            break;
+        case( VT_INT ):
+        case( VT_I4 ):
+            res = VarUI1FromI4( V_UNION(ps,lVal), &V_UNION(pd,bVal) );
+            break;
         case( VT_UI1 ):
             res = VariantCopy( pd, ps );
             break;
-                case( VT_UI2 ):
-                        res = VarUI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,bVal) );
-                        break;
-                case( VT_UINT ):
-                case( VT_UI4 ):
-                        res = VarUI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,bVal) );
-                        break;
-                case( VT_R4 ):
-                        res = VarUI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,bVal) );
-                        break;
-                case( VT_R8 ):
-                        res = VarUI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,bVal) );
-                        break;
-                case( VT_DATE ):
-                        res = VarUI1FromDate( V_UNION(ps,date), &V_UNION(pd,bVal) );
-                        break;
-                case( VT_BOOL ):
-                        res = VarUI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,bVal) );
-                        break;
-                case( VT_BSTR ):
-                        res = VarUI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,bVal) );
-                        break;
-                case( VT_CY ):
-                        res = VarUI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,bVal) );
-                        break;
-                case( VT_DISPATCH ):
-                        /*res = VarUI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,bVal) );*/
-                case( VT_DECIMAL ):
-                        /*res = VarUI1FromDec( V_UNION(ps,deiVal), &V_UNION(pd,bVal) );*/
-                case( VT_UNKNOWN ):
-                default:
-                        res = DISP_E_TYPEMISMATCH;
-                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                        break;
-                }
-                break;
-
-        case( VT_UI2 ):
-                switch( vtFrom )
-                {
-                case( VT_I1 ):
-                        res = VarUI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,uiVal) );
-                        break;
-                case( VT_I2 ):
-                        res = VarUI2FromI2( V_UNION(ps,iVal), &V_UNION(pd,uiVal) );
-                        break;
-                case( VT_INT ):
-                case( VT_I4 ):
-                        res = VarUI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,uiVal) );
-                        break;
-                case( VT_UI1 ):
-                        res = VarUI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,uiVal) );
-                        break;
+        case( VT_UI2 ):
+            res = VarUI1FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,bVal) );
+            break;
+        case( VT_UINT ):
+        case( VT_UI4 ):
+            res = VarUI1FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,bVal) );
+            break;
+        case( VT_R4 ):
+            res = VarUI1FromR4( V_UNION(ps,fltVal), &V_UNION(pd,bVal) );
+            break;
+        case( VT_R8 ):
+            res = VarUI1FromR8( V_UNION(ps,dblVal), &V_UNION(pd,bVal) );
+            break;
+        case( VT_DATE ):
+            res = VarUI1FromDate( V_UNION(ps,date), &V_UNION(pd,bVal) );
+            break;
+        case( VT_BOOL ):
+            res = VarUI1FromBool( V_UNION(ps,boolVal), &V_UNION(pd,bVal) );
+            break;
+        case( VT_BSTR ):
+            res = VarUI1FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,bVal) );
+            break;
+        case( VT_CY ):
+            res = VarUI1FromCy( V_UNION(ps,cyVal), &V_UNION(pd,bVal) );
+            break;
+        case( VT_DISPATCH ):
+            /*res = VarUI1FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,bVal) );*/
+        case( VT_DECIMAL ):
+            /*res = VarUI1FromDec( V_UNION(ps,deiVal), &V_UNION(pd,bVal) );*/
+        case( VT_UNKNOWN ):
+        default:
+            res = DISP_E_TYPEMISMATCH;
+            FIXME("Coercion from %d to %d\n", vtFrom, vt );
+            break;
+        }
+        break;
+
+    case( VT_UI2 ):
+        switch( vtFrom )
+        {
+        case( VT_I1 ):
+            res = VarUI2FromI1( V_UNION(ps,cVal), &V_UNION(pd,uiVal) );
+            break;
+        case( VT_I2 ):
+            res = VarUI2FromI2( V_UNION(ps,iVal), &V_UNION(pd,uiVal) );
+            break;
+        case( VT_INT ):
+        case( VT_I4 ):
+            res = VarUI2FromI4( V_UNION(ps,lVal), &V_UNION(pd,uiVal) );
+            break;
+        case( VT_UI1 ):
+            res = VarUI2FromUI1( V_UNION(ps,bVal), &V_UNION(pd,uiVal) );
+            break;
         case( VT_UI2 ):
             res = VariantCopy( pd, ps );
             break;
-                case( VT_UINT ):
-                case( VT_UI4 ):
-                        res = VarUI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,uiVal) );
-                        break;
-                case( VT_R4 ):
-                        res = VarUI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,uiVal) );
-                        break;
-                case( VT_R8 ):
-                        res = VarUI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,uiVal) );
-                        break;
-                case( VT_DATE ):
-                        res = VarUI2FromDate( V_UNION(ps,date), &V_UNION(pd,uiVal) );
-                        break;
-                case( VT_BOOL ):
-                        res = VarUI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,uiVal) );
-                        break;
-                case( VT_BSTR ):
-                        res = VarUI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,uiVal) );
-                        break;
-                case( VT_CY ):
-                        res = VarUI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,uiVal) );
-                        break;
-                case( VT_DISPATCH ):
-                        /*res = VarUI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,uiVal) );*/
-                case( VT_DECIMAL ):
-                        /*res = VarUI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,uiVal) );*/
-                case( VT_UNKNOWN ):
-                default:
-                        res = DISP_E_TYPEMISMATCH;
-                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                        break;
-                }
-                break;
-
-        case( VT_UINT ):
-        case( VT_UI4 ):
-                switch( vtFrom )
-                {
-                case( VT_I1 ):
-                        res = VarUI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,ulVal) );
-                        break;
-                case( VT_I2 ):
-                        res = VarUI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,ulVal) );
-                        break;
-                case( VT_INT ):
-                case( VT_I4 ):
-                        res = VarUI4FromI4( V_UNION(ps,lVal), &V_UNION(pd,ulVal) );
-                        break;
-                case( VT_UI1 ):
-                        res = VarUI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,ulVal) );
-                        break;
-                case( VT_UI2 ):
-                        res = VarUI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,ulVal) );
-                        break;
+        case( VT_UINT ):
+        case( VT_UI4 ):
+            res = VarUI2FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,uiVal) );
+            break;
+        case( VT_R4 ):
+            res = VarUI2FromR4( V_UNION(ps,fltVal), &V_UNION(pd,uiVal) );
+            break;
+        case( VT_R8 ):
+            res = VarUI2FromR8( V_UNION(ps,dblVal), &V_UNION(pd,uiVal) );
+            break;
+        case( VT_DATE ):
+            res = VarUI2FromDate( V_UNION(ps,date), &V_UNION(pd,uiVal) );
+            break;
+        case( VT_BOOL ):
+            res = VarUI2FromBool( V_UNION(ps,boolVal), &V_UNION(pd,uiVal) );
+            break;
+        case( VT_BSTR ):
+            res = VarUI2FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,uiVal) );
+            break;
+        case( VT_CY ):
+            res = VarUI2FromCy( V_UNION(ps,cyVal), &V_UNION(pd,uiVal) );
+            break;
+        case( VT_DISPATCH ):
+            /*res = VarUI2FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,uiVal) );*/
+        case( VT_DECIMAL ):
+            /*res = VarUI2FromDec( V_UNION(ps,deiVal), &V_UNION(pd,uiVal) );*/
+        case( VT_UNKNOWN ):
+        default:
+            res = DISP_E_TYPEMISMATCH;
+            FIXME("Coercion from %d to %d\n", vtFrom, vt );
+            break;
+        }
+        break;
+
+    case( VT_UINT ):
+    case( VT_UI4 ):
+        switch( vtFrom )
+        {
+        case( VT_I1 ):
+            res = VarUI4FromI1( V_UNION(ps,cVal), &V_UNION(pd,ulVal) );
+            break;
+        case( VT_I2 ):
+            res = VarUI4FromI2( V_UNION(ps,iVal), &V_UNION(pd,ulVal) );
+            break;
+        case( VT_INT ):
+        case( VT_I4 ):
+            res = VarUI4FromI4( V_UNION(ps,lVal), &V_UNION(pd,ulVal) );
+            break;
+        case( VT_UI1 ):
+            res = VarUI4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,ulVal) );
+            break;
+        case( VT_UI2 ):
+            res = VarUI4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,ulVal) );
+            break;
         case( VT_UI4 ):
             res = VariantCopy( pd, ps );
             break;
-                case( VT_R4 ):
-                        res = VarUI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,ulVal) );
-                        break;
-                case( VT_R8 ):
-                        res = VarUI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,ulVal) );
-                        break;
-                case( VT_DATE ):
-                        res = VarUI4FromDate( V_UNION(ps,date), &V_UNION(pd,ulVal) );
-                        break;
-                case( VT_BOOL ):
-                        res = VarUI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,ulVal) );
-                        break;
-                case( VT_BSTR ):
-                        res = VarUI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,ulVal) );
-                        break;
-                case( VT_CY ):
-                        res = VarUI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,ulVal) );
-                        break;
-                case( VT_DISPATCH ):
-                        /*res = VarUI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,ulVal) );*/
-                case( VT_DECIMAL ):
-                        /*res = VarUI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,ulVal) );*/
-                case( VT_UNKNOWN ):
-                default:
-                        res = DISP_E_TYPEMISMATCH;
-                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                        break;
-                }
-                break;
-                
-        case( VT_R4 ):
-                switch( vtFrom )
-                {
-                case( VT_I1 ):
-                        res = VarR4FromI1( V_UNION(ps,cVal), &V_UNION(pd,fltVal) );
-                        break;
-                case( VT_I2 ):
-                        res = VarR4FromI2( V_UNION(ps,iVal), &V_UNION(pd,fltVal) );
-                        break;
-                case( VT_INT ):
-                case( VT_I4 ):
-                        res = VarR4FromI4( V_UNION(ps,lVal), &V_UNION(pd,fltVal) );
-                        break;
-                case( VT_UI1 ):
-                        res = VarR4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,fltVal) );
-                        break;
-                case( VT_UI2 ):
-                        res = VarR4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,fltVal) );
-                        break;
-                case( VT_UINT ):
-                case( VT_UI4 ):
-                        res = VarR4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,fltVal) );
-                        break;
+        case( VT_R4 ):
+            res = VarUI4FromR4( V_UNION(ps,fltVal), &V_UNION(pd,ulVal) );
+            break;
+        case( VT_R8 ):
+            res = VarUI4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,ulVal) );
+            break;
+        case( VT_DATE ):
+            res = VarUI4FromDate( V_UNION(ps,date), &V_UNION(pd,ulVal) );
+            break;
+        case( VT_BOOL ):
+            res = VarUI4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,ulVal) );
+            break;
+        case( VT_BSTR ):
+            res = VarUI4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,ulVal) );
+            break;
+        case( VT_CY ):
+            res = VarUI4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,ulVal) );
+            break;
+        case( VT_DISPATCH ):
+            /*res = VarUI4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,ulVal) );*/
+        case( VT_DECIMAL ):
+            /*res = VarUI4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,ulVal) );*/
+        case( VT_UNKNOWN ):
+        default:
+            res = DISP_E_TYPEMISMATCH;
+            FIXME("Coercion from %d to %d\n", vtFrom, vt );
+            break;
+        }
+        break;
+
+    case( VT_R4 ):
+        switch( vtFrom )
+        {
+        case( VT_I1 ):
+            res = VarR4FromI1( V_UNION(ps,cVal), &V_UNION(pd,fltVal) );
+            break;
+        case( VT_I2 ):
+            res = VarR4FromI2( V_UNION(ps,iVal), &V_UNION(pd,fltVal) );
+            break;
+        case( VT_INT ):
+        case( VT_I4 ):
+            res = VarR4FromI4( V_UNION(ps,lVal), &V_UNION(pd,fltVal) );
+            break;
+        case( VT_UI1 ):
+            res = VarR4FromUI1( V_UNION(ps,bVal), &V_UNION(pd,fltVal) );
+            break;
+        case( VT_UI2 ):
+            res = VarR4FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,fltVal) );
+            break;
+        case( VT_UINT ):
+        case( VT_UI4 ):
+            res = VarR4FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,fltVal) );
+            break;
         case( VT_R4 ):
             res = VariantCopy( pd, ps );
             break;
-                case( VT_R8 ):
-                        res = VarR4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,fltVal) );
-                        break;
-                case( VT_DATE ):
-                        res = VarR4FromDate( V_UNION(ps,date), &V_UNION(pd,fltVal) );
-                        break;
-                case( VT_BOOL ):
-                        res = VarR4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,fltVal) );
-                        break;
-                case( VT_BSTR ):
-                        res = VarR4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,fltVal) );
-                        break;
-                case( VT_CY ):
-                        res = VarR4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,fltVal) );
-                        break;
-                case( VT_DISPATCH ):
-                        /*res = VarR4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,fltVal) );*/
-                case( VT_DECIMAL ):
-                        /*res = VarR4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,fltVal) );*/
-                case( VT_UNKNOWN ):
-                default:
-                        res = DISP_E_TYPEMISMATCH;
-                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                        break;
-                }
-                break;
-
-        case( VT_R8 ):
-                switch( vtFrom )
-                {
-                case( VT_I1 ):
-                        res = VarR8FromI1( V_UNION(ps,cVal), &V_UNION(pd,dblVal) );
-                        break;
-                case( VT_I2 ):
-                        res = VarR8FromI2( V_UNION(ps,iVal), &V_UNION(pd,dblVal) );
-                        break;
-                case( VT_INT ):
-                case( VT_I4 ):
-                        res = VarR8FromI4( V_UNION(ps,lVal), &V_UNION(pd,dblVal) );
-                        break;
-                case( VT_UI1 ):
-                        res = VarR8FromUI1( V_UNION(ps,bVal), &V_UNION(pd,dblVal) );
-                        break;
-                case( VT_UI2 ):
-                        res = VarR8FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,dblVal) );
-                        break;
-                case( VT_UINT ):
-                case( VT_UI4 ):
-                        res = VarR8FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,dblVal) );
-                        break;
-                case( VT_R4 ):
-                        res = VarR8FromR4( V_UNION(ps,fltVal), &V_UNION(pd,dblVal) );
-                        break;
+        case( VT_R8 ):
+            res = VarR4FromR8( V_UNION(ps,dblVal), &V_UNION(pd,fltVal) );
+            break;
+        case( VT_DATE ):
+            res = VarR4FromDate( V_UNION(ps,date), &V_UNION(pd,fltVal) );
+            break;
+        case( VT_BOOL ):
+            res = VarR4FromBool( V_UNION(ps,boolVal), &V_UNION(pd,fltVal) );
+            break;
+        case( VT_BSTR ):
+            res = VarR4FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,fltVal) );
+            break;
+        case( VT_CY ):
+            res = VarR4FromCy( V_UNION(ps,cyVal), &V_UNION(pd,fltVal) );
+            break;
+        case( VT_DISPATCH ):
+            /*res = VarR4FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,fltVal) );*/
+        case( VT_DECIMAL ):
+            /*res = VarR4FromDec( V_UNION(ps,deiVal), &V_UNION(pd,fltVal) );*/
+        case( VT_UNKNOWN ):
+        default:
+            res = DISP_E_TYPEMISMATCH;
+            FIXME("Coercion from %d to %d\n", vtFrom, vt );
+            break;
+        }
+        break;
+
+    case( VT_R8 ):
+        switch( vtFrom )
+        {
+        case( VT_I1 ):
+            res = VarR8FromI1( V_UNION(ps,cVal), &V_UNION(pd,dblVal) );
+            break;
+        case( VT_I2 ):
+            res = VarR8FromI2( V_UNION(ps,iVal), &V_UNION(pd,dblVal) );
+            break;
+        case( VT_INT ):
+        case( VT_I4 ):
+            res = VarR8FromI4( V_UNION(ps,lVal), &V_UNION(pd,dblVal) );
+            break;
+        case( VT_UI1 ):
+            res = VarR8FromUI1( V_UNION(ps,bVal), &V_UNION(pd,dblVal) );
+            break;
+        case( VT_UI2 ):
+            res = VarR8FromUI2( V_UNION(ps,uiVal), &V_UNION(pd,dblVal) );
+            break;
+        case( VT_UINT ):
+        case( VT_UI4 ):
+            res = VarR8FromUI4( V_UNION(ps,ulVal), &V_UNION(pd,dblVal) );
+            break;
+        case( VT_R4 ):
+            res = VarR8FromR4( V_UNION(ps,fltVal), &V_UNION(pd,dblVal) );
+            break;
         case( VT_R8 ):
             res = VariantCopy( pd, ps );
             break;
-                case( VT_DATE ):
-                        res = VarR8FromDate( V_UNION(ps,date), &V_UNION(pd,dblVal) );
-                        break;
-                case( VT_BOOL ):
-                        res = VarR8FromBool( V_UNION(ps,boolVal), &V_UNION(pd,dblVal) );
-                        break;
-                case( VT_BSTR ):
-                        res = VarR8FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,dblVal) );
-                        break;
-                case( VT_CY ):
-                        res = VarR8FromCy( V_UNION(ps,cyVal), &V_UNION(pd,dblVal) );
-                        break;
-                case( VT_DISPATCH ):
-                        /*res = VarR8FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,dblVal) );*/
-                case( VT_DECIMAL ):
-                        /*res = VarR8FromDec( V_UNION(ps,deiVal), &V_UNION(pd,dblVal) );*/
-                case( VT_UNKNOWN ):
-                default:
-                        res = DISP_E_TYPEMISMATCH;
-                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                        break;
-                }
-                break;
-
-        case( VT_DATE ):
-                switch( vtFrom )
-                {
-                case( VT_I1 ):
-                        res = VarDateFromI1( V_UNION(ps,cVal), &V_UNION(pd,date) );
-                        break;
-                case( VT_I2 ):
-                        res = VarDateFromI2( V_UNION(ps,iVal), &V_UNION(pd,date) );
-                        break;
-                case( VT_INT ):
-                        res = VarDateFromInt( V_UNION(ps,intVal), &V_UNION(pd,date) );
-                        break;
-                case( VT_I4 ):
-                        res = VarDateFromI4( V_UNION(ps,lVal), &V_UNION(pd,date) );
-                        break;
-                case( VT_UI1 ):
-                        res = VarDateFromUI1( V_UNION(ps,bVal), &V_UNION(pd,date) );
-                        break;
-                case( VT_UI2 ):
-                        res = VarDateFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,date) );
-                        break;
-                case( VT_UINT ):
-                        res = VarDateFromUint( V_UNION(ps,uintVal), &V_UNION(pd,date) );
-                        break;
-                case( VT_UI4 ):
-                        res = VarDateFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,date) );
-                        break;
-                case( VT_R4 ):
-                        res = VarDateFromR4( V_UNION(ps,fltVal), &V_UNION(pd,date) );
-                        break;
-                case( VT_R8 ):
-                        res = VarDateFromR8( V_UNION(ps,dblVal), &V_UNION(pd,date) );
-                        break;
+        case( VT_DATE ):
+            res = VarR8FromDate( V_UNION(ps,date), &V_UNION(pd,dblVal) );
+            break;
+        case( VT_BOOL ):
+            res = VarR8FromBool( V_UNION(ps,boolVal), &V_UNION(pd,dblVal) );
+            break;
+        case( VT_BSTR ):
+            res = VarR8FromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,dblVal) );
+            break;
+        case( VT_CY ):
+            res = VarR8FromCy( V_UNION(ps,cyVal), &V_UNION(pd,dblVal) );
+            break;
+        case( VT_DISPATCH ):
+            /*res = VarR8FromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,dblVal) );*/
+        case( VT_DECIMAL ):
+            /*res = VarR8FromDec( V_UNION(ps,deiVal), &V_UNION(pd,dblVal) );*/
+        case( VT_UNKNOWN ):
+        default:
+            res = DISP_E_TYPEMISMATCH;
+            FIXME("Coercion from %d to %d\n", vtFrom, vt );
+            break;
+        }
+        break;
+
+    case( VT_DATE ):
+        switch( vtFrom )
+        {
+        case( VT_I1 ):
+            res = VarDateFromI1( V_UNION(ps,cVal), &V_UNION(pd,date) );
+            break;
+        case( VT_I2 ):
+            res = VarDateFromI2( V_UNION(ps,iVal), &V_UNION(pd,date) );
+            break;
+        case( VT_INT ):
+            res = VarDateFromInt( V_UNION(ps,intVal), &V_UNION(pd,date) );
+            break;
+        case( VT_I4 ):
+            res = VarDateFromI4( V_UNION(ps,lVal), &V_UNION(pd,date) );
+            break;
+        case( VT_UI1 ):
+            res = VarDateFromUI1( V_UNION(ps,bVal), &V_UNION(pd,date) );
+            break;
+        case( VT_UI2 ):
+            res = VarDateFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,date) );
+            break;
+        case( VT_UINT ):
+            res = VarDateFromUint( V_UNION(ps,uintVal), &V_UNION(pd,date) );
+            break;
+        case( VT_UI4 ):
+            res = VarDateFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,date) );
+            break;
+        case( VT_R4 ):
+            res = VarDateFromR4( V_UNION(ps,fltVal), &V_UNION(pd,date) );
+            break;
+        case( VT_R8 ):
+            res = VarDateFromR8( V_UNION(ps,dblVal), &V_UNION(pd,date) );
+            break;
         case( VT_DATE ):
             res = VariantCopy( pd, ps );
             break;
-                case( VT_BOOL ):
-                        res = VarDateFromBool( V_UNION(ps,boolVal), &V_UNION(pd,date) );
-                        break;
-                case( VT_BSTR ):
-                        res = VarDateFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,date) );
-                        break;
-                case( VT_CY ):
-                        res = VarDateFromCy( V_UNION(ps,cyVal), &V_UNION(pd,date) );
-                        break;
-                case( VT_DISPATCH ):
-                        /*res = VarDateFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,date) );*/
-                case( VT_DECIMAL ):
-                        /*res = VarDateFromDec( V_UNION(ps,deiVal), &V_UNION(pd,date) );*/
-                case( VT_UNKNOWN ):
-                default:
-                        res = DISP_E_TYPEMISMATCH;
-                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                        break;
-                }
-                break;
-
-        case( VT_BOOL ):
-                switch( vtFrom )
-                {
-                case( VT_I1 ):
-                        res = VarBoolFromI1( V_UNION(ps,cVal), &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_I2 ):
-                        res = VarBoolFromI2( V_UNION(ps,iVal), &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_INT ):
-                        res = VarBoolFromInt( V_UNION(ps,intVal), &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_I4 ):
-                        res = VarBoolFromI4( V_UNION(ps,lVal), &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_UI1 ):
-                        res = VarBoolFromUI1( V_UNION(ps,bVal), &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_UI2 ):
-                        res = VarBoolFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_UINT ):
-                        res = VarBoolFromUint( V_UNION(ps,uintVal), &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_UI4 ):
-                        res = VarBoolFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_R4 ):
-                        res = VarBoolFromR4( V_UNION(ps,fltVal), &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_R8 ):
-                        res = VarBoolFromR8( V_UNION(ps,dblVal), &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_DATE ):
-                        res = VarBoolFromDate( V_UNION(ps,date), &V_UNION(pd,boolVal) );
-                        break;
+        case( VT_BOOL ):
+            res = VarDateFromBool( V_UNION(ps,boolVal), &V_UNION(pd,date) );
+            break;
+        case( VT_BSTR ):
+            res = VarDateFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,date) );
+            break;
+        case( VT_CY ):
+            res = VarDateFromCy( V_UNION(ps,cyVal), &V_UNION(pd,date) );
+            break;
+        case( VT_DISPATCH ):
+            /*res = VarDateFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,date) );*/
+        case( VT_DECIMAL ):
+            /*res = VarDateFromDec( V_UNION(ps,deiVal), &V_UNION(pd,date) );*/
+        case( VT_UNKNOWN ):
+        default:
+            res = DISP_E_TYPEMISMATCH;
+            FIXME("Coercion from %d to %d\n", vtFrom, vt );
+            break;
+        }
+        break;
+
+    case( VT_BOOL ):
+        switch( vtFrom )
+        {
+        case( VT_I1 ):
+            res = VarBoolFromI1( V_UNION(ps,cVal), &V_UNION(pd,boolVal) );
+            break;
+        case( VT_I2 ):
+            res = VarBoolFromI2( V_UNION(ps,iVal), &V_UNION(pd,boolVal) );
+            break;
+        case( VT_INT ):
+            res = VarBoolFromInt( V_UNION(ps,intVal), &V_UNION(pd,boolVal) );
+            break;
+        case( VT_I4 ):
+            res = VarBoolFromI4( V_UNION(ps,lVal), &V_UNION(pd,boolVal) );
+            break;
+        case( VT_UI1 ):
+            res = VarBoolFromUI1( V_UNION(ps,bVal), &V_UNION(pd,boolVal) );
+            break;
+        case( VT_UI2 ):
+            res = VarBoolFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,boolVal) );
+            break;
+        case( VT_UINT ):
+            res = VarBoolFromUint( V_UNION(ps,uintVal), &V_UNION(pd,boolVal) );
+            break;
+        case( VT_UI4 ):
+            res = VarBoolFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,boolVal) );
+            break;
+        case( VT_R4 ):
+            res = VarBoolFromR4( V_UNION(ps,fltVal), &V_UNION(pd,boolVal) );
+            break;
+        case( VT_R8 ):
+            res = VarBoolFromR8( V_UNION(ps,dblVal), &V_UNION(pd,boolVal) );
+            break;
+        case( VT_DATE ):
+            res = VarBoolFromDate( V_UNION(ps,date), &V_UNION(pd,boolVal) );
+            break;
         case( VT_BOOL ):
             res = VariantCopy( pd, ps );
             break;
-                case( VT_BSTR ):
-                        res = VarBoolFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_CY ):
-                        res = VarBoolFromCy( V_UNION(ps,cyVal), &V_UNION(pd,boolVal) );
-                        break;
-                case( VT_DISPATCH ):
-                        /*res = VarBoolFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,boolVal) );*/
-                case( VT_DECIMAL ):
-                        /*res = VarBoolFromDec( V_UNION(ps,deiVal), &V_UNION(pd,boolVal) );*/
-                case( VT_UNKNOWN ):
-                default:
-                        res = DISP_E_TYPEMISMATCH;
-                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                        break;
-                }
-                break;
-
-        case( VT_BSTR ):
-                switch( vtFrom )
-                {
-                case( VT_EMPTY ):
-                        if ((V_UNION(pd,bstrVal) = SysAllocStringLen(NULL, 0)))
-                                res = S_OK;
-                        else
-                                res = E_OUTOFMEMORY;
-                        break;
-                case( VT_I1 ):
-                        res = VarBstrFromI1( V_UNION(ps,cVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_I2 ):
-                        res = VarBstrFromI2( V_UNION(ps,iVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_INT ):
-                        res = VarBstrFromInt( V_UNION(ps,intVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_I4 ):
-                        res = VarBstrFromI4( V_UNION(ps,lVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_UI1 ):
-                        res = VarBstrFromUI1( V_UNION(ps,bVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_UI2 ):
-                        res = VarBstrFromUI2( V_UNION(ps,uiVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_UINT ):
-                        res = VarBstrFromUint( V_UNION(ps,uintVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_UI4 ):
-                        res = VarBstrFromUI4( V_UNION(ps,ulVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_R4 ):
-                        res = VarBstrFromR4( V_UNION(ps,fltVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_R8 ):
-                        res = VarBstrFromR8( V_UNION(ps,dblVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_DATE ):
-                        res = VarBstrFromDate( V_UNION(ps,date), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_BOOL ):
-                        res = VarBstrFromBool( V_UNION(ps,boolVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_BSTR ):
-                        res = VariantCopy( pd, ps );
-                        break;
-                case( VT_CY ):
-                        res = VarBstrFromCy( V_UNION(ps,cyVal), lcid, 0, &V_UNION(pd,bstrVal) );
-                        break;
-                case( VT_DISPATCH ):
-                        /*res = VarBstrFromDisp( V_UNION(ps,pdispVal), lcid, 0, &(pd,bstrVal) );*/
-                case( VT_DECIMAL ):
-                        /*res = VarBstrFromDec( V_UNION(ps,deiVal), lcid, 0, &(pd,bstrVal) );*/
-                case( VT_UNKNOWN ):
-                default:
-                        res = DISP_E_TYPEMISMATCH;
-                        FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                        break;
-                }
-                break;
+        case( VT_BSTR ):
+            res = VarBoolFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,boolVal) );
+            break;
+        case( VT_CY ):
+            res = VarBoolFromCy( V_UNION(ps,cyVal), &V_UNION(pd,boolVal) );
+            break;
+        case( VT_DISPATCH ):
+            /*res = VarBoolFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,boolVal) );*/
+        case( VT_DECIMAL ):
+            /*res = VarBoolFromDec( V_UNION(ps,deiVal), &V_UNION(pd,boolVal) );*/
+        case( VT_UNKNOWN ):
+        default:
+            res = DISP_E_TYPEMISMATCH;
+            FIXME("Coercion from %d to %d\n", vtFrom, vt );
+            break;
+        }
+        break;
+
+    case( VT_BSTR ):
+        switch( vtFrom )
+        {
+        case( VT_EMPTY ):
+            if ((V_UNION(pd,bstrVal) = SysAllocStringLen(NULL, 0)))
+                res = S_OK;
+            else
+                res = E_OUTOFMEMORY;
+            break;
+        case( VT_I1 ):
+            res = VarBstrFromI1( V_UNION(ps,cVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_I2 ):
+            res = VarBstrFromI2( V_UNION(ps,iVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_INT ):
+            res = VarBstrFromInt( V_UNION(ps,intVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_I4 ):
+            res = VarBstrFromI4( V_UNION(ps,lVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_UI1 ):
+            res = VarBstrFromUI1( V_UNION(ps,bVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_UI2 ):
+            res = VarBstrFromUI2( V_UNION(ps,uiVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_UINT ):
+            res = VarBstrFromUint( V_UNION(ps,uintVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_UI4 ):
+            res = VarBstrFromUI4( V_UNION(ps,ulVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_R4 ):
+            res = VarBstrFromR4( V_UNION(ps,fltVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_R8 ):
+            res = VarBstrFromR8( V_UNION(ps,dblVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_DATE ):
+            res = VarBstrFromDate( V_UNION(ps,date), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_BOOL ):
+            res = VarBstrFromBool( V_UNION(ps,boolVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_BSTR ):
+            res = VariantCopy( pd, ps );
+            break;
+        case( VT_CY ):
+            res = VarBstrFromCy( V_UNION(ps,cyVal), lcid, 0, &V_UNION(pd,bstrVal) );
+            break;
+        case( VT_DISPATCH ):
+            /*res = VarBstrFromDisp( V_UNION(ps,pdispVal), lcid, 0, &(pd,bstrVal) );*/
+        case( VT_DECIMAL ):
+            /*res = VarBstrFromDec( V_UNION(ps,deiVal), lcid, 0, &(pd,bstrVal) );*/
+        case( VT_UNKNOWN ):
+        default:
+            res = DISP_E_TYPEMISMATCH;
+            FIXME("Coercion from %d to %d\n", vtFrom, vt );
+            break;
+        }
+        break;
 
      case( VT_CY ):
-        switch( vtFrom )
-          {
-          case( VT_I1 ):
-             res = VarCyFromI1( V_UNION(ps,cVal), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_I2 ):
-             res = VarCyFromI2( V_UNION(ps,iVal), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_INT ):
-             res = VarCyFromInt( V_UNION(ps,intVal), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_I4 ):
-             res = VarCyFromI4( V_UNION(ps,lVal), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_UI1 ):
-             res = VarCyFromUI1( V_UNION(ps,bVal), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_UI2 ):
-             res = VarCyFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_UINT ):
-             res = VarCyFromUint( V_UNION(ps,uintVal), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_UI4 ):
-             res = VarCyFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_R4 ):
-             res = VarCyFromR4( V_UNION(ps,fltVal), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_R8 ):
-             res = VarCyFromR8( V_UNION(ps,dblVal), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_DATE ):
-             res = VarCyFromDate( V_UNION(ps,date), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_BOOL ):
-             res = VarCyFromBool( V_UNION(ps,date), &V_UNION(pd,cyVal) );
-             break;
-          case( VT_CY ):
-             res = VariantCopy( pd, ps );
-             break;
-          case( VT_BSTR ):
-             res = VarCyFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cyVal) );
-             break;
-          case( VT_DISPATCH ):
-             /*res = VarCyFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cyVal) );*/
-          case( VT_DECIMAL ):
-             /*res = VarCyFromDec( V_UNION(ps,deiVal), &V_UNION(pd,cyVal) );*/
-             break;
-          case( VT_UNKNOWN ):
-          default:
-             res = DISP_E_TYPEMISMATCH;
-             FIXME("Coercion from %d to %d\n", vtFrom, vt );
-             break;
-          }
-        break;
-
-        default:
-                res = DISP_E_TYPEMISMATCH;
-                FIXME("Coercion from %d to %d\n", vtFrom, vt );
-                break;
-        }
-        
-        return res;
-}
-
-/******************************************************************************
- *              ValidateVtRange [INTERNAL]
+    switch( vtFrom )
+      {
+      case( VT_I1 ):
+         res = VarCyFromI1( V_UNION(ps,cVal), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_I2 ):
+         res = VarCyFromI2( V_UNION(ps,iVal), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_INT ):
+         res = VarCyFromInt( V_UNION(ps,intVal), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_I4 ):
+         res = VarCyFromI4( V_UNION(ps,lVal), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_UI1 ):
+         res = VarCyFromUI1( V_UNION(ps,bVal), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_UI2 ):
+         res = VarCyFromUI2( V_UNION(ps,uiVal), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_UINT ):
+         res = VarCyFromUint( V_UNION(ps,uintVal), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_UI4 ):
+         res = VarCyFromUI4( V_UNION(ps,ulVal), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_R4 ):
+         res = VarCyFromR4( V_UNION(ps,fltVal), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_R8 ):
+         res = VarCyFromR8( V_UNION(ps,dblVal), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_DATE ):
+         res = VarCyFromDate( V_UNION(ps,date), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_BOOL ):
+         res = VarCyFromBool( V_UNION(ps,date), &V_UNION(pd,cyVal) );
+         break;
+      case( VT_CY ):
+         res = VariantCopy( pd, ps );
+         break;
+      case( VT_BSTR ):
+         res = VarCyFromStr( V_UNION(ps,bstrVal), lcid, 0, &V_UNION(pd,cyVal) );
+         break;
+      case( VT_DISPATCH ):
+         /*res = VarCyFromDisp( V_UNION(ps,pdispVal), lcid, &V_UNION(pd,cyVal) );*/
+      case( VT_DECIMAL ):
+         /*res = VarCyFromDec( V_UNION(ps,deiVal), &V_UNION(pd,cyVal) );*/
+         break;
+      case( VT_UNKNOWN ):
+      default:
+         res = DISP_E_TYPEMISMATCH;
+         FIXME("Coercion from %d to %d\n", vtFrom, vt );
+         break;
+      }
+    break;
+
+    default:
+        res = DISP_E_TYPEMISMATCH;
+        FIXME("Coercion from %d to %d\n", vtFrom, vt );
+        break;
+    }
+
+    return res;
+}
+
+/******************************************************************************
+ *      ValidateVtRange [INTERNAL]
  *
  * Used internally by the hi-level Variant API to determine
@@ -1608 +1609 @@
 
 /******************************************************************************
- *              ValidateVartype [INTERNAL]
+ *      ValidateVartype [INTERNAL]
  *
  * Used internally by the hi-level Variant API to determine
@@ -1615 +1616 @@
 static HRESULT WINAPI ValidateVariantType( VARTYPE vt )
 {
-        HRESULT res = S_OK;
-
-        /* check if we have a valid argument.
-         */
-        if( vt & VT_BYREF )
+    HRESULT res = S_OK;
+
+    /* check if we have a valid argument.
+     */
+    if( vt & VT_BYREF )
     {
         /* if by reference check that the type is in
@@ -1626 +1627 @@
         if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
             ( vt & VT_TYPEMASK ) == VT_NULL ||
-                        ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
-                {
-                        res = E_INVALIDARG;
-                }
-                        
+            ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
+        {
+            res = E_INVALIDARG;
+        }
+
     }
     else
@@ -1636 +1637 @@
         res = ValidateVtRange( vt );
     }
-                
-        return res;
-}
-
-/******************************************************************************
- *              ValidateVt      [INTERNAL]
+
+    return res;
+}
+
+/******************************************************************************
+ *      ValidateVt  [INTERNAL]
  *
  * Used internally by the hi-level Variant API to determine
@@ -1648 +1649 @@
 static HRESULT WINAPI ValidateVt( VARTYPE vt )
 {
-        HRESULT res = S_OK;
-
-        /* check if we have a valid argument.
-         */
-        if( vt & VT_BYREF )
+    HRESULT res = S_OK;
+
+    /* check if we have a valid argument.
+     */
+    if( vt & VT_BYREF )
     {
         /* if by reference check that the type is in
@@ -1659 +1660 @@
         if( ( vt & VT_TYPEMASK ) == VT_EMPTY ||
             ( vt & VT_TYPEMASK ) == VT_NULL ||
-                        ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
-                {
-                        res = DISP_E_BADVARTYPE;
-                }
-                        
+            ( vt & VT_TYPEMASK ) > VT_MAXVALIDTYPE )
+        {
+            res = DISP_E_BADVARTYPE;
+        }
+
     }
     else
@@ -1669 +1670 @@
         res = ValidateVtRange( vt );
     }
-                
-        return res;
-}
-
-
-
-
-
-/******************************************************************************
- *              VariantInit     [OLEAUT32.8]
+
+    return res;
+}
+
+
+
+
+
+/******************************************************************************
+ *      VariantInit [OLEAUT32.8]
  *
  * Initializes the Variant.  Unlike VariantClear it does not interpret the current
@@ -1694 +1695 @@
 
 /******************************************************************************
- *              VariantClear    [OLEAUT32.9]
+ *      VariantClear    [OLEAUT32.9]
  *
  * This function clears the VARIANT by setting the vt field to VT_EMPTY. It also
- * sets the wReservedX field to 0.      The current contents of the VARIANT are
+ * sets the wReservedX field to 0.  The current contents of the VARIANT are
  * freed.  If the vt is VT_BSTR the string is freed. If VT_DISPATCH the object is
  * released. If VT_ARRAY the array is freed.
@@ -1716 +1717 @@
       if ( (V_VT(pvarg) & VT_ARRAY) != 0)
       {
-        SafeArrayDestroy(V_UNION(pvarg,parray));
+    SafeArrayDestroy(V_UNION(pvarg,parray));
       }
       else
       {
-        switch( V_VT(pvarg) & VT_TYPEMASK )
-        {
-          case( VT_BSTR ):
-            SysFreeString( V_UNION(pvarg,bstrVal) );
-            break;
-          case( VT_DISPATCH ):
-            if(V_UNION(pvarg,pdispVal)!=NULL)
-              ICOM_CALL(Release,V_UNION(pvarg,pdispVal));
-            break;
-          case( VT_VARIANT ):
-            VariantClear(V_UNION(pvarg,pvarVal));
-            break;
-          case( VT_UNKNOWN ):
-            if(V_UNION(pvarg,punkVal)!=NULL)
-              ICOM_CALL(Release,V_UNION(pvarg,punkVal));
-            break;
-          case( VT_SAFEARRAY ):
-            SafeArrayDestroy(V_UNION(pvarg,parray));
-            break;
-          default:
-            break;
-        }
+    switch( V_VT(pvarg) & VT_TYPEMASK )
+    {
+      case( VT_BSTR ):
+        SysFreeString( V_UNION(pvarg,bstrVal) );
+        break;
+      case( VT_DISPATCH ):
+        if(V_UNION(pvarg,pdispVal)!=NULL)
+          ICOM_CALL(Release,V_UNION(pvarg,pdispVal));
+        break;
+      case( VT_VARIANT ):
+        VariantClear(V_UNION(pvarg,pvarVal));
+        break;
+      case( VT_UNKNOWN ):
+        if(V_UNION(pvarg,punkVal)!=NULL)
+          ICOM_CALL(Release,V_UNION(pvarg,punkVal));
+        break;
+      case( VT_SAFEARRAY ):
+        SafeArrayDestroy(V_UNION(pvarg,parray));
+        break;
+      default:
+        break;
+    }
       }
     }
-        
+
     /*
      * Empty all the fields and mark the type as empty.
@@ -1756 +1757 @@
 
 /******************************************************************************
- *              VariantCopy     [OLEAUT32.10]
+ *      VariantCopy [OLEAUT32.10]
  *
  * Frees up the designation variant and makes a copy of the source.
@@ -1774 +1775 @@
   {
     res = VariantClear( pvargDest );
-                
+
     if( res == S_OK )
     {
       if( V_VT(pvargSrc) & VT_BYREF )
       {
-        /* In the case of byreference we only need
-         * to copy the pointer.
-         */
-        pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
-        V_VT(pvargDest) = V_VT(pvargSrc);
+    /* In the case of byreference we only need
+     * to copy the pointer.
+     */
+    pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
+    V_VT(pvargDest) = V_VT(pvargSrc);
       }
       else
       {
-        /*
-         * The VT_ARRAY flag is another way to designate a safe array.
-         */
-        if (V_VT(pvargSrc) & VT_ARRAY)
-        {
-          SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
-        }
-        else
-        {
-          /* In the case of by value we need to
-           * copy the actuall value. In the case of
-           * VT_BSTR a copy of the string is made,
-           * if VT_DISPATCH or VT_IUNKNOWN AddReff is
-           * called to increment the object's reference count.
-           */
-          switch( V_VT(pvargSrc) & VT_TYPEMASK )
-          {
-            case( VT_BSTR ):
-              V_UNION(pvargDest,bstrVal) = SysAllocString( V_UNION(pvargSrc,bstrVal) );
-              break;
-            case( VT_DISPATCH ):
-              V_UNION(pvargDest,pdispVal) = V_UNION(pvargSrc,pdispVal);
-              if (V_UNION(pvargDest,pdispVal)!=NULL)
-                ICOM_CALL(AddRef,V_UNION(pvargDest,pdispVal));
-              break;
-            case( VT_VARIANT ):
-              VariantCopy(V_UNION(pvargDest,pvarVal),V_UNION(pvargSrc,pvarVal));
-              break;
-            case( VT_UNKNOWN ):
-              V_UNION(pvargDest,punkVal) = V_UNION(pvargSrc,punkVal);
-              if (V_UNION(pvargDest,pdispVal)!=NULL)
-                ICOM_CALL(AddRef,V_UNION(pvargDest,punkVal));
-              break;
-            case( VT_SAFEARRAY ):
-              SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
-              break;
-            default:
-              pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
-              break;
-          }
-        }
-        
-        V_VT(pvargDest) = V_VT(pvargSrc);
-      }      
+    /*
+     * The VT_ARRAY flag is another way to designate a safe array.
+     */
+    if (V_VT(pvargSrc) & VT_ARRAY)
+    {
+      SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
+    }
+    else
+    {
+      /* In the case of by value we need to
+       * copy the actuall value. In the case of
+       * VT_BSTR a copy of the string is made,
+       * if VT_DISPATCH or VT_IUNKNOWN AddReff is
+       * called to increment the object's reference count.
+       */
+      switch( V_VT(pvargSrc) & VT_TYPEMASK )
+      {
+        case( VT_BSTR ):
+          V_UNION(pvargDest,bstrVal) = SysAllocString( V_UNION(pvargSrc,bstrVal) );
+          break;
+        case( VT_DISPATCH ):
+          V_UNION(pvargDest,pdispVal) = V_UNION(pvargSrc,pdispVal);
+          if (V_UNION(pvargDest,pdispVal)!=NULL)
+        ICOM_CALL(AddRef,V_UNION(pvargDest,pdispVal));
+          break;
+        case( VT_VARIANT ):
+          VariantCopy(V_UNION(pvargDest,pvarVal),V_UNION(pvargSrc,pvarVal));
+          break;
+        case( VT_UNKNOWN ):
+          V_UNION(pvargDest,punkVal) = V_UNION(pvargSrc,punkVal);
+          if (V_UNION(pvargDest,pdispVal)!=NULL)
+        ICOM_CALL(AddRef,V_UNION(pvargDest,punkVal));
+          break;
+        case( VT_SAFEARRAY ):
+          SafeArrayCopy(V_UNION(pvargSrc,parray), &V_UNION(pvargDest,parray));
+          break;
+        default:
+          pvargDest->n1.n2.n3 = pvargSrc->n1.n2.n3;
+          break;
+      }
+    }
+
+    V_VT(pvargDest) = V_VT(pvargSrc);
+      }
     }
   }
@@ -1839 +1840 @@
 
 /******************************************************************************
- *              VariantCopyInd  [OLEAUT32.11]
+ *      VariantCopyInd  [OLEAUT32.11]
  *
  * Frees up the destination variant and makes a copy of the source.  If
@@ -1854 +1855 @@
   if( res != S_OK )
     return res;
-  
+
   if( V_VT(pvargSrc) & VT_BYREF )
   {
@@ -1876 +1877 @@
       if( res == S_OK )
       {
-        /*
-         * The VT_ARRAY flag is another way to designate a safearray variant.
-         */
-        if ( V_VT(pvargSrc) & VT_ARRAY)
-        {
-          SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
-        }
-        else
-        {
-          /* In the case of by reference we need
-           * to copy the date pointed to by the variant.
-           */
-
-          /* Get the variant type.
-           */
-          switch( V_VT(pvargSrc) & VT_TYPEMASK )
-          {
-            case( VT_BSTR ):
-              V_UNION(pvargDest,bstrVal) = SysAllocString( *(V_UNION(pvargSrc,pbstrVal)) );
-              break;
-            case( VT_DISPATCH ):
-              break;
-            case( VT_VARIANT ):
-              {
-                /* Prevent from cycling.  According to tests on
-                 * VariantCopyInd in Windows and the documentation
-                 * this API dereferences the inner Variants to only one depth.
-                 * If the inner Variant itself contains an
-                 * other inner variant the E_INVALIDARG error is
-                 * returned. 
-                 */
-                if( pvargSrc->n1.n2.wReserved1 & PROCESSING_INNER_VARIANT )
-                {
-                  /* If we get here we are attempting to deference
-                   * an inner variant that that is itself contained
-                   * in an inner variant so report E_INVALIDARG error.
-                   */
-                  res = E_INVALIDARG;
-                }
-                else
-                {
-                  /* Set the processing inner variant flag.
-                   * We will set this flag in the inner variant
-                   * that will be passed to the VariantCopyInd function.
-                   */
-                  (V_UNION(pvargSrc,pvarVal))->n1.n2.wReserved1 |= PROCESSING_INNER_VARIANT;
-                  
-                  /* Dereference the inner variant.
-                   */
-                  res = VariantCopyInd( pvargDest, V_UNION(pvargSrc,pvarVal) );
-                  /* We must also copy its type, I think.
-                   */
-                  V_VT(pvargSrc) = V_VT(V_UNION(pvargSrc,pvarVal));
-                }
-              }
-              break;
-            case( VT_UNKNOWN ):
-              break;
-            case( VT_SAFEARRAY ):
-              SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
-              break;
-            default:
-              /* This is a by reference Variant which means that the union
-               * part of the Variant contains a pointer to some data of
-               * type "V_VT(pvargSrc) & VT_TYPEMASK".
-               * We will deference this data in a generic fashion using
-               * the void pointer "Variant.u.byref".
-               * We will copy this data into the union of the destination
-               * Variant.
-               */
-              memcpy( &pvargDest->n1.n2, V_UNION(pvargSrc,byref), SizeOfVariantData( pvargSrc ) );
-              break;
-          }
-        }
-        
-        V_VT(pvargDest) = V_VT(pvargSrc) & VT_TYPEMASK;
+    /*
+     * The VT_ARRAY flag is another way to designate a safearray variant.
+     */
+    if ( V_VT(pvargSrc) & VT_ARRAY)
+    {
+      SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
+    }
+    else
+    {
+      /* In the case of by reference we need
+       * to copy the date pointed to by the variant.
+       */
+
+      /* Get the variant type.
+       */
+      switch( V_VT(pvargSrc) & VT_TYPEMASK )
+      {
+        case( VT_BSTR ):
+          V_UNION(pvargDest,bstrVal) = SysAllocString( *(V_UNION(pvargSrc,pbstrVal)) );
+          break;
+        case( VT_DISPATCH ):
+          break;
+        case( VT_VARIANT ):
+          {
+        /* Prevent from cycling.  According to tests on
+         * VariantCopyInd in Windows and the documentation
+         * this API dereferences the inner Variants to only one depth.
+         * If the inner Variant itself contains an
+         * other inner variant the E_INVALIDARG error is
+         * returned.
+         */
+        if( pvargSrc->n1.n2.wReserved1 & PROCESSING_INNER_VARIANT )
+        {
+          /* If we get here we are attempting to deference
+           * an inner variant that that is itself contained
+           * in an inner variant so report E_INVALIDARG error.
+           */
+          res = E_INVALIDARG;
+        }
+        else
+        {
+          /* Set the processing inner variant flag.
+           * We will set this flag in the inner variant
+           * that will be passed to the VariantCopyInd function.
+           */
+          (V_UNION(pvargSrc,pvarVal))->n1.n2.wReserved1 |= PROCESSING_INNER_VARIANT;
+
+          /* Dereference the inner variant.
+           */
+          res = VariantCopyInd( pvargDest, V_UNION(pvargSrc,pvarVal) );
+          /* We must also copy its type, I think.
+           */
+          V_VT(pvargSrc) = V_VT(V_UNION(pvargSrc,pvarVal));
+        }
+          }
+          break;
+        case( VT_UNKNOWN ):
+          break;
+        case( VT_SAFEARRAY ):
+          SafeArrayCopy(*V_UNION(pvargSrc,pparray), &V_UNION(pvargDest,parray));
+          break;
+        default:
+          /* This is a by reference Variant which means that the union
+           * part of the Variant contains a pointer to some data of
+           * type "V_VT(pvargSrc) & VT_TYPEMASK".
+           * We will deference this data in a generic fashion using
+           * the void pointer "Variant.u.byref".
+           * We will copy this data into the union of the destination
+           * Variant.
+           */
+          memcpy( &pvargDest->n1.n2, V_UNION(pvargSrc,byref), SizeOfVariantData( pvargSrc ) );
+          break;
+      }
+    }
+
+    V_VT(pvargDest) = V_VT(pvargSrc) & VT_TYPEMASK;
       }
     }
@@ -1968 +1969 @@
 
 /******************************************************************************
- *              VariantChangeType       [OLEAUT32.12]
+ *      VariantChangeType   [OLEAUT32.12]
  */
 HRESULT WINAPI VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
-                                                        USHORT wFlags, VARTYPE vt)
-{
-        return VariantChangeTypeEx( pvargDest, pvargSrc, 0, wFlags, vt );
-}
-
-/******************************************************************************
- *              VariantChangeTypeEx     [OLEAUT32.147]
+                            USHORT wFlags, VARTYPE vt)
+{
+    return VariantChangeTypeEx( pvargDest, pvargSrc, 0, wFlags, vt );
+}
+
+/******************************************************************************
+ *      VariantChangeTypeEx [OLEAUT32.147]
  */
 HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
-                                                          LCID lcid, USHORT wFlags, VARTYPE vt)
-{
-        HRESULT res = S_OK;
-        VARIANTARG varg;
-        VariantInit( &varg );
-        
-        TRACE("(%p, %p, %ld, %u, %u),stub\n", pvargDest, pvargSrc, lcid, wFlags, vt);
-
-        /* validate our source argument.
-         */
-        res = ValidateVariantType( V_VT(pvargSrc) );
-
-        /* validate the vartype.
-         */
-        if( res == S_OK )
-        {
-                res = ValidateVt( vt );
-        }
-
-        /* if we are doing an in-place conversion make a copy of the source.
-         */
-        if( res == S_OK && pvargDest == pvargSrc )
-        {
-                res = VariantCopy( &varg, pvargSrc );
-                pvargSrc = &varg;
-        }
-
-        if( res == S_OK )
-        {
-                /* free up the destination variant.
-                 */
-                res = VariantClear( pvargDest );
-        }
-
-        if( res == S_OK )
-        {
-                if( V_VT(pvargSrc) & VT_BYREF )
-                {
-                        /* Convert the source variant to a "byvalue" variant.
-                         */
-                        VARIANTARG Variant;
-                        VariantInit( &Variant );
-                        res = VariantCopyInd( &Variant, pvargSrc );
-                        if( res == S_OK )
-                        {
-                                res = Coerce( pvargDest, lcid, wFlags, &Variant, vt );
-                                /* this should not fail.
-                                 */
-                                VariantClear( &Variant );
-                        }
-        
-                }
-                else
-                {
-                        /* Use the current "byvalue" source variant.
-                         */
-                        res = Coerce( pvargDest, lcid, wFlags, pvargSrc, vt );
-                }
-        }
-        /* this should not fail.
-         */
-        VariantClear( &varg );
-        
-        /* set the type of the destination
-         */
-        if ( res == S_OK )
-                V_VT(pvargDest) = vt;
-
-        return res;
-}
-
-
-
-
-/******************************************************************************
- *              VarUI1FromI2            [OLEAUT32.130]
+                              LCID lcid, USHORT wFlags, VARTYPE vt)
+{
+    HRESULT res = S_OK;
+    VARIANTARG varg;
+    VariantInit( &varg );
+
+    TRACE("(%p, %p, %ld, %u, %u),stub\n", pvargDest, pvargSrc, lcid, wFlags, vt);
+
+    /* validate our source argument.
+     */
+    res = ValidateVariantType( V_VT(pvargSrc) );
+
+    /* validate the vartype.
+     */
+    if( res == S_OK )
+    {
+        res = ValidateVt( vt );
+    }
+
+    /* if we are doing an in-place conversion make a copy of the source.
+     */
+    if( res == S_OK && pvargDest == pvargSrc )
+    {
+        res = VariantCopy( &varg, pvargSrc );
+        pvargSrc = &varg;
+    }
+
+    if( res == S_OK )
+    {
+        /* free up the destination variant.
+         */
+        res = VariantClear( pvargDest );
+    }
+
+    if( res == S_OK )
+    {
+        if( V_VT(pvargSrc) & VT_BYREF )
+        {
+            /* Convert the source variant to a "byvalue" variant.
+             */
+            VARIANTARG Variant;
+            VariantInit( &Variant );
+            res = VariantCopyInd( &Variant, pvargSrc );
+            if( res == S_OK )
+            {
+                res = Coerce( pvargDest, lcid, wFlags, &Variant, vt );
+                /* this should not fail.
+                 */
+                VariantClear( &Variant );
+            }
+
+        }
+        else
+        {
+            /* Use the current "byvalue" source variant.
+             */
+            res = Coerce( pvargDest, lcid, wFlags, pvargSrc, vt );
+        }
+    }
+    /* this should not fail.
+     */
+    VariantClear( &varg );
+
+    /* set the type of the destination
+     */
+    if ( res == S_OK )
+        V_VT(pvargDest) = vt;
+
+    return res;
+}
+
+
+
+
+/******************************************************************************
+ *      VarUI1FromI2        [OLEAUT32.130]
  */
 HRESULT WINAPI VarUI1FromI2(short sIn, BYTE* pbOut)
 {
-        TRACE("( %d, %p ), stub\n", sIn, pbOut );
-
-        /* Check range of value.
-         */
-        if( sIn < UI1_MIN || sIn > UI1_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pbOut = (BYTE) sIn;
-        
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI1FromI4            [OLEAUT32.131]
+    TRACE("( %d, %p ), stub\n", sIn, pbOut );
+
+    /* Check range of value.
+     */
+    if( sIn < UI1_MIN || sIn > UI1_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pbOut = (BYTE) sIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI1FromI4        [OLEAUT32.131]
  */
 HRESULT WINAPI VarUI1FromI4(LONG lIn, BYTE* pbOut)
 {
-        TRACE("( %ld, %p ), stub\n", lIn, pbOut );
-
-        /* Check range of value.
-         */
-        if( lIn < UI1_MIN || lIn > UI1_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pbOut = (BYTE) lIn;
-        
-        return S_OK;
-}
-
-
-/******************************************************************************
- *              VarUI1FromR4            [OLEAUT32.132]
+    TRACE("( %ld, %p ), stub\n", lIn, pbOut );
+
+    /* Check range of value.
+     */
+    if( lIn < UI1_MIN || lIn > UI1_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pbOut = (BYTE) lIn;
+
+    return S_OK;
+}
+
+
+/******************************************************************************
+ *      VarUI1FromR4        [OLEAUT32.132]
  */
 HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut)
 {
-        TRACE("( %f, %p ), stub\n", fltIn, pbOut );
-
-        /* Check range of value.
+    TRACE("( %f, %p ), stub\n", fltIn, pbOut );
+
+    /* Check range of value.
      */
     fltIn = round( fltIn );
-        if( fltIn < UI1_MIN || fltIn > UI1_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pbOut = (BYTE) fltIn;
-        
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI1FromR8            [OLEAUT32.133]
+    if( fltIn < UI1_MIN || fltIn > UI1_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pbOut = (BYTE) fltIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI1FromR8        [OLEAUT32.133]
  */
 HRESULT WINAPI VarUI1FromR8(double dblIn, BYTE* pbOut)
 {
-        TRACE("( %f, %p ), stub\n", dblIn, pbOut );
-
-        /* Check range of value.
+    TRACE("( %f, %p ), stub\n", dblIn, pbOut );
+
+    /* Check range of value.
      */
     dblIn = round( dblIn );
-        if( dblIn < UI1_MIN || dblIn > UI1_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pbOut = (BYTE) dblIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI1FromDate          [OLEAUT32.135]
+    if( dblIn < UI1_MIN || dblIn > UI1_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pbOut = (BYTE) dblIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI1FromDate      [OLEAUT32.135]
  */
 HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
 {
-        TRACE("( %f, %p ), stub\n", dateIn, pbOut );
-
-        /* Check range of value.
+    TRACE("( %f, %p ), stub\n", dateIn, pbOut );
+
+    /* Check range of value.
      */
     dateIn = round( dateIn );
-        if( dateIn < UI1_MIN || dateIn > UI1_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pbOut = (BYTE) dateIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI1FromBool          [OLEAUT32.138]
+    if( dateIn < UI1_MIN || dateIn > UI1_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pbOut = (BYTE) dateIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI1FromBool      [OLEAUT32.138]
  */
 HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE* pbOut)
 {
-        TRACE("( %d, %p ), stub\n", boolIn, pbOut );
-
-        *pbOut = (BYTE) boolIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI1FromI1            [OLEAUT32.237]
+    TRACE("( %d, %p ), stub\n", boolIn, pbOut );
+
+    *pbOut = (BYTE) boolIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI1FromI1        [OLEAUT32.237]
  */
 HRESULT WINAPI VarUI1FromI1(CHAR cIn, BYTE* pbOut)
 {
-        TRACE("( %c, %p ), stub\n", cIn, pbOut );
-
-        *pbOut = cIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI1FromUI2           [OLEAUT32.238]
+    TRACE("( %c, %p ), stub\n", cIn, pbOut );
+
+    *pbOut = cIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI1FromUI2       [OLEAUT32.238]
  */
 HRESULT WINAPI VarUI1FromUI2(USHORT uiIn, BYTE* pbOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, pbOut );
-
-        /* Check range of value.
-         */
-        if( uiIn > UI1_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pbOut = (BYTE) uiIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI1FromUI4           [OLEAUT32.239]
+    TRACE("( %d, %p ), stub\n", uiIn, pbOut );
+
+    /* Check range of value.
+     */
+    if( uiIn > UI1_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pbOut = (BYTE) uiIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI1FromUI4       [OLEAUT32.239]
  */
 HRESULT WINAPI VarUI1FromUI4(ULONG ulIn, BYTE* pbOut)
 {
-        TRACE("( %ld, %p ), stub\n", ulIn, pbOut );
-
-        /* Check range of value.
-         */
-        if( ulIn > UI1_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pbOut = (BYTE) ulIn;
-
-        return S_OK;
-}
-
-
-/******************************************************************************
- *              VarUI1FromStr           [OLEAUT32.136]
+    TRACE("( %ld, %p ), stub\n", ulIn, pbOut );
+
+    /* Check range of value.
+     */
+    if( ulIn > UI1_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pbOut = (BYTE) ulIn;
+
+    return S_OK;
+}
+
+
+/******************************************************************************
+ *      VarUI1FromStr       [OLEAUT32.136]
  */
 HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
 {
-        double dValue = 0.0;
-        LPSTR pNewString = NULL;
-
-        TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, pbOut );
-
-        /* Check if we have a valid argument
-         */
-        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
-        RemoveCharacterFromString( pNewString, "," );
-        if( IsValidRealString( pNewString ) == FALSE )
-        {
-                return DISP_E_TYPEMISMATCH;
-        }
-
-        /* Convert the valid string to a floating point number.
-         */
-        dValue = atof( pNewString );
-        
-        /* We don't need the string anymore so free it.
-         */
-        HeapFree( GetProcessHeap(), 0 , pNewString );
-
-        /* Check range of value.
+    double dValue = 0.0;
+    LPSTR pNewString = NULL;
+
+    TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, pbOut );
+
+    /* Check if we have a valid argument
+     */
+    pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
+    RemoveCharacterFromString( pNewString, "," );
+    if( IsValidRealString( pNewString ) == FALSE )
+    {
+        return DISP_E_TYPEMISMATCH;
+    }
+
+    /* Convert the valid string to a floating point number.
+     */
+    dValue = atof( pNewString );
+
+    /* We don't need the string anymore so free it.
+     */
+    HeapFree( GetProcessHeap(), 0 , pNewString );
+
+    /* Check range of value.
      */
     dValue = round( dValue );
-        if( dValue < UI1_MIN || dValue > UI1_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pbOut = (BYTE) dValue;
-
-        return S_OK;
+    if( dValue < UI1_MIN || dValue > UI1_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pbOut = (BYTE) dValue;
+
+    return S_OK;
 }
 
@@ -2262 +2263 @@
 HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut) {
    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
-   
+
    if (t > UI1_MAX || t < UI1_MIN) return DISP_E_OVERFLOW;
-   
+
    *pbOut = (BYTE)t;
    return S_OK;
@@ -2270 +2271 @@
 
 /******************************************************************************
- *              VarI2FromUI1            [OLEAUT32.48]
+ *      VarI2FromUI1        [OLEAUT32.48]
  */
 HRESULT WINAPI VarI2FromUI1(BYTE bIn, short* psOut)
 {
-        TRACE("( 0x%08x, %p ), stub\n", bIn, psOut );
-
-        *psOut = (short) bIn;
-        
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI2FromI4             [OLEAUT32.49]
+    TRACE("( 0x%08x, %p ), stub\n", bIn, psOut );
+
+    *psOut = (short) bIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI2FromI4     [OLEAUT32.49]
  */
 HRESULT WINAPI VarI2FromI4(LONG lIn, short* psOut)
 {
-        TRACE("( %lx, %p ), stub\n", lIn, psOut );
-
-        /* Check range of value.
-         */
-        if( lIn < I2_MIN || lIn > I2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *psOut = (short) lIn;
-        
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI2FromR4             [OLEAUT32.50]
+    TRACE("( %lx, %p ), stub\n", lIn, psOut );
+
+    /* Check range of value.
+     */
+    if( lIn < I2_MIN || lIn > I2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *psOut = (short) lIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI2FromR4     [OLEAUT32.50]
  */
 HRESULT WINAPI VarI2FromR4(FLOAT fltIn, short* psOut)
 {
-        TRACE("( %f, %p ), stub\n", fltIn, psOut );
-
-        /* Check range of value.
+    TRACE("( %f, %p ), stub\n", fltIn, psOut );
+
+    /* Check range of value.
      */
     fltIn = round( fltIn );
-        if( fltIn < I2_MIN || fltIn > I2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *psOut = (short) fltIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI2FromR8             [OLEAUT32.51]
+    if( fltIn < I2_MIN || fltIn > I2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *psOut = (short) fltIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI2FromR8     [OLEAUT32.51]
  */
 HRESULT WINAPI VarI2FromR8(double dblIn, short* psOut)
 {
-        TRACE("( %f, %p ), stub\n", dblIn, psOut );
-
-        /* Check range of value.
+    TRACE("( %f, %p ), stub\n", dblIn, psOut );
+
+    /* Check range of value.
      */
     dblIn = round( dblIn );
-        if( dblIn < I2_MIN || dblIn > I2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *psOut = (short) dblIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI2FromDate           [OLEAUT32.53]
+    if( dblIn < I2_MIN || dblIn > I2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *psOut = (short) dblIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI2FromDate       [OLEAUT32.53]
  */
 HRESULT WINAPI VarI2FromDate(DATE dateIn, short* psOut)
 {
-        TRACE("( %f, %p ), stub\n", dateIn, psOut );
-
-        /* Check range of value.
+    TRACE("( %f, %p ), stub\n", dateIn, psOut );
+
+    /* Check range of value.
      */
     dateIn = round( dateIn );
-        if( dateIn < I2_MIN || dateIn > I2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *psOut = (short) dateIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI2FromBool           [OLEAUT32.56]
+    if( dateIn < I2_MIN || dateIn > I2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *psOut = (short) dateIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI2FromBool       [OLEAUT32.56]
  */
 HRESULT WINAPI VarI2FromBool(VARIANT_BOOL boolIn, short* psOut)
 {
-        TRACE("( %d, %p ), stub\n", boolIn, psOut );
-
-        *psOut = (short) boolIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI2FromI1             [OLEAUT32.205]
+    TRACE("( %d, %p ), stub\n", boolIn, psOut );
+
+    *psOut = (short) boolIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI2FromI1     [OLEAUT32.205]
  */
 HRESULT WINAPI VarI2FromI1(CHAR cIn, short* psOut)
 {
-        TRACE("( %c, %p ), stub\n", cIn, psOut );
-
-        *psOut = (short) cIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI2FromUI2            [OLEAUT32.206]
+    TRACE("( %c, %p ), stub\n", cIn, psOut );
+
+    *psOut = (short) cIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI2FromUI2        [OLEAUT32.206]
  */
 HRESULT WINAPI VarI2FromUI2(USHORT uiIn, short* psOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, psOut );
-
-        /* Check range of value.
-         */
-        if( uiIn > I2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *psOut = (short) uiIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI2FromUI4            [OLEAUT32.207]
+    TRACE("( %d, %p ), stub\n", uiIn, psOut );
+
+    /* Check range of value.
+     */
+    if( uiIn > I2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *psOut = (short) uiIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI2FromUI4        [OLEAUT32.207]
  */
 HRESULT WINAPI VarI2FromUI4(ULONG ulIn, short* psOut)
 {
-        TRACE("( %lx, %p ), stub\n", ulIn, psOut );
-
-        /* Check range of value.
-         */
-        if( ulIn < I2_MIN || ulIn > I2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *psOut = (short) ulIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI2FromStr            [OLEAUT32.54]
+    TRACE("( %lx, %p ), stub\n", ulIn, psOut );
+
+    /* Check range of value.
+     */
+    if( ulIn < I2_MIN || ulIn > I2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *psOut = (short) ulIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI2FromStr        [OLEAUT32.54]
  */
 HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, short* psOut)
 {
-        double dValue = 0.0;
-        LPSTR pNewString = NULL;
-
-        TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, psOut );
-
-        /* Check if we have a valid argument
-         */
-        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
-        RemoveCharacterFromString( pNewString, "," );
-        if( IsValidRealString( pNewString ) == FALSE )
-        {
-                return DISP_E_TYPEMISMATCH;
-        }
-
-        /* Convert the valid string to a floating point number.
-         */
-        dValue = atof( pNewString );
-        
-        /* We don't need the string anymore so free it.
-         */
-        HeapFree( GetProcessHeap(), 0, pNewString );
-
-        /* Check range of value.
+    double dValue = 0.0;
+    LPSTR pNewString = NULL;
+
+    TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, psOut );
+
+    /* Check if we have a valid argument
+     */
+    pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
+    RemoveCharacterFromString( pNewString, "," );
+    if( IsValidRealString( pNewString ) == FALSE )
+    {
+        return DISP_E_TYPEMISMATCH;
+    }
+
+    /* Convert the valid string to a floating point number.
+     */
+    dValue = atof( pNewString );
+
+    /* We don't need the string anymore so free it.
+     */
+    HeapFree( GetProcessHeap(), 0, pNewString );
+
+    /* Check range of value.
      */
     dValue = round( dValue );
-        if( dValue < I2_MIN || dValue > I2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *psOut = (short)  dValue;
-
-        return S_OK;
+    if( dValue < I2_MIN || dValue > I2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *psOut = (short)  dValue;
+
+    return S_OK;
 }
 
@@ -2468 +2469 @@
 HRESULT WINAPI VarI2FromCy(CY cyIn, short* psOut) {
    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
-   
+
    if (t > I2_MAX || t < I2_MIN) return DISP_E_OVERFLOW;
-   
+
    *psOut = (SHORT)t;
    return S_OK;
@@ -2476 +2477 @@
 
 /******************************************************************************
- *              VarI4FromUI1            [OLEAUT32.58]
+ *      VarI4FromUI1        [OLEAUT32.58]
  */
 HRESULT WINAPI VarI4FromUI1(BYTE bIn, LONG* plOut)
 {
-        TRACE("( %X, %p ), stub\n", bIn, plOut );
-
-        *plOut = (LONG) bIn;
-
-        return S_OK;
-}
-
-
-/******************************************************************************
- *              VarI4FromR4             [OLEAUT32.60]
+    TRACE("( %X, %p ), stub\n", bIn, plOut );
+
+    *plOut = (LONG) bIn;
+
+    return S_OK;
+}
+
+
+/******************************************************************************
+ *      VarI4FromR4     [OLEAUT32.60]
  */
 HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG* plOut)
 {
-        TRACE("( %f, %p ), stub\n", fltIn, plOut );
-
-        /* Check range of value.
+    TRACE("( %f, %p ), stub\n", fltIn, plOut );
+
+    /* Check range of value.
      */
     fltIn = round( fltIn );
-        if( fltIn < I4_MIN || fltIn > I4_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *plOut = (LONG) fltIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI4FromR8             [OLEAUT32.61]
+    if( fltIn < I4_MIN || fltIn > I4_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *plOut = (LONG) fltIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI4FromR8     [OLEAUT32.61]
  */
 HRESULT WINAPI VarI4FromR8(double dblIn, LONG* plOut)
 {
-        TRACE("( %f, %p ), stub\n", dblIn, plOut );
-
-        /* Check range of value.
+    TRACE("( %f, %p ), stub\n", dblIn, plOut );
+
+    /* Check range of value.
      */
     dblIn = round( dblIn );
-        if( dblIn < I4_MIN || dblIn > I4_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *plOut = (LONG) dblIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI4FromDate           [OLEAUT32.63]
+    if( dblIn < I4_MIN || dblIn > I4_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *plOut = (LONG) dblIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI4FromDate       [OLEAUT32.63]
  */
 HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG* plOut)
 {
-        TRACE("( %f, %p ), stub\n", dateIn, plOut );
-
-        /* Check range of value.
+    TRACE("( %f, %p ), stub\n", dateIn, plOut );
+
+    /* Check range of value.
      */
     dateIn = round( dateIn );
-        if( dateIn < I4_MIN || dateIn > I4_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *plOut = (LONG) dateIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI4FromBool           [OLEAUT32.66]
+    if( dateIn < I4_MIN || dateIn > I4_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *plOut = (LONG) dateIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI4FromBool       [OLEAUT32.66]
  */
 HRESULT WINAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG* plOut)
 {
-        TRACE("( %d, %p ), stub\n", boolIn, plOut );
-
-        *plOut = (LONG) boolIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI4FromI1             [OLEAUT32.209]
+    TRACE("( %d, %p ), stub\n", boolIn, plOut );
+
+    *plOut = (LONG) boolIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI4FromI1     [OLEAUT32.209]
  */
 HRESULT WINAPI VarI4FromI1(CHAR cIn, LONG* plOut)
 {
-        TRACE("( %c, %p ), stub\n", cIn, plOut );
-
-        *plOut = (LONG) cIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI4FromUI2            [OLEAUT32.210]
+    TRACE("( %c, %p ), stub\n", cIn, plOut );
+
+    *plOut = (LONG) cIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI4FromUI2        [OLEAUT32.210]
  */
 HRESULT WINAPI VarI4FromUI2(USHORT uiIn, LONG* plOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, plOut );
-
-        *plOut = (LONG) uiIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI4FromUI4            [OLEAUT32.211]
+    TRACE("( %d, %p ), stub\n", uiIn, plOut );
+
+    *plOut = (LONG) uiIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI4FromUI4        [OLEAUT32.211]
  */
 HRESULT WINAPI VarI4FromUI4(ULONG ulIn, LONG* plOut)
 {
-        TRACE("( %lx, %p ), stub\n", ulIn, plOut );
-
-        /* Check range of value.
-         */
-        if( ulIn < I4_MIN || ulIn > I4_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *plOut = (LONG) ulIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI4FromI2             [OLEAUT32.59]
+    TRACE("( %lx, %p ), stub\n", ulIn, plOut );
+
+    /* Check range of value.
+     */
+    if( ulIn < I4_MIN || ulIn > I4_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *plOut = (LONG) ulIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI4FromI2     [OLEAUT32.59]
  */
 HRESULT WINAPI VarI4FromI2(short sIn, LONG* plOut)
 {
-        TRACE("( %d, %p ), stub\n", sIn, plOut );
-
-        *plOut = (LONG) sIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI4FromStr            [OLEAUT32.64]
+    TRACE("( %d, %p ), stub\n", sIn, plOut );
+
+    *plOut = (LONG) sIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI4FromStr        [OLEAUT32.64]
  */
 HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG* plOut)
 {
-        double dValue = 0.0;
-        LPSTR pNewString = NULL;
-
-        TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, plOut );
-
-        /* Check if we have a valid argument
-         */
-        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
-        RemoveCharacterFromString( pNewString, "," );
-        if( IsValidRealString( pNewString ) == FALSE )
-        {
-                return DISP_E_TYPEMISMATCH;
-        }
-
-        /* Convert the valid string to a floating point number.
-         */
-        dValue = atof( pNewString );
-        
-        /* We don't need the string anymore so free it.
-         */
-        HeapFree( GetProcessHeap(), 0, pNewString );
-
-        /* Check range of value.
+    double dValue = 0.0;
+    LPSTR pNewString = NULL;
+
+    TRACE("( %p, 0x%08lx, 0x%08lx, %p ), stub\n", strIn, lcid, dwFlags, plOut );
+
+    /* Check if we have a valid argument
+     */
+    pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
+    RemoveCharacterFromString( pNewString, "," );
+    if( IsValidRealString( pNewString ) == FALSE )
+    {
+        return DISP_E_TYPEMISMATCH;
+    }
+
+    /* Convert the valid string to a floating point number.
+     */
+    dValue = atof( pNewString );
+
+    /* We don't need the string anymore so free it.
+     */
+    HeapFree( GetProcessHeap(), 0, pNewString );
+
+    /* Check range of value.
      */
     dValue = round( dValue );
-        if( dValue < I4_MIN || dValue > I4_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *plOut = (LONG) dValue;
-
-        return S_OK;
+    if( dValue < I4_MIN || dValue > I4_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *plOut = (LONG) dValue;
+
+    return S_OK;
 }
 
@@ -2661 +2662 @@
 HRESULT WINAPI VarI4FromCy(CY cyIn, LONG* plOut) {
    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
-   
+
    if (t > I4_MAX || t < I4_MIN) return DISP_E_OVERFLOW;
-   
+
    *plOut = (LONG)t;
    return S_OK;
@@ -2669 +2670 @@
 
 /******************************************************************************
- *              VarR4FromUI1            [OLEAUT32.68]
+ *      VarR4FromUI1        [OLEAUT32.68]
  */
 HRESULT WINAPI VarR4FromUI1(BYTE bIn, FLOAT* pfltOut)
 {
-        TRACE("( %X, %p ), stub\n", bIn, pfltOut );
-
-        *pfltOut = (FLOAT) bIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR4FromI2             [OLEAUT32.69]
+    TRACE("( %X, %p ), stub\n", bIn, pfltOut );
+
+    *pfltOut = (FLOAT) bIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR4FromI2     [OLEAUT32.69]
  */
 HRESULT WINAPI VarR4FromI2(short sIn, FLOAT* pfltOut)
 {
-        TRACE("( %d, %p ), stub\n", sIn, pfltOut );
-
-        *pfltOut = (FLOAT) sIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR4FromI4             [OLEAUT32.70]
+    TRACE("( %d, %p ), stub\n", sIn, pfltOut );
+
+    *pfltOut = (FLOAT) sIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR4FromI4     [OLEAUT32.70]
  */
 HRESULT WINAPI VarR4FromI4(LONG lIn, FLOAT* pfltOut)
 {
-        TRACE("( %lx, %p ), stub\n", lIn, pfltOut );
-
-        *pfltOut = (FLOAT) lIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR4FromR8             [OLEAUT32.71]
+    TRACE("( %lx, %p ), stub\n", lIn, pfltOut );
+
+    *pfltOut = (FLOAT) lIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR4FromR8     [OLEAUT32.71]
  */
 HRESULT WINAPI VarR4FromR8(double dblIn, FLOAT* pfltOut)
 {
-        TRACE("( %f, %p ), stub\n", dblIn, pfltOut );
-
-        /* Check range of value.
-         */
-        if( dblIn < -(FLT_MAX) || dblIn > FLT_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pfltOut = (FLOAT) dblIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR4FromDate           [OLEAUT32.73]
+    TRACE("( %f, %p ), stub\n", dblIn, pfltOut );
+
+    /* Check range of value.
+     */
+    if( dblIn < -(FLT_MAX) || dblIn > FLT_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pfltOut = (FLOAT) dblIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR4FromDate       [OLEAUT32.73]
  */
 HRESULT WINAPI VarR4FromDate(DATE dateIn, FLOAT* pfltOut)
 {
-        TRACE("( %f, %p ), stub\n", dateIn, pfltOut );
-
-        /* Check range of value.
-         */
-        if( dateIn < -(FLT_MAX) || dateIn > FLT_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pfltOut = (FLOAT) dateIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR4FromBool           [OLEAUT32.76]
+    TRACE("( %f, %p ), stub\n", dateIn, pfltOut );
+
+    /* Check range of value.
+     */
+    if( dateIn < -(FLT_MAX) || dateIn > FLT_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pfltOut = (FLOAT) dateIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR4FromBool       [OLEAUT32.76]
  */
 HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, FLOAT* pfltOut)
 {
-        TRACE("( %d, %p ), stub\n", boolIn, pfltOut );
-
-        *pfltOut = (FLOAT) boolIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR4FromI1             [OLEAUT32.213]
+    TRACE("( %d, %p ), stub\n", boolIn, pfltOut );
+
+    *pfltOut = (FLOAT) boolIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR4FromI1     [OLEAUT32.213]
  */
 HRESULT WINAPI VarR4FromI1(CHAR cIn, FLOAT* pfltOut)
 {
-        TRACE("( %c, %p ), stub\n", cIn, pfltOut );
-
-        *pfltOut = (FLOAT) cIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR4FromUI2            [OLEAUT32.214]
+    TRACE("( %c, %p ), stub\n", cIn, pfltOut );
+
+    *pfltOut = (FLOAT) cIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR4FromUI2        [OLEAUT32.214]
  */
 HRESULT WINAPI VarR4FromUI2(USHORT uiIn, FLOAT* pfltOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, pfltOut );
-
-        *pfltOut = (FLOAT) uiIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR4FromUI4            [OLEAUT32.215]
+    TRACE("( %d, %p ), stub\n", uiIn, pfltOut );
+
+    *pfltOut = (FLOAT) uiIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR4FromUI4        [OLEAUT32.215]
  */
 HRESULT WINAPI VarR4FromUI4(ULONG ulIn, FLOAT* pfltOut)
 {
-        TRACE("( %ld, %p ), stub\n", ulIn, pfltOut );
-
-        *pfltOut = (FLOAT) ulIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR4FromStr            [OLEAUT32.74]
+    TRACE("( %ld, %p ), stub\n", ulIn, pfltOut );
+
+    *pfltOut = (FLOAT) ulIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR4FromStr        [OLEAUT32.74]
  */
 HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, FLOAT* pfltOut)
 {
-        double dValue = 0.0;
-        LPSTR pNewString = NULL;
-
-        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pfltOut );
-
-        /* Check if we have a valid argument
-         */
-        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
-        RemoveCharacterFromString( pNewString, "," );
-        if( IsValidRealString( pNewString ) == FALSE )
-        {
-                return DISP_E_TYPEMISMATCH;
-        }
-
-        /* Convert the valid string to a floating point number.
-         */
-        dValue = atof( pNewString );
-        
-        /* We don't need the string anymore so free it.
-         */
-        HeapFree( GetProcessHeap(), 0, pNewString );
-
-        /* Check range of value.
-         */
-        if( dValue < -(FLT_MAX) || dValue > FLT_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pfltOut = (FLOAT) dValue;
-
-        return S_OK;
+    double dValue = 0.0;
+    LPSTR pNewString = NULL;
+
+    TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pfltOut );
+
+    /* Check if we have a valid argument
+     */
+    pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
+    RemoveCharacterFromString( pNewString, "," );
+    if( IsValidRealString( pNewString ) == FALSE )
+    {
+        return DISP_E_TYPEMISMATCH;
+    }
+
+    /* Convert the valid string to a floating point number.
+     */
+    dValue = atof( pNewString );
+
+    /* We don't need the string anymore so free it.
+     */
+    HeapFree( GetProcessHeap(), 0, pNewString );
+
+    /* Check range of value.
+     */
+    if( dValue < -(FLT_MAX) || dValue > FLT_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pfltOut = (FLOAT) dValue;
+
+    return S_OK;
 }
 
@@ -2835 +2836 @@
 HRESULT WINAPI VarR4FromCy(CY cyIn, FLOAT* pfltOut) {
    *pfltOut = (FLOAT)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
-   
+
    return S_OK;
 }
 
 /******************************************************************************
- *              VarR8FromUI1            [OLEAUT32.78]
+ *      VarR8FromUI1        [OLEAUT32.78]
  */
 HRESULT WINAPI VarR8FromUI1(BYTE bIn, double* pdblOut)
 {
-        TRACE("( %d, %p ), stub\n", bIn, pdblOut );
-
-        *pdblOut = (double) bIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR8FromI2             [OLEAUT32.79]
+    TRACE("( %d, %p ), stub\n", bIn, pdblOut );
+
+    *pdblOut = (double) bIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR8FromI2     [OLEAUT32.79]
  */
 HRESULT WINAPI VarR8FromI2(short sIn, double* pdblOut)
 {
-        TRACE("( %d, %p ), stub\n", sIn, pdblOut );
-
-        *pdblOut = (double) sIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR8FromI4             [OLEAUT32.80]
+    TRACE("( %d, %p ), stub\n", sIn, pdblOut );
+
+    *pdblOut = (double) sIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR8FromI4     [OLEAUT32.80]
  */
 HRESULT WINAPI VarR8FromI4(LONG lIn, double* pdblOut)
 {
-        TRACE("( %ld, %p ), stub\n", lIn, pdblOut );
-
-        *pdblOut = (double) lIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR8FromR4             [OLEAUT32.81]
+    TRACE("( %ld, %p ), stub\n", lIn, pdblOut );
+
+    *pdblOut = (double) lIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR8FromR4     [OLEAUT32.81]
  */
 HRESULT WINAPI VarR8FromR4(FLOAT fltIn, double* pdblOut)
 {
-        TRACE("( %f, %p ), stub\n", fltIn, pdblOut );
-
-        *pdblOut = (double) fltIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR8FromDate           [OLEAUT32.83]
+    TRACE("( %f, %p ), stub\n", fltIn, pdblOut );
+
+    *pdblOut = (double) fltIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR8FromDate       [OLEAUT32.83]
  */
 HRESULT WINAPI VarR8FromDate(DATE dateIn, double* pdblOut)
 {
-        TRACE("( %f, %p ), stub\n", dateIn, pdblOut );
-
-        *pdblOut = (double) dateIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR8FromBool           [OLEAUT32.86]
+    TRACE("( %f, %p ), stub\n", dateIn, pdblOut );
+
+    *pdblOut = (double) dateIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR8FromBool       [OLEAUT32.86]
  */
 HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double* pdblOut)
 {
-        TRACE("( %d, %p ), stub\n", boolIn, pdblOut );
-
-        *pdblOut = (double) boolIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR8FromI1             [OLEAUT32.217]
+    TRACE("( %d, %p ), stub\n", boolIn, pdblOut );
+
+    *pdblOut = (double) boolIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR8FromI1     [OLEAUT32.217]
  */
 HRESULT WINAPI VarR8FromI1(CHAR cIn, double* pdblOut)
 {
-        TRACE("( %c, %p ), stub\n", cIn, pdblOut );
-
-        *pdblOut = (double) cIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR8FromUI2            [OLEAUT32.218]
+    TRACE("( %c, %p ), stub\n", cIn, pdblOut );
+
+    *pdblOut = (double) cIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR8FromUI2        [OLEAUT32.218]
  */
 HRESULT WINAPI VarR8FromUI2(USHORT uiIn, double* pdblOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, pdblOut );
-
-        *pdblOut = (double) uiIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR8FromUI4            [OLEAUT32.219]
+    TRACE("( %d, %p ), stub\n", uiIn, pdblOut );
+
+    *pdblOut = (double) uiIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR8FromUI4        [OLEAUT32.219]
  */
 HRESULT WINAPI VarR8FromUI4(ULONG ulIn, double* pdblOut)
 {
-        TRACE("( %ld, %p ), stub\n", ulIn, pdblOut );
-
-        *pdblOut = (double) ulIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarR8FromStr            [OLEAUT32.84]
+    TRACE("( %ld, %p ), stub\n", ulIn, pdblOut );
+
+    *pdblOut = (double) ulIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarR8FromStr        [OLEAUT32.84]
  */
 HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double* pdblOut)
 {
-        double dValue = 0.0;
-        LPSTR pNewString = NULL;
-
-        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pdblOut );
-
-        /* Check if we have a valid argument
-         */
-        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
-        RemoveCharacterFromString( pNewString, "," );
-        if( IsValidRealString( pNewString ) == FALSE )
-        {
-                return DISP_E_TYPEMISMATCH;
-        }
-
-        /* Convert the valid string to a floating point number.
-         */
-        dValue = atof( pNewString );
-        
-        /* We don't need the string anymore so free it.
-         */
-        HeapFree( GetProcessHeap(), 0, pNewString );
-
-        *pdblOut = dValue;
-
-        return S_OK;
+    double dValue = 0.0;
+    LPSTR pNewString = NULL;
+
+    TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pdblOut );
+
+    /* Check if we have a valid argument
+     */
+    pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
+    RemoveCharacterFromString( pNewString, "," );
+    if( IsValidRealString( pNewString ) == FALSE )
+    {
+        return DISP_E_TYPEMISMATCH;
+    }
+
+    /* Convert the valid string to a floating point number.
+     */
+    dValue = atof( pNewString );
+
+    /* We don't need the string anymore so free it.
+     */
+    HeapFree( GetProcessHeap(), 0, pNewString );
+
+    *pdblOut = dValue;
+
+    return S_OK;
 }
 
@@ -2985 +2986 @@
 HRESULT WINAPI VarR8FromCy(CY cyIn, double* pdblOut) {
    *pdblOut = (double)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
-   
+
    return S_OK;
 }
 
 /******************************************************************************
- *              VarDateFromUI1          [OLEAUT32.88]
+ *      VarDateFromUI1      [OLEAUT32.88]
  */
 HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
 {
-        TRACE("( %d, %p ), stub\n", bIn, pdateOut );
-
-        *pdateOut = (DATE) bIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarDateFromI2           [OLEAUT32.89]
+    TRACE("( %d, %p ), stub\n", bIn, pdateOut );
+
+    *pdateOut = (DATE) bIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarDateFromI2       [OLEAUT32.89]
  */
 HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
 {
-        TRACE("( %d, %p ), stub\n", sIn, pdateOut );
-
-        *pdateOut = (DATE) sIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarDateFromI4           [OLEAUT32.90]
+    TRACE("( %d, %p ), stub\n", sIn, pdateOut );
+
+    *pdateOut = (DATE) sIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarDateFromI4       [OLEAUT32.90]
  */
 HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut)
 {
-        TRACE("( %ld, %p ), stub\n", lIn, pdateOut );
-
-        if( lIn < DATE_MIN || lIn > DATE_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pdateOut = (DATE) lIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarDateFromR4           [OLEAUT32.91]
+    TRACE("( %ld, %p ), stub\n", lIn, pdateOut );
+
+    if( lIn < DATE_MIN || lIn > DATE_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pdateOut = (DATE) lIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarDateFromR4       [OLEAUT32.91]
  */
 HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut)
@@ -3038 +3039 @@
 
     if( ceil(fltIn) < DATE_MIN || floor(fltIn) > DATE_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pdateOut = (DATE) fltIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarDateFromR8           [OLEAUT32.92]
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pdateOut = (DATE) fltIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarDateFromR8       [OLEAUT32.92]
  */
 HRESULT WINAPI VarDateFromR8(double dblIn, DATE* pdateOut)
@@ -3054 +3055 @@
     TRACE("( %f, %p ), stub\n", dblIn, pdateOut );
 
-        if( ceil(dblIn) < DATE_MIN || floor(dblIn) > DATE_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pdateOut = (DATE) dblIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarDateFromStr          [OLEAUT32.94]
+    if( ceil(dblIn) < DATE_MIN || floor(dblIn) > DATE_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pdateOut = (DATE) dblIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarDateFromStr      [OLEAUT32.94]
  * The string representing the date is composed of two parts, a date and time.
  *
@@ -3074 +3075 @@
  *
  * The formats for the date part are has follows:
- * mm/[dd/][yy]yy 
+ * mm/[dd/][yy]yy
  * [dd/]mm/[yy]yy
- * [yy]yy/mm/dd 
+ * [yy]yy/mm/dd
  * January dd[,] [yy]yy
  * dd January [yy]yy
@@ -3083 +3084 @@
  *
  * The formats for the date and time string are has follows.
- * date[whitespace][time] 
+ * date[whitespace][time]
  * [time][whitespace]date
  *
@@ -3111 +3112 @@
 
 
-        return ret;
-}
-
-/******************************************************************************
- *              VarDateFromI1           [OLEAUT32.221]
+    return ret;
+}
+
+/******************************************************************************
+ *      VarDateFromI1       [OLEAUT32.221]
  */
 HRESULT WINAPI VarDateFromI1(CHAR cIn, DATE* pdateOut)
 {
-        TRACE("( %c, %p ), stub\n", cIn, pdateOut );
-
-        *pdateOut = (DATE) cIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarDateFromUI2          [OLEAUT32.222]
+    TRACE("( %c, %p ), stub\n", cIn, pdateOut );
+
+    *pdateOut = (DATE) cIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarDateFromUI2      [OLEAUT32.222]
  */
 HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, pdateOut );
-
-        if( uiIn > DATE_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pdateOut = (DATE) uiIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarDateFromUI4          [OLEAUT32.223]
+    TRACE("( %d, %p ), stub\n", uiIn, pdateOut );
+
+    if( uiIn > DATE_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pdateOut = (DATE) uiIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarDateFromUI4      [OLEAUT32.223]
  */
 HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
 {
-        TRACE("( %ld, %p ), stub\n", ulIn, pdateOut );
-
-        if( ulIn < DATE_MIN || ulIn > DATE_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pdateOut = (DATE) ulIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarDateFromBool         [OLEAUT32.96]
+    TRACE("( %ld, %p ), stub\n", ulIn, pdateOut );
+
+    if( ulIn < DATE_MIN || ulIn > DATE_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pdateOut = (DATE) ulIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarDateFromBool     [OLEAUT32.96]
  */
 HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
 {
-        TRACE("( %d, %p ), stub\n", boolIn, pdateOut );
-
-        *pdateOut = (DATE) boolIn;
-
-        return S_OK;
+    TRACE("( %d, %p ), stub\n", boolIn, pdateOut );
+
+    *pdateOut = (DATE) boolIn;
+
+    return S_OK;
 }
 
@@ -3184 +3185 @@
 
 /******************************************************************************
- *              VarBstrFromUI1          [OLEAUT32.108]
+ *      VarBstrFromUI1      [OLEAUT32.108]
  */
 HRESULT WINAPI VarBstrFromUI1(BYTE bVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
-        TRACE("( %d, %ld, %ld, %p ), stub\n", bVal, lcid, dwFlags, pbstrOut );
-        sprintf( pBuffer, "%d", bVal );
-
-        *pbstrOut =  StringDupAtoBstr( pBuffer );
-        
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBstrFromI2           [OLEAUT32.109]
+    TRACE("( %d, %ld, %ld, %p ), stub\n", bVal, lcid, dwFlags, pbstrOut );
+    sprintf( pBuffer, "%d", bVal );
+
+    *pbstrOut =  StringDupAtoBstr( pBuffer );
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBstrFromI2       [OLEAUT32.109]
  */
 HRESULT WINAPI VarBstrFromI2(short iVal, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
-        TRACE("( %d, %ld, %ld, %p ), stub\n", iVal, lcid, dwFlags, pbstrOut );
-        sprintf( pBuffer, "%d", iVal );
-        *pbstrOut = StringDupAtoBstr( pBuffer );
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBstrFromI4           [OLEAUT32.110]
+    TRACE("( %d, %ld, %ld, %p ), stub\n", iVal, lcid, dwFlags, pbstrOut );
+    sprintf( pBuffer, "%d", iVal );
+    *pbstrOut = StringDupAtoBstr( pBuffer );
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBstrFromI4       [OLEAUT32.110]
  */
 HRESULT WINAPI VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
-        TRACE("( %ld, %ld, %ld, %p ), stub\n", lIn, lcid, dwFlags, pbstrOut );
-
-        sprintf( pBuffer, "%ld", lIn );
-        *pbstrOut = StringDupAtoBstr( pBuffer );
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBstrFromR4           [OLEAUT32.111]
+    TRACE("( %ld, %ld, %ld, %p ), stub\n", lIn, lcid, dwFlags, pbstrOut );
+
+    sprintf( pBuffer, "%ld", lIn );
+    *pbstrOut = StringDupAtoBstr( pBuffer );
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBstrFromR4       [OLEAUT32.111]
  */
 HRESULT WINAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
-        TRACE("( %f, %ld, %ld, %p ), stub\n", fltIn, lcid, dwFlags, pbstrOut );
-
-        sprintf( pBuffer, "%.7g", fltIn );
-        *pbstrOut = StringDupAtoBstr( pBuffer );
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBstrFromR8           [OLEAUT32.112]
+    TRACE("( %f, %ld, %ld, %p ), stub\n", fltIn, lcid, dwFlags, pbstrOut );
+
+    sprintf( pBuffer, "%.7g", fltIn );
+    *pbstrOut = StringDupAtoBstr( pBuffer );
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBstrFromR8       [OLEAUT32.112]
  */
 HRESULT WINAPI VarBstrFromR8(double dblIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
-        TRACE("( %f, %ld, %ld, %p ), stub\n", dblIn, lcid, dwFlags, pbstrOut );
-
-        sprintf( pBuffer, "%.15g", dblIn );
-        *pbstrOut = StringDupAtoBstr( pBuffer );
-
-        return S_OK;
+    TRACE("( %f, %ld, %ld, %p ), stub\n", dblIn, lcid, dwFlags, pbstrOut );
+
+    sprintf( pBuffer, "%.15g", dblIn );
+    *pbstrOut = StringDupAtoBstr( pBuffer );
+
+    return S_OK;
 }
 
@@ -3251 +3252 @@
  */
 HRESULT WINAPI VarBstrFromCy(CY cyIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut) {
-                                /* FIXME */
-        return E_NOTIMPL;
-}
-
- 
-/******************************************************************************
- *              VarBstrFromDate         [OLEAUT32.114]
+                /* FIXME */
+    return E_NOTIMPL;
+}
+
+
+/******************************************************************************
+ *      VarBstrFromDate     [OLEAUT32.114]
  *
  * The date is implemented using an 8 byte floating-point number.
@@ -3274 +3275 @@
  * The tm structure is as follows:
  * struct tm {
- *                int tm_sec;      seconds after the minute - [0,59]
- *                int tm_min;      minutes after the hour - [0,59]
- *                int tm_hour;     hours since midnight - [0,23]
- *                int tm_mday;     day of the month - [1,31]
- *                int tm_mon;      months since January - [0,11]
- *                int tm_year;     years
- *                int tm_wday;     days since Sunday - [0,6]
- *                int tm_yday;     days since January 1 - [0,365]
- *                int tm_isdst;    daylight savings time flag
- *                };
+ *        int tm_sec;      seconds after the minute - [0,59]
+ *        int tm_min;      minutes after the hour - [0,59]
+ *        int tm_hour;     hours since midnight - [0,23]
+ *        int tm_mday;     day of the month - [1,31]
+ *        int tm_mon;      months since January - [0,11]
+ *        int tm_year;     years
+ *        int tm_wday;     days since Sunday - [0,6]
+ *        int tm_yday;     days since January 1 - [0,365]
+ *        int tm_isdst;    daylight savings time flag
+ *        };
  */
 HRESULT WINAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
@@ -3293 +3294 @@
 
     if( DateToTm( dateIn, dwFlags, &TM ) == FALSE )
-                        {
+            {
         return E_INVALIDARG;
-                }
+        }
 
     if( dwFlags & VAR_DATEVALUEONLY )
-                        strftime( pBuffer, BUFFER_MAX, "%x", &TM );
+            strftime( pBuffer, BUFFER_MAX, "%x", &TM );
     else if( dwFlags & VAR_TIMEVALUEONLY )
-                        strftime( pBuffer, BUFFER_MAX, "%X", &TM );
-                else
+            strftime( pBuffer, BUFFER_MAX, "%X", &TM );
+        else
         strftime( pBuffer, BUFFER_MAX, "%x %X", &TM );
 
-                *pbstrOut = StringDupAtoBstr( pBuffer );
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBstrFromBool         [OLEAUT32.116]
+        *pbstrOut = StringDupAtoBstr( pBuffer );
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBstrFromBool     [OLEAUT32.116]
  */
 HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
-        TRACE("( %d, %ld, %ld, %p ), stub\n", boolIn, lcid, dwFlags, pbstrOut );
-
-        if( boolIn == VARIANT_FALSE )
-        {
-                sprintf( pBuffer, "False" );
-        }
-        else
-        {
-                sprintf( pBuffer, "True" );
-        }
-
-        *pbstrOut = StringDupAtoBstr( pBuffer );
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBstrFromI1           [OLEAUT32.229]
+    TRACE("( %d, %ld, %ld, %p ), stub\n", boolIn, lcid, dwFlags, pbstrOut );
+
+    if( boolIn == VARIANT_FALSE )
+    {
+        sprintf( pBuffer, "False" );
+    }
+    else
+    {
+        sprintf( pBuffer, "True" );
+    }
+
+    *pbstrOut = StringDupAtoBstr( pBuffer );
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBstrFromI1       [OLEAUT32.229]
  */
 HRESULT WINAPI VarBstrFromI1(CHAR cIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
-        TRACE("( %c, %ld, %ld, %p ), stub\n", cIn, lcid, dwFlags, pbstrOut );
-        sprintf( pBuffer, "%d", cIn );
-        *pbstrOut = StringDupAtoBstr( pBuffer );
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBstrFromUI2          [OLEAUT32.230]
+    TRACE("( %c, %ld, %ld, %p ), stub\n", cIn, lcid, dwFlags, pbstrOut );
+    sprintf( pBuffer, "%d", cIn );
+    *pbstrOut = StringDupAtoBstr( pBuffer );
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBstrFromUI2      [OLEAUT32.230]
  */
 HRESULT WINAPI VarBstrFromUI2(USHORT uiIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
-        TRACE("( %d, %ld, %ld, %p ), stub\n", uiIn, lcid, dwFlags, pbstrOut );
-        sprintf( pBuffer, "%d", uiIn );
-        *pbstrOut = StringDupAtoBstr( pBuffer );
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBstrFromUI4          [OLEAUT32.231]
+    TRACE("( %d, %ld, %ld, %p ), stub\n", uiIn, lcid, dwFlags, pbstrOut );
+    sprintf( pBuffer, "%d", uiIn );
+    *pbstrOut = StringDupAtoBstr( pBuffer );
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBstrFromUI4      [OLEAUT32.231]
  */
 HRESULT WINAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
 {
-        TRACE("( %ld, %ld, %ld, %p ), stub\n", ulIn, lcid, dwFlags, pbstrOut );
-        sprintf( pBuffer, "%ld", ulIn );
-        *pbstrOut = StringDupAtoBstr( pBuffer );
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBoolFromUI1          [OLEAUT32.118]
+    TRACE("( %ld, %ld, %ld, %p ), stub\n", ulIn, lcid, dwFlags, pbstrOut );
+    sprintf( pBuffer, "%ld", ulIn );
+    *pbstrOut = StringDupAtoBstr( pBuffer );
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBoolFromUI1      [OLEAUT32.118]
  */
 HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL* pboolOut)
 {
-        TRACE("( %d, %p ), stub\n", bIn, pboolOut );
-
-        if( bIn == 0 )
-        {
-                *pboolOut = VARIANT_FALSE;
-        }
-        else
-        {
-                *pboolOut = VARIANT_TRUE;
-        }
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBoolFromI2           [OLEAUT32.119]
+    TRACE("( %d, %p ), stub\n", bIn, pboolOut );
+
+    if( bIn == 0 )
+    {
+        *pboolOut = VARIANT_FALSE;
+    }
+    else
+    {
+        *pboolOut = VARIANT_TRUE;
+    }
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBoolFromI2       [OLEAUT32.119]
  */
 HRESULT WINAPI VarBoolFromI2(short sIn, VARIANT_BOOL* pboolOut)
 {
-        TRACE("( %d, %p ), stub\n", sIn, pboolOut );
-
-        if( sIn == 0 )
-        {
-                *pboolOut = VARIANT_FALSE;
-        }
-        else
-        {
-                *pboolOut = VARIANT_TRUE;
-        }
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBoolFromI4           [OLEAUT32.120]
+    TRACE("( %d, %p ), stub\n", sIn, pboolOut );
+
+    if( sIn == 0 )
+    {
+        *pboolOut = VARIANT_FALSE;
+    }
+    else
+    {
+        *pboolOut = VARIANT_TRUE;
+    }
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBoolFromI4       [OLEAUT32.120]
  */
 HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL* pboolOut)
 {
-        TRACE("( %ld, %p ), stub\n", lIn, pboolOut );
-
-        if( lIn == 0 )
-        {
-                *pboolOut = VARIANT_FALSE;
-        }
-        else
-        {
-                *pboolOut = VARIANT_TRUE;
-        }
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBoolFromR4           [OLEAUT32.121]
+    TRACE("( %ld, %p ), stub\n", lIn, pboolOut );
+
+    if( lIn == 0 )
+    {
+        *pboolOut = VARIANT_FALSE;
+    }
+    else
+    {
+        *pboolOut = VARIANT_TRUE;
+    }
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBoolFromR4       [OLEAUT32.121]
  */
 HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL* pboolOut)
 {
-        TRACE("( %f, %p ), stub\n", fltIn, pboolOut );
-
-        if( fltIn == 0.0 )
-        {
-                *pboolOut = VARIANT_FALSE;
-        }
-        else
-        {
-                *pboolOut = VARIANT_TRUE;
-        }
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBoolFromR8           [OLEAUT32.122]
+    TRACE("( %f, %p ), stub\n", fltIn, pboolOut );
+
+    if( fltIn == 0.0 )
+    {
+        *pboolOut = VARIANT_FALSE;
+    }
+    else
+    {
+        *pboolOut = VARIANT_TRUE;
+    }
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBoolFromR8       [OLEAUT32.122]
  */
 HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL* pboolOut)
 {
-        TRACE("( %f, %p ), stub\n", dblIn, pboolOut );
-
-        if( dblIn == 0.0 )
-        {
-                *pboolOut = VARIANT_FALSE;
-        }
-        else
-        {
-                *pboolOut = VARIANT_TRUE;
-        }
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBoolFromDate         [OLEAUT32.123]
+    TRACE("( %f, %p ), stub\n", dblIn, pboolOut );
+
+    if( dblIn == 0.0 )
+    {
+        *pboolOut = VARIANT_FALSE;
+    }
+    else
+    {
+        *pboolOut = VARIANT_TRUE;
+    }
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBoolFromDate     [OLEAUT32.123]
  */
 HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL* pboolOut)
 {
-        TRACE("( %f, %p ), stub\n", dateIn, pboolOut );
-
-        if( dateIn == 0.0 )
-        {
-                *pboolOut = VARIANT_FALSE;
-        }
-        else
-        {
-                *pboolOut = VARIANT_TRUE;
-        }
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBoolFromStr          [OLEAUT32.125]
+    TRACE("( %f, %p ), stub\n", dateIn, pboolOut );
+
+    if( dateIn == 0.0 )
+    {
+        *pboolOut = VARIANT_FALSE;
+    }
+    else
+    {
+        *pboolOut = VARIANT_TRUE;
+    }
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBoolFromStr      [OLEAUT32.125]
  */
 HRESULT WINAPI VarBoolFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL* pboolOut)
 {
-        HRESULT ret = S_OK;
-        char* pNewString = NULL;
-
-        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pboolOut );
+    HRESULT ret = S_OK;
+    char* pNewString = NULL;
+
+    TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pboolOut );
 
     pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
 
-        if( pNewString == NULL || strlen( pNewString ) == 0 )
-        {
-                ret = DISP_E_TYPEMISMATCH;
-        }
-
-        if( ret == S_OK )
-        {
-                if( strncasecmp( pNewString, "True", strlen( pNewString ) ) == 0 )
-                {
-                        *pboolOut = VARIANT_TRUE;
-                }
-                else if( strncasecmp( pNewString, "False", strlen( pNewString ) ) == 0 )
-                {
-                        *pboolOut = VARIANT_FALSE;
-                }
-                else
-                {
-                        /* Try converting the string to a floating point number.
-                         */
-                        double dValue = 0.0;
-                        HRESULT res = VarR8FromStr( strIn, lcid, dwFlags, &dValue );
-                        if( res != S_OK )
-                        {
-                                ret = DISP_E_TYPEMISMATCH;
-                        }
-                        else if( dValue == 0.0 )
-                        {
-                                *pboolOut = VARIANT_FALSE;
-                        }
-                        else
-                        {
-                                *pboolOut = VARIANT_TRUE;
-                        }
-                }
-        }
-
-        HeapFree( GetProcessHeap(), 0, pNewString );
-        
-        return ret;
-}
-
-/******************************************************************************
- *              VarBoolFromI1           [OLEAUT32.233]
+    if( pNewString == NULL || strlen( pNewString ) == 0 )
+    {
+        ret = DISP_E_TYPEMISMATCH;
+    }
+
+    if( ret == S_OK )
+    {
+        if( strncasecmp( pNewString, "True", strlen( pNewString ) ) == 0 )
+        {
+            *pboolOut = VARIANT_TRUE;
+        }
+        else if( strncasecmp( pNewString, "False", strlen( pNewString ) ) == 0 )
+        {
+            *pboolOut = VARIANT_FALSE;
+        }
+        else
+        {
+            /* Try converting the string to a floating point number.
+             */
+            double dValue = 0.0;
+            HRESULT res = VarR8FromStr( strIn, lcid, dwFlags, &dValue );
+            if( res != S_OK )
+            {
+                ret = DISP_E_TYPEMISMATCH;
+            }
+            else if( dValue == 0.0 )
+            {
+                *pboolOut = VARIANT_FALSE;
+            }
+            else
+            {
+                *pboolOut = VARIANT_TRUE;
+            }
+        }
+    }
+
+    HeapFree( GetProcessHeap(), 0, pNewString );
+
+    return ret;
+}
+
+/******************************************************************************
+ *      VarBoolFromI1       [OLEAUT32.233]
  */
 HRESULT WINAPI VarBoolFromI1(CHAR cIn, VARIANT_BOOL* pboolOut)
 {
-        TRACE("( %c, %p ), stub\n", cIn, pboolOut );
-
-        if( cIn == 0 )
-        {
-                *pboolOut = VARIANT_FALSE;
-        }
-        else
-        {
-                *pboolOut = VARIANT_TRUE;
-        }
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBoolFromUI2          [OLEAUT32.234]
+    TRACE("( %c, %p ), stub\n", cIn, pboolOut );
+
+    if( cIn == 0 )
+    {
+        *pboolOut = VARIANT_FALSE;
+    }
+    else
+    {
+        *pboolOut = VARIANT_TRUE;
+    }
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBoolFromUI2      [OLEAUT32.234]
  */
 HRESULT WINAPI VarBoolFromUI2(USHORT uiIn, VARIANT_BOOL* pboolOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, pboolOut );
-
-        if( uiIn == 0 )
-        {
-                *pboolOut = VARIANT_FALSE;
-        }
-        else
-        {
-                *pboolOut = VARIANT_TRUE;
-        }
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarBoolFromUI4          [OLEAUT32.235]
+    TRACE("( %d, %p ), stub\n", uiIn, pboolOut );
+
+    if( uiIn == 0 )
+    {
+        *pboolOut = VARIANT_FALSE;
+    }
+    else
+    {
+        *pboolOut = VARIANT_TRUE;
+    }
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarBoolFromUI4      [OLEAUT32.235]
  */
 HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL* pboolOut)
 {
-        TRACE("( %ld, %p ), stub\n", ulIn, pboolOut );
-
-        if( ulIn == 0 )
-        {
-                *pboolOut = VARIANT_FALSE;
-        }
-        else
-        {
-                *pboolOut = VARIANT_TRUE;
-        }
-
-        return S_OK;
+    TRACE("( %ld, %p ), stub\n", ulIn, pboolOut );
+
+    if( ulIn == 0 )
+    {
+        *pboolOut = VARIANT_FALSE;
+    }
+    else
+    {
+        *pboolOut = VARIANT_TRUE;
+    }
+
+    return S_OK;
 }
 
@@ -3597 +3598 @@
       if (cyIn.s.Hi || cyIn.s.Lo) *pboolOut = -1;
       else *pboolOut = 0;
-      
+
       return S_OK;
 }
 
 /******************************************************************************
- *              VarI1FromUI1            [OLEAUT32.244]
+ *      VarI1FromUI1        [OLEAUT32.244]
  */
 HRESULT WINAPI VarI1FromUI1(BYTE bIn, CHAR* pcOut)
 {
-        TRACE("( %d, %p ), stub\n", bIn, pcOut );
-
-        /* Check range of value.
-         */
-        if( bIn > CHAR_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pcOut = (CHAR) bIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI1FromI2             [OLEAUT32.245]
+    TRACE("( %d, %p ), stub\n", bIn, pcOut );
+
+    /* Check range of value.
+     */
+    if( bIn > CHAR_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pcOut = (CHAR) bIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI1FromI2     [OLEAUT32.245]
  */
 HRESULT WINAPI VarI1FromI2(short uiIn, CHAR* pcOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, pcOut );
-
-        if( uiIn > CHAR_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pcOut = (CHAR) uiIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI1FromI4             [OLEAUT32.246]
+    TRACE("( %d, %p ), stub\n", uiIn, pcOut );
+
+    if( uiIn > CHAR_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pcOut = (CHAR) uiIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI1FromI4     [OLEAUT32.246]
  */
 HRESULT WINAPI VarI1FromI4(LONG lIn, CHAR* pcOut)
 {
-        TRACE("( %ld, %p ), stub\n", lIn, pcOut );
-
-        if( lIn < CHAR_MIN || lIn > CHAR_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pcOut = (CHAR) lIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI1FromR4             [OLEAUT32.247]
+    TRACE("( %ld, %p ), stub\n", lIn, pcOut );
+
+    if( lIn < CHAR_MIN || lIn > CHAR_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pcOut = (CHAR) lIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI1FromR4     [OLEAUT32.247]
  */
 HRESULT WINAPI VarI1FromR4(FLOAT fltIn, CHAR* pcOut)
 {
-        TRACE("( %f, %p ), stub\n", fltIn, pcOut );
+    TRACE("( %f, %p ), stub\n", fltIn, pcOut );
 
     fltIn = round( fltIn );
-        if( fltIn < CHAR_MIN || fltIn > CHAR_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pcOut = (CHAR) fltIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI1FromR8             [OLEAUT32.248]
+    if( fltIn < CHAR_MIN || fltIn > CHAR_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pcOut = (CHAR) fltIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI1FromR8     [OLEAUT32.248]
  */
 HRESULT WINAPI VarI1FromR8(double dblIn, CHAR* pcOut)
 {
-        TRACE("( %f, %p ), stub\n", dblIn, pcOut );
+    TRACE("( %f, %p ), stub\n", dblIn, pcOut );
 
     dblIn = round( dblIn );
     if( dblIn < CHAR_MIN || dblIn > CHAR_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pcOut = (CHAR) dblIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI1FromDate           [OLEAUT32.249]
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pcOut = (CHAR) dblIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI1FromDate       [OLEAUT32.249]
  */
 HRESULT WINAPI VarI1FromDate(DATE dateIn, CHAR* pcOut)
 {
-        TRACE("( %f, %p ), stub\n", dateIn, pcOut );
+    TRACE("( %f, %p ), stub\n", dateIn, pcOut );
 
     dateIn = round( dateIn );
-        if( dateIn < CHAR_MIN || dateIn > CHAR_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pcOut = (CHAR) dateIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI1FromStr            [OLEAUT32.251]
+    if( dateIn < CHAR_MIN || dateIn > CHAR_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pcOut = (CHAR) dateIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI1FromStr        [OLEAUT32.251]
  */
 HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CHAR* pcOut)
 {
-        double dValue = 0.0;
-        LPSTR pNewString = NULL;
-
-        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pcOut );
-
-        /* Check if we have a valid argument
-         */
-        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
-        RemoveCharacterFromString( pNewString, "," );
-        if( IsValidRealString( pNewString ) == FALSE )
-        {
-                return DISP_E_TYPEMISMATCH;
-        }
-
-        /* Convert the valid string to a floating point number.
-         */
-        dValue = atof( pNewString );
-  
-        /* We don't need the string anymore so free it.
-         */
-        HeapFree( GetProcessHeap(), 0, pNewString );
-
-        /* Check range of value.
+    double dValue = 0.0;
+    LPSTR pNewString = NULL;
+
+    TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pcOut );
+
+    /* Check if we have a valid argument
+     */
+    pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
+    RemoveCharacterFromString( pNewString, "," );
+    if( IsValidRealString( pNewString ) == FALSE )
+    {
+        return DISP_E_TYPEMISMATCH;
+    }
+
+    /* Convert the valid string to a floating point number.
+     */
+    dValue = atof( pNewString );
+
+    /* We don't need the string anymore so free it.
+     */
+    HeapFree( GetProcessHeap(), 0, pNewString );
+
+    /* Check range of value.
      */
     dValue = round( dValue );
-        if( dValue < CHAR_MIN || dValue > CHAR_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pcOut = (CHAR) dValue;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI1FromBool           [OLEAUT32.253]
+    if( dValue < CHAR_MIN || dValue > CHAR_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pcOut = (CHAR) dValue;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI1FromBool       [OLEAUT32.253]
  */
 HRESULT WINAPI VarI1FromBool(VARIANT_BOOL boolIn, CHAR* pcOut)
 {
-        TRACE("( %d, %p ), stub\n", boolIn, pcOut );
-
-        *pcOut = (CHAR) boolIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI1FromUI2            [OLEAUT32.254]
+    TRACE("( %d, %p ), stub\n", boolIn, pcOut );
+
+    *pcOut = (CHAR) boolIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI1FromUI2        [OLEAUT32.254]
  */
 HRESULT WINAPI VarI1FromUI2(USHORT uiIn, CHAR* pcOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, pcOut );
-
-        if( uiIn > CHAR_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pcOut = (CHAR) uiIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarI1FromUI4            [OLEAUT32.255]
+    TRACE("( %d, %p ), stub\n", uiIn, pcOut );
+
+    if( uiIn > CHAR_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pcOut = (CHAR) uiIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarI1FromUI4        [OLEAUT32.255]
  */
 HRESULT WINAPI VarI1FromUI4(ULONG ulIn, CHAR* pcOut)
 {
-        TRACE("( %ld, %p ), stub\n", ulIn, pcOut );
-
-        if( ulIn > CHAR_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pcOut = (CHAR) ulIn;
-
-        return S_OK;
+    TRACE("( %ld, %p ), stub\n", ulIn, pcOut );
+
+    if( ulIn > CHAR_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pcOut = (CHAR) ulIn;
+
+    return S_OK;
 }
 
@@ -3800 +3801 @@
 HRESULT WINAPI VarI1FromCy(CY cyIn, CHAR* pcOut) {
    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
-   
+
    if (t > CHAR_MAX || t < CHAR_MIN) return DISP_E_OVERFLOW;
-   
+
    *pcOut = (CHAR)t;
    return S_OK;
@@ -3808 +3809 @@
 
 /******************************************************************************
- *              VarUI2FromUI1           [OLEAUT32.257]
+ *      VarUI2FromUI1       [OLEAUT32.257]
  */
 HRESULT WINAPI VarUI2FromUI1(BYTE bIn, USHORT* puiOut)
 {
-        TRACE("( %d, %p ), stub\n", bIn, puiOut );
-
-        *puiOut = (USHORT) bIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI2FromI2            [OLEAUT32.258]
+    TRACE("( %d, %p ), stub\n", bIn, puiOut );
+
+    *puiOut = (USHORT) bIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI2FromI2        [OLEAUT32.258]
  */
 HRESULT WINAPI VarUI2FromI2(short uiIn, USHORT* puiOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, puiOut );
-
-        if( uiIn < UI2_MIN )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *puiOut = (USHORT) uiIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI2FromI4            [OLEAUT32.259]
+    TRACE("( %d, %p ), stub\n", uiIn, puiOut );
+
+    if( uiIn < UI2_MIN )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *puiOut = (USHORT) uiIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI2FromI4        [OLEAUT32.259]
  */
 HRESULT WINAPI VarUI2FromI4(LONG lIn, USHORT* puiOut)
 {
-        TRACE("( %ld, %p ), stub\n", lIn, puiOut );
-
-        if( lIn < UI2_MIN || lIn > UI2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *puiOut = (USHORT) lIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI2FromR4            [OLEAUT32.260]
+    TRACE("( %ld, %p ), stub\n", lIn, puiOut );
+
+    if( lIn < UI2_MIN || lIn > UI2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *puiOut = (USHORT) lIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI2FromR4        [OLEAUT32.260]
  */
 HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* puiOut)
 {
-        TRACE("( %f, %p ), stub\n", fltIn, puiOut );
+    TRACE("( %f, %p ), stub\n", fltIn, puiOut );
 
     fltIn = round( fltIn );
-        if( fltIn < UI2_MIN || fltIn > UI2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *puiOut = (USHORT) fltIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI2FromR8            [OLEAUT32.261]
+    if( fltIn < UI2_MIN || fltIn > UI2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *puiOut = (USHORT) fltIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI2FromR8        [OLEAUT32.261]
  */
 HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* puiOut)
 {
-        TRACE("( %f, %p ), stub\n", dblIn, puiOut );
+    TRACE("( %f, %p ), stub\n", dblIn, puiOut );
 
     dblIn = round( dblIn );
     if( dblIn < UI2_MIN || dblIn > UI2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *puiOut = (USHORT) dblIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI2FromDate          [OLEAUT32.262]
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *puiOut = (USHORT) dblIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI2FromDate      [OLEAUT32.262]
  */
 HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* puiOut)
 {
-        TRACE("( %f, %p ), stub\n", dateIn, puiOut );
+    TRACE("( %f, %p ), stub\n", dateIn, puiOut );
 
     dateIn = round( dateIn );
-        if( dateIn < UI2_MIN || dateIn > UI2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *puiOut = (USHORT) dateIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI2FromStr           [OLEAUT32.264]
+    if( dateIn < UI2_MIN || dateIn > UI2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *puiOut = (USHORT) dateIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI2FromStr       [OLEAUT32.264]
  */
 HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* puiOut)
 {
-        double dValue = 0.0;
-        LPSTR pNewString = NULL;
-
-        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, puiOut );
-
-        /* Check if we have a valid argument
-         */
-        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
-        RemoveCharacterFromString( pNewString, "," );
-        if( IsValidRealString( pNewString ) == FALSE )
-        {
-                return DISP_E_TYPEMISMATCH;
-        }
-
-        /* Convert the valid string to a floating point number.
-         */
-        dValue = atof( pNewString );
-  
-        /* We don't need the string anymore so free it.
-         */
-        HeapFree( GetProcessHeap(), 0, pNewString );
-
-        /* Check range of value.
+    double dValue = 0.0;
+    LPSTR pNewString = NULL;
+
+    TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, puiOut );
+
+    /* Check if we have a valid argument
+     */
+    pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
+    RemoveCharacterFromString( pNewString, "," );
+    if( IsValidRealString( pNewString ) == FALSE )
+    {
+        return DISP_E_TYPEMISMATCH;
+    }
+
+    /* Convert the valid string to a floating point number.
+     */
+    dValue = atof( pNewString );
+
+    /* We don't need the string anymore so free it.
+     */
+    HeapFree( GetProcessHeap(), 0, pNewString );
+
+    /* Check range of value.
      */
     dValue = round( dValue );
-        if( dValue < UI2_MIN || dValue > UI2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *puiOut = (USHORT) dValue;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI2FromBool          [OLEAUT32.266]
+    if( dValue < UI2_MIN || dValue > UI2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *puiOut = (USHORT) dValue;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI2FromBool      [OLEAUT32.266]
  */
 HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT* puiOut)
 {
-        TRACE("( %d, %p ), stub\n", boolIn, puiOut );
-
-        *puiOut = (USHORT) boolIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI2FromI1            [OLEAUT32.267]
+    TRACE("( %d, %p ), stub\n", boolIn, puiOut );
+
+    *puiOut = (USHORT) boolIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI2FromI1        [OLEAUT32.267]
  */
 HRESULT WINAPI VarUI2FromI1(CHAR cIn, USHORT* puiOut)
 {
-        TRACE("( %c, %p ), stub\n", cIn, puiOut );
-
-        *puiOut = (USHORT) cIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI2FromUI4           [OLEAUT32.268]
+    TRACE("( %c, %p ), stub\n", cIn, puiOut );
+
+    *puiOut = (USHORT) cIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI2FromUI4       [OLEAUT32.268]
  */
 HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* puiOut)
 {
-        TRACE("( %ld, %p ), stub\n", ulIn, puiOut );
-
-        if( ulIn < UI2_MIN || ulIn > UI2_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *puiOut = (USHORT) ulIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI4FromStr           [OLEAUT32.277]
+    TRACE("( %ld, %p ), stub\n", ulIn, puiOut );
+
+    if( ulIn < UI2_MIN || ulIn > UI2_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *puiOut = (USHORT) ulIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI4FromStr       [OLEAUT32.277]
  */
 HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG* pulOut)
 {
-        double dValue = 0.0;
-        LPSTR pNewString = NULL;
-
-        TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pulOut );
-
-        /* Check if we have a valid argument
-         */
-        pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
-        RemoveCharacterFromString( pNewString, "," );
-        if( IsValidRealString( pNewString ) == FALSE )
-        {
-                return DISP_E_TYPEMISMATCH;
-        }
-
-        /* Convert the valid string to a floating point number.
-         */
-        dValue = atof( pNewString );
-  
-        /* We don't need the string anymore so free it.
-         */
-        HeapFree( GetProcessHeap(), 0, pNewString );
-
-        /* Check range of value.
+    double dValue = 0.0;
+    LPSTR pNewString = NULL;
+
+    TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pulOut );
+
+    /* Check if we have a valid argument
+     */
+    pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
+    RemoveCharacterFromString( pNewString, "," );
+    if( IsValidRealString( pNewString ) == FALSE )
+    {
+        return DISP_E_TYPEMISMATCH;
+    }
+
+    /* Convert the valid string to a floating point number.
+     */
+    dValue = atof( pNewString );
+
+    /* We don't need the string anymore so free it.
+     */
+    HeapFree( GetProcessHeap(), 0, pNewString );
+
+    /* Check range of value.
      */
     dValue = round( dValue );
-        if( dValue < UI4_MIN || dValue > UI4_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pulOut = (ULONG) dValue;
-
-        return S_OK;
+    if( dValue < UI4_MIN || dValue > UI4_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pulOut = (ULONG) dValue;
+
+    return S_OK;
 }
 
@@ -4034 +4035 @@
 HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut) {
    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
-   
+
    if (t > UI2_MAX || t < UI2_MIN) return DISP_E_OVERFLOW;
-      
+
    *pusOut = (USHORT)t;
-   
+
    return S_OK;
 }
 
 /******************************************************************************
- *              VarUI4FromUI1           [OLEAUT32.270]
+ *      VarUI4FromUI1       [OLEAUT32.270]
  */
 HRESULT WINAPI VarUI4FromUI1(BYTE bIn, ULONG* pulOut)
 {
-        TRACE("( %d, %p ), stub\n", bIn, pulOut );
-
-        *pulOut = (USHORT) bIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI4FromI2            [OLEAUT32.271]
+    TRACE("( %d, %p ), stub\n", bIn, pulOut );
+
+    *pulOut = (USHORT) bIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI4FromI2        [OLEAUT32.271]
  */
 HRESULT WINAPI VarUI4FromI2(short uiIn, ULONG* pulOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, pulOut );
-
-        if( uiIn < UI4_MIN )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pulOut = (ULONG) uiIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI4FromI4            [OLEAUT32.272]
+    TRACE("( %d, %p ), stub\n", uiIn, pulOut );
+
+    if( uiIn < UI4_MIN )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pulOut = (ULONG) uiIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI4FromI4        [OLEAUT32.272]
  */
 HRESULT WINAPI VarUI4FromI4(LONG lIn, ULONG* pulOut)
 {
-        TRACE("( %ld, %p ), stub\n", lIn, pulOut );
-
-        if( lIn < UI4_MIN )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pulOut = (ULONG) lIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI4FromR4            [OLEAUT32.273]
+    TRACE("( %ld, %p ), stub\n", lIn, pulOut );
+
+    if( lIn < UI4_MIN )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pulOut = (ULONG) lIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI4FromR4        [OLEAUT32.273]
  */
 HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG* pulOut)
@@ -4095 +4096 @@
     fltIn = round( fltIn );
     if( fltIn < UI4_MIN || fltIn > UI4_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pulOut = (ULONG) fltIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI4FromR8            [OLEAUT32.274]
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pulOut = (ULONG) fltIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI4FromR8        [OLEAUT32.274]
  */
 HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG* pulOut)
 {
-        TRACE("( %f, %p ), stub\n", dblIn, pulOut );
+    TRACE("( %f, %p ), stub\n", dblIn, pulOut );
 
     dblIn = round( dblIn );
-        if( dblIn < UI4_MIN || dblIn > UI4_MAX )
-        {
-                return DISP_E_OVERFLOW;
-    }
-
-        *pulOut = (ULONG) dblIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI4FromDate          [OLEAUT32.275]
+    if( dblIn < UI4_MIN || dblIn > UI4_MAX )
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pulOut = (ULONG) dblIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI4FromDate      [OLEAUT32.275]
  */
 HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG* pulOut)
 {
-        TRACE("( %f, %p ), stub\n", dateIn, pulOut );
+    TRACE("( %f, %p ), stub\n", dateIn, pulOut );
 
     dateIn = round( dateIn );
     if( dateIn < UI4_MIN || dateIn > UI4_MAX )
-        {
-                return DISP_E_OVERFLOW;
-        }
-
-        *pulOut = (ULONG) dateIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI4FromBool          [OLEAUT32.279]
+    {
+        return DISP_E_OVERFLOW;
+    }
+
+    *pulOut = (ULONG) dateIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI4FromBool      [OLEAUT32.279]
  */
 HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG* pulOut)
 {
-        TRACE("( %d, %p ), stub\n", boolIn, pulOut );
-
-        *pulOut = (ULONG) boolIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI4FromI1            [OLEAUT32.280]
+    TRACE("( %d, %p ), stub\n", boolIn, pulOut );
+
+    *pulOut = (ULONG) boolIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI4FromI1        [OLEAUT32.280]
  */
 HRESULT WINAPI VarUI4FromI1(CHAR cIn, ULONG* pulOut)
 {
-        TRACE("( %c, %p ), stub\n", cIn, pulOut );
-
-        *pulOut = (ULONG) cIn;
-
-        return S_OK;
-}
-
-/******************************************************************************
- *              VarUI4FromUI2           [OLEAUT32.281]
+    TRACE("( %c, %p ), stub\n", cIn, pulOut );
+
+    *pulOut = (ULONG) cIn;
+
+    return S_OK;
+}
+
+/******************************************************************************
+ *      VarUI4FromUI2       [OLEAUT32.281]
  */
 HRESULT WINAPI VarUI4FromUI2(USHORT uiIn, ULONG* pulOut)
 {
-        TRACE("( %d, %p ), stub\n", uiIn, pulOut );
-
-        *pulOut = (ULONG) uiIn;
-
-        return S_OK;
+    TRACE("( %d, %p ), stub\n", uiIn, pulOut );
+
+    *pulOut = (ULONG) uiIn;
+
+    return S_OK;
 }
 
@@ -4182 +4183 @@
 HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG* pulOut) {
    double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
-   
+
    if (t > UI4_MAX || t < UI4_MIN) return DISP_E_OVERFLOW;
 
@@ -4197 +4198 @@
    pcyOut->s.Hi = 0;
    pcyOut->s.Lo = ((ULONG)bIn) * 10000;
-   
+
    return S_OK;
 }
@@ -4209 +4210 @@
    else pcyOut->s.Hi = 0;
    pcyOut->s.Lo = ((ULONG)sIn) * 10000;
-   
+
    return S_OK;
 }
@@ -4222 +4223 @@
       pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
       if (lIn < 0) pcyOut->s.Hi--;
-   
+
       return S_OK;
 }
@@ -4235 +4236 @@
    pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
    if (fltIn < 0) pcyOut->s.Hi--;
-   
+
    return S_OK;
 }
@@ -4269 +4270 @@
  */
 HRESULT WINAPI VarCyFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pcyOut) {
-                                /* FIXME */
-                return E_NOTIMPL;
-}
-
- 
+                /* FIXME */
+        return E_NOTIMPL;
+}
+
+
 /**********************************************************************
  *              VarCyFromBool [OLEAUT32.106]
@@ -4282 +4283 @@
    else pcyOut->s.Hi = 0;
    pcyOut->s.Lo = (ULONG)boolIn * (ULONG)10000;
-   
+
    return S_OK;
 }
@@ -4294 +4295 @@
    else pcyOut->s.Hi = 0;
    pcyOut->s.Lo = (ULONG)cIn * (ULONG)10000;
-   
+
    return S_OK;
 }
@@ -4305 +4306 @@
    pcyOut->s.Hi = 0;
    pcyOut->s.Lo = (ULONG)usIn * (ULONG)10000;
-   
+
    return S_OK;
 }
@@ -4317 +4318 @@
    pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
    pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
-      
+
    return S_OK;
 }
@@ -4333 +4334 @@
 
     TRACE("( 0x%x, 0x%x, 0x%p ), stub\n", wDosDate, wDosTime, pvtime );
-    
+
     t.tm_sec = (wDosTime & 0x001f) * 2;
     t.tm_min = (wDosTime & 0x07e0) >> 5;
     t.tm_hour = (wDosTime & 0xf800) >> 11;
-    
+
     t.tm_mday = (wDosDate & 0x001f);
     t.tm_mon = (wDosDate & 0x01e0) >> 5;
@@ -4363 +4364 @@
     cDig = 0;
     for (i=0; strIn[i] ;i++) {
-        if ((strIn[i]>='0') && (strIn[i]<='9')) {
-            if (pnumprs->cDig > cDig) {
-                *(rgbDig++)=strIn[i]-'0';
-                cDig++;
-                lastent = i;
-            }
-        }
-    }
-    pnumprs->cDig       = cDig;
+    if ((strIn[i]>='0') && (strIn[i]<='9')) {
+        if (pnumprs->cDig > cDig) {
+        *(rgbDig++)=strIn[i]-'0';
+        cDig++;
+        lastent = i;
+        }
+    }
+    }
+    pnumprs->cDig   = cDig;
 
     /* FIXME: Just patching some values in */
-    pnumprs->nPwr10     = 0;
-    pnumprs->nBaseShift = 0;
-    pnumprs->cchUsed    = lastent;
-    pnumprs->dwOutFlags = NUMPRS_DECIMAL;
+    pnumprs->nPwr10 = 0;
+    pnumprs->nBaseShift = 0;
+    pnumprs->cchUsed    = lastent;
+    pnumprs->dwOutFlags = NUMPRS_DECIMAL;
     return S_OK;
 }
@@ -4394 +4395 @@
     xint = 0;
     for (i=0;i<pnumprs->cDig;i++)
-        xint = xint*10 + rgbDig[i];
+    xint = xint*10 + rgbDig[i];
 
     VariantInit(pvar);
     if (dwVtBits & VTBIT_I4) {
-        V_VT(pvar) = VT_I4;
-        V_UNION(pvar,intVal) = xint;
-        return S_OK;
+    V_VT(pvar) = VT_I4;
+    V_UNION(pvar,intVal) = xint;
+    return S_OK;
     }
     if (dwVtBits & VTBIT_R8) {
-        V_VT(pvar) = VT_R8;
-        V_UNION(pvar,dblVal) = xint;
-        return S_OK;
+    V_VT(pvar) = VT_R8;
+    V_UNION(pvar,dblVal) = xint;
+    return S_OK;
     } else {
-        FIXME("vtbitmask is unsupported %lx\n",dwVtBits);
-        return E_FAIL;
+    FIXME("vtbitmask is unsupported %lx\n",dwVtBits);
+    return E_FAIL;
     }
 }
@@ -4659 +4660 @@
  *              VarBstrCmp [OLEAUT32.440]
  *
- * flags can be: 
+ * flags can be:
  *   NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
  *   NORM_IGNORESTRINGWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA