Changeset 6711 for trunk/src/oleaut32

Timestamp:

Sep 15, 2001, 11:32:00 AM (24 years ago)

Author:

sandervl

Message:

restored old version + wine update

Location:

trunk/src/oleaut32

Files:

• connpt.c (modified) (29 diffs)
• dispatch.c (modified) (3 diffs)
• initterm.cpp (modified) (4 diffs)
• ole2disp.c (modified) (18 diffs)
• oleaut.c (modified) (7 diffs)
• olefont.c (modified) (57 diffs)
• olepicture.c (modified) (50 diffs)
• parsedt.c (modified) (18 diffs)
• safearray.c (modified) (67 diffs)
• typelib.c (modified) (11 diffs)
• typelib.h (modified) (2 diffs)
• variant.c (modified) (67 diffs)

trunk/src/oleaut32/connpt.c

@@ -72 +72 @@
   CONNECTDATA *pCD;
   DWORD nConns;
-
+  
   /* Next connection to enumerate from */
   DWORD nCur;
@@ -79 +79 @@
 
 static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
-                              DWORD nSinks,
-                              CONNECTDATA *pCD);
+                                                          DWORD nSinks,
+                                                          CONNECTDATA *pCD);
 
 
@@ -87 +87 @@
  */
 static ConnectionPointImpl *ConnectionPointImpl_Construct(IUnknown *pUnk,
-                              REFIID riid)
+                                                          REFIID riid)
 {
   ConnectionPointImpl *Obj;
@@ -97 +97 @@
   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 +139 @@
   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 +165 @@
     return E_NOINTERFACE;
   }
-
+  
   /*
    * Query Interface always increases the reference count by one when it is
@@ -189 +189 @@
   return This->ref;
 }
-
+        
 /************************************************************************
  * ConnectionPointImpl_Release (IUnknown)
@@ -195 +195 @@
  * See Windows documentation for more details on IUnknown methods.
  */
-static ULONG WINAPI ConnectionPointImpl_Release(
+static ULONG WINAPI ConnectionPointImpl_Release( 
       IConnectionPoint* iface)
 {
@@ -215 +215 @@
     return 0;
   }
-
+  
   return This->ref;
 }
@@ -224 +224 @@
  */
 static HRESULT WINAPI ConnectionPointImpl_GetConnectionInterface(
-                           IConnectionPoint *iface,
-                           IID              *piid)
+                                               IConnectionPoint *iface,
+                                               IID              *piid)
 {
   ICOM_THIS(ConnectionPointImpl, iface);
@@ -238 +238 @@
  */
 static HRESULT WINAPI ConnectionPointImpl_GetConnectionPointContainer(
-                      IConnectionPoint           *iface,
-                      IConnectionPointContainer  **ppCPC)
+                                      IConnectionPoint           *iface,
+                                      IConnectionPointContainer  **ppCPC)
 {
   ICOM_THIS(ConnectionPointImpl, iface);
@@ -245 +245 @@
 
   return IUnknown_QueryInterface(This->Obj,
-                 &IID_IConnectionPointContainer,
-                 (LPVOID)ppCPC);
+                                 &IID_IConnectionPointContainer,
+                                 (LPVOID)ppCPC);
 }
 
@@ -254 +254 @@
  */
 static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface,
-                         IUnknown *lpUnk,
-                         DWORD *pdwCookie)
+                                                 IUnknown *lpUnk,
+                                                 DWORD *pdwCookie)
 {
   DWORD i;
@@ -273 +273 @@
     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 +287 @@
  */
 static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface,
-                           DWORD dwCookie)
+                                                   DWORD dwCookie)
 {
   ICOM_THIS(ConnectionPointImpl, iface);
@@ -307 +307 @@
  */
 static HRESULT WINAPI ConnectionPointImpl_EnumConnections(
-                            IConnectionPoint *iface,
-                            LPENUMCONNECTIONS *ppEnum)
-{
+                                                    IConnectionPoint *iface,
+                                                    LPENUMCONNECTIONS *ppEnum)
+{ 
   ICOM_THIS(ConnectionPointImpl, iface);
   CONNECTDATA *pCD;
@@ -317 +317 @@
 
   TRACE("(%p)->(%p)\n", This, ppEnum);
-
+  
   *ppEnum = NULL;
 
@@ -339 +339 @@
   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 +367 @@
  */
 static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
-                              DWORD nSinks,
-                              CONNECTDATA *pCD)
+                                                          DWORD nSinks,
+                                                          CONNECTDATA *pCD)
 {
   EnumConnectionsImpl *Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
@@ -420 +420 @@
   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 +446 @@
     return E_NOINTERFACE;
   }
-
+  
   /*
    * Query Interface always increases the reference count by one when it is
@@ -470 +470 @@
   return This->ref;
 }
-
+        
 /************************************************************************
  * EnumConnectionsImpl_Release (IUnknown)
@@ -497 +497 @@
     return 0;
   }
-
+  
   return This->ref;
 }
@@ -506 +506 @@
  */
 static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface,
-                           ULONG cConn, LPCONNECTDATA pCD,
-                           ULONG *pEnum)
+                                               ULONG cConn, LPCONNECTDATA pCD,
+                                               ULONG *pEnum)
 {
   ICOM_THIS(EnumConnectionsImpl, iface);
@@ -542 +542 @@
  */
 static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface,
-                           ULONG cSkip)
+                                               ULONG cSkip)
 {
   ICOM_THIS(EnumConnectionsImpl, iface);
@@ -576 +576 @@
  */
 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 +588 @@
   return S_OK;
 }
-
+  
 static ICOM_VTABLE(IEnumConnections) EnumConnectionsImpl_VTable =
 {
@@ -616 +616 @@
  */
 HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid,
-                  IConnectionPoint **pCP)
+                              IConnectionPoint **pCP)
 {
   ConnectionPointImpl *Obj;
@@ -624 +624 @@
   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

@@ -37 +37 @@
  *
  * 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 +76 @@
  *         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 +109 @@
  *
  * 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

@@ -59 +59 @@
    {
    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 +95 @@
       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 +105 @@
          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 +122 @@
       case 1 :
          if(dllHandle) {
-        UnregisterLxDll(dllHandle);
+                UnregisterLxDll(dllHandle);
          }
          break;

trunk/src/oleaut32/ole2disp.c

@@ -1 +1 @@
 /*
- *  OLE2DISP library
+ *      OLE2DISP library
  *
- *  Copyright 1995  Martin von Loewis
+ *      Copyright 1995  Martin von Loewis
  */
 #ifdef __WIN32OS2__
@@ -31 +31 @@
 
 /******************************************************************************
- *      BSTR_AllocBytes [Internal]
+ *              BSTR_AllocBytes [Internal]
  */
 static BSTR16 BSTR_AllocBytes(int n)
@@ -56 +56 @@
 
 /******************************************************************************
- *      SysAllocString16    [OLE2DISP.2]
+ *              SysAllocString16        [OLE2DISP.2]
  */
 BSTR16 WINAPI SysAllocString16(LPCOLESTR16 in)
 {
-    BSTR16 out;
-
+        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;
-
-    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 +84 @@
 #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 +103 @@
      * Sanity check
      */
-    if (old==NULL)
+    if (old==NULL) 
       return 0;
 
@@ -109 +109 @@
      * Make sure we free the old string.
      */
-    if (*old!=NULL)
+    if (*old!=NULL)      
       SysFreeString(*old);
 
@@ -122 +122 @@
 #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 +137 @@
      */
     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 +152 @@
  * 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 +214 @@
 #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;
+        BSTR16 new=SysAllocStringLen16(in,len);
+        BSTR_Free(*old);
+        *old=new;
+        return 1;
+}
+#endif
+
+ 
+/******************************************************************************
+ *             SysReAllocStringLen   [OLEAUT32.5]
+ */
+int WINAPI SysReAllocStringLen(BSTR* old, const OLECHAR* in, unsigned int len)
+{
+    /*
+     * Sanity check
+     */
+    if (old==NULL) 
+      return 0;
+
+    /*
+     * Make sure we free the old string.
+     */
+    if (*old!=NULL)      
+      SysFreeString(*old);
+
+    /*
+     * Allocate the new string
+     */
+    *old = SysAllocStringLen(in, len);
+
     return 1;
 }
-#endif
-
-
-/******************************************************************************
- *             SysReAllocStringLen   [OLEAUT32.5]
- */
-int WINAPI SysReAllocStringLen(BSTR* old, const OLECHAR* in, unsigned int len)
-{
-    /*
-     * Sanity check
-     */
-    if (old==NULL)
-      return 0;
-
-    /*
-     * Make sure we free the old string.
-     */
-    if (*old!=NULL)
-      SysFreeString(*old);
-
-    /*
-     * Allocate the new string
-     */
-    *old = SysAllocStringLen(in, len);
-
-    return 1;
-}
-
-#ifndef __WIN32OS2__
-/******************************************************************************
- *      SysFreeString16 [OLE2DISP.6]
+
+#ifndef __WIN32OS2__
+/******************************************************************************
+ *              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 +288 @@
 #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 +310 @@
      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 +334 @@
      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 +349 @@
  */
 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 +362 @@
  */
 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 +377 @@
         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 +392 @@
         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 +405 @@
  */
 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 +1 @@
 /*
- *  OLEAUT32
+ *      OLEAUT32
  *
  */
@@ -17 +17 @@
 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 +61 @@
 #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 +101 @@
  *
  * 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 +120 @@
     {
     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 +141 @@
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      DllRegisterServer
+ *              DllRegisterServer
  */
-HRESULT WINAPI OLEAUT32_DllRegisterServer() {
+HRESULT WINAPI OLEAUT32_DllRegisterServer() { 
     FIXME("stub!\n");
     return S_OK;
@@ -149 +149 @@
 
 /***********************************************************************
- *      DllUnregisterServer
+ *              DllUnregisterServer
  */
 HRESULT WINAPI OLEAUT32_DllUnregisterServer() {

trunk/src/oleaut32/olefont.c

@@ -46 +46 @@
 {
   /*
-   * 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 +85 @@
 
 /*
- * 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 +91 @@
  */
 #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 +134 @@
  * 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 +165 @@
  * 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 +186 @@
  */
 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 +227 @@
   OLEFontImpl_put_Charset,
   OLEFontImpl_get_hFont,
-  OLEFontImpl_Clone,
+  OLEFontImpl_Clone, 
   OLEFontImpl_IsEqual,
   OLEFontImpl_SetRatio,
@@ -273 +273 @@
 
 /******************************************************************************
- *      OleCreateFontIndirect   [OLEAUT32.420]
+ *              OleCreateFontIndirect   [OLEAUT32.420]
  */
 HRESULT WINAPI OleCreateFontIndirect(
@@ -331 +331 @@
 
   IConnectionPoint_EnumConnections(this->pCP, &pEnum);
-
+  
   while(IEnumConnections_Next(pEnum, 1, &CD, NULL) == S_OK) {
     IPropertyNotifySink *sink;
@@ -343 +343 @@
   return;
 }
-
+  
 /************************************************************************
  * OLEFontImpl_Construct
@@ -364 +364 @@
   if (newObject==0)
     return newObject;
-
+  
   /*
    * Initialize the virtual function table.
@@ -372 +372 @@
   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 +386 @@
   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 +448 @@
   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 +491 @@
     return E_NOINTERFACE;
   }
-
+  
   /*
    * Query Interface always increases the reference count by one when it is
@@ -500 +500 @@
   return S_OK;;
 }
-
+        
 /************************************************************************
  * OLEFontImpl_AddRef (IUnknown)
@@ -506 +506 @@
  * See Windows documentation for more details on IUnknown methods.
  */
-ULONG WINAPI OLEFontImpl_AddRef(
+ULONG WINAPI OLEFontImpl_AddRef( 
   IFont* iface)
 {
@@ -515 +515 @@
   return this->ref;
 }
-
+        
 /************************************************************************
  * OLEFontImpl_Release (IUnknown)
@@ -521 +521 @@
  * See Windows documentation for more details on IUnknown methods.
  */
-ULONG WINAPI OLEFontImpl_Release(
+ULONG WINAPI OLEFontImpl_Release( 
       IFont* iface)
 {
@@ -541 +541 @@
     return 0;
   }
-
+  
   return this->ref;
 }
-
+        
 /************************************************************************
  * OLEFontImpl_get_Name (IFont)
@@ -551 +551 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Name(
-  IFont*  iface,
+  IFont*  iface, 
   BSTR* pname)
 {
@@ -576 +576 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Name(
-  IFont* iface,
+  IFont* iface, 
   BSTR name)
 {
@@ -585 +585 @@
   {
     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 +611 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Size(
-  IFont* iface,
+  IFont* iface, 
   CY*    psize)
 {
@@ -635 +635 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Size(
-  IFont* iface,
+  IFont* iface, 
   CY     size)
 {
@@ -653 +653 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Bold(
-  IFont*  iface,
+  IFont*  iface, 
   BOOL* pbold)
 {
@@ -692 +692 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Italic(
-  IFont*  iface,
+  IFont*  iface, 
   BOOL* pitalic)
 {
@@ -714 +714 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Italic(
-  IFont* iface,
+  IFont* iface, 
   BOOL italic)
 {
@@ -732 +732 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Underline(
-  IFont*  iface,
+  IFont*  iface, 
   BOOL* punderline)
 {
@@ -773 +773 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Strikethrough(
-  IFont*  iface,
+  IFont*  iface, 
   BOOL* pstrikethrough)
 {
@@ -796 +796 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Strikethrough(
- IFont* iface,
+ IFont* iface, 
  BOOL strikethrough)
 {
@@ -814 +814 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Weight(
-  IFont* iface,
+  IFont* iface, 
   short* pweight)
 {
@@ -837 +837 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Weight(
-  IFont* iface,
+  IFont* iface, 
   short  weight)
 {
@@ -855 +855 @@
  */
 static HRESULT WINAPI OLEFontImpl_get_Charset(
-  IFont* iface,
+  IFont* iface, 
   short* pcharset)
 {
@@ -878 +878 @@
  */
 static HRESULT WINAPI OLEFontImpl_put_Charset(
-  IFont* iface,
+  IFont* iface, 
   short charset)
 {
@@ -912 +912 @@
     INT      fontHeight;
     CY       cySize;
-
+    
     /*
      * The height of the font returned by the get_Size property is the
@@ -982 +982 @@
    */
   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 +994 @@
 
   logFont.lfHeight          = ((fontHeight%10000L)>5000L) ? (-fontHeight/10000L)-1 :
-                                (-fontHeight/10000L);
+                                                            (-fontHeight/10000L);
   logFont.lfItalic          = this->description.fItalic;
   logFont.lfUnderline       = this->description.fUnderline;
@@ -1023 +1023 @@
  */
 static HRESULT WINAPI OLEFontImpl_IsEqual(
-  IFont* iface,
+  IFont* iface, 
   IFont* pFontOther)
 {
@@ -1055 +1055 @@
  */
 static HRESULT      WINAPI OLEFontImpl_QueryTextMetrics(
-  IFont*         iface,
+  IFont*         iface, 
   TEXTMETRICOLE* ptm)
 {
@@ -1068 +1068 @@
  */
 static HRESULT WINAPI OLEFontImpl_AddRefHfont(
-  IFont*  iface,
+  IFont*  iface, 
   HFONT hfont)
 {
@@ -1107 +1107 @@
   {
     DeleteObject(this->gdiFont);
-    this->gdiFont = 0;
+    this->gdiFont = 0; 
   }
 
@@ -1174 +1174 @@
  */
 static HRESULT WINAPI OLEFontImpl_GetTypeInfoCount(
-  IDispatch*    iface,
+  IDispatch*    iface, 
   unsigned int* pctinfo)
 {
@@ -1189 +1189 @@
  */
 static HRESULT WINAPI OLEFontImpl_GetTypeInfo(
-  IDispatch*  iface,
+  IDispatch*  iface, 
   UINT      iTInfo,
-  LCID        lcid,
+  LCID        lcid, 
   ITypeInfo** ppTInfo)
 {
@@ -1207 +1207 @@
 static HRESULT WINAPI OLEFontImpl_GetIDsOfNames(
   IDispatch*  iface,
-  REFIID      riid,
-  LPOLESTR* rgszNames,
-  UINT      cNames,
+  REFIID      riid, 
+  LPOLESTR* rgszNames, 
+  UINT      cNames, 
   LCID        lcid,
   DISPID*     rgDispId)
@@ -1226 +1226 @@
 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 +1289 @@
  */
 static HRESULT WINAPI OLEFontImpl_GetClassID(
-  IPersistStream* iface,
+  IPersistStream* iface, 
   CLSID*                pClassID)
 {
@@ -1343 +1343 @@
 
   _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
-
+  
   /*
    * Read the version byte
@@ -1372 +1372 @@
   this->description.fStrikethrough = (bAttributes & FONTPERSIST_STRIKETHROUGH) != 0;
   this->description.fUnderline     = (bAttributes & FONTPERSIST_UNDERLINE) != 0;
-
+    
   /*
    * Weight
@@ -1408 +1408 @@
     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 +1430 @@
   BYTE  bAttributes;
   BYTE  bStringSize;
-
+  
   _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
 
@@ -1459 +1459 @@
   if (this->description.fStrikethrough)
     bAttributes |= FONTPERSIST_STRIKETHROUGH;
-
+  
   if (this->description.fUnderline)
     bAttributes |= FONTPERSIST_UNDERLINE;
@@ -1467 +1467 @@
   if (cbWritten!=1)
     return E_FAIL;
-
+  
   /*
    * Weight
@@ -1499 +1499 @@
   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 +1507 @@
 
     IStream_Write(pOutStream, writeBuffer, bStringSize, &cbWritten);
-
+    
     HeapFree(GetProcessHeap(), 0, writeBuffer);
 
@@ -1620 +1620 @@
   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 +1637 @@
 } 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

@@ -50 +50 @@
 #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 +90 @@
   /* We own the object and must destroy it ourselves */
     BOOL fOwn;
-
+  
   /* Picture description */
     PICTDESC desc;
@@ -105 +105 @@
 
     BOOL keepOrigFormat;
-    HDC hDCCur;
+    HDC hDCCur;
 } OLEPictureImpl;
 
@@ -174 +174 @@
   if (newObject==0)
     return newObject;
-
+  
   /*
    * Initialize the virtual function table.
@@ -186 +186 @@
 
   /*
-   * 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 +199 @@
   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 +206 @@
       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 +237 @@
  * this object.  */
 static void OLEPictureImpl_Destroy(OLEPictureImpl* Obj)
-{
+{ 
   TRACE("(%p)\n", Obj);
 
@@ -282 +282 @@
   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 +323 @@
     return E_NOINTERFACE;
   }
-
+  
   /*
    * Query Interface always increases the reference count by one when it is
@@ -362 +362 @@
  * See Windows documentation for more details on IUnknown methods.
  */
-static ULONG WINAPI OLEPictureImpl_AddRef(
+static ULONG WINAPI OLEPictureImpl_AddRef( 
   IPicture* iface)
 {
@@ -371 +371 @@
   return This->ref;
 }
-
+        
 /************************************************************************
  * OLEPictureImpl_Release (IUnknown)
@@ -377 +377 @@
  * See Windows documentation for more details on IUnknown methods.
  */
-static ULONG WINAPI OLEPictureImpl_Release(
+static ULONG WINAPI OLEPictureImpl_Release( 
       IPicture* iface)
 {
@@ -397 +397 @@
     return 0;
   }
-
+  
   return This->ref;
 }
@@ -404 +404 @@
 /************************************************************************
  * OLEPictureImpl_get_Handle
- */
+ */ 
 static HRESULT WINAPI OLEPictureImpl_get_Handle(IPicture *iface,
-                        OLE_HANDLE *phandle)
+                                                OLE_HANDLE *phandle)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -433 +433 @@
 /************************************************************************
  * OLEPictureImpl_get_hPal
- */
+ */ 
 static HRESULT WINAPI OLEPictureImpl_get_hPal(IPicture *iface,
-                          OLE_HANDLE *phandle)
+                                              OLE_HANDLE *phandle)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -444 +444 @@
 /************************************************************************
  * OLEPictureImpl_get_Type
- */
+ */ 
 static HRESULT WINAPI OLEPictureImpl_get_Type(IPicture *iface,
-                          short *ptype)
+                                              short *ptype)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -456 +456 @@
 /************************************************************************
  * OLEPictureImpl_get_Width
- */
+ */ 
 static HRESULT WINAPI OLEPictureImpl_get_Width(IPicture *iface,
-                           OLE_XSIZE_HIMETRIC *pwidth)
+                                               OLE_XSIZE_HIMETRIC *pwidth)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -468 +468 @@
 /************************************************************************
  * OLEPictureImpl_get_Height
- */
+ */ 
 static HRESULT WINAPI OLEPictureImpl_get_Height(IPicture *iface,
-                        OLE_YSIZE_HIMETRIC *pheight)
+                                                OLE_YSIZE_HIMETRIC *pheight)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -480 +480 @@
 /************************************************************************
  * 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 +542 @@
 /************************************************************************
  * OLEPictureImpl_set_hPal
- */
+ */ 
 static HRESULT WINAPI OLEPictureImpl_set_hPal(IPicture *iface,
-                          OLE_HANDLE hpal)
+                                              OLE_HANDLE hpal)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -554 +554 @@
 /************************************************************************
  * OLEPictureImpl_get_CurDC
- */
+ */ 
 static HRESULT WINAPI OLEPictureImpl_get_CurDC(IPicture *iface,
-                           HDC *phdc)
+                                               HDC *phdc)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -566 +566 @@
 /************************************************************************
  * 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 +578 @@
 
       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 +591 @@
 /************************************************************************
  * OLEPictureImpl_get_KeepOriginalFormat
- */
+ */ 
 static HRESULT WINAPI OLEPictureImpl_get_KeepOriginalFormat(IPicture *iface,
-                                BOOL *pfKeep)
+                                                            BOOL *pfKeep)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -605 +605 @@
 /************************************************************************
  * OLEPictureImpl_put_KeepOriginalFormat
- */
+ */ 
 static HRESULT WINAPI OLEPictureImpl_put_KeepOriginalFormat(IPicture *iface,
-                                BOOL keep)
+                                                            BOOL keep)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -618 +618 @@
 /************************************************************************
  * OLEPictureImpl_PictureChanged
- */
+ */ 
 static HRESULT WINAPI OLEPictureImpl_PictureChanged(IPicture *iface)
 {
@@ -629 +629 @@
 /************************************************************************
  * 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 +642 @@
 /************************************************************************
  * OLEPictureImpl_get_Attributes
- */
+ */ 
 static HRESULT WINAPI OLEPictureImpl_get_Attributes(IPicture *iface,
-                            DWORD *pdwAttr)
+                                                    DWORD *pdwAttr)
 {
   ICOM_THIS(OLEPictureImpl, iface);
@@ -650 +650 @@
   *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 +706 @@
   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 +805 @@
  * 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 +828 @@
   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 +841 @@
   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 +868 @@
     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 +877 @@
       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 +902 @@
     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 +921 @@
   }
   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 +930 @@
     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 +945 @@
   case 0x0000: { /* ICON , first word is dwReserved */
     HICON hicon;
-    CURSORICONFILEDIR   *cifd = (CURSORICONFILEDIR*)xbuf;
-    int i;
+    CURSORICONFILEDIR   *cifd = (CURSORICONFILEDIR*)xbuf;
+    int i;
 
     /*
@@ -954 +954 @@
 
     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 +969 @@
      */
     if (cifd->idCount!=1) {
-    for (i=0;i<cifd->idCount;i++) {
-        if (cifd->idEntries[i].bWidth == 32)
-        break;
+        for (i=0;i<cifd->idCount;i++) {
+            if (cifd->idEntries[i].bWidth == 32)
+                break;
+        }
+        if (i==cifd->idCount) i=0;
     }
-    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 +1074 @@
  */
 static HRESULT WINAPI OLEPictureImpl_GetTypeInfoCount(
-  IDispatch*    iface,
+  IDispatch*    iface, 
   unsigned int* pctinfo)
 {
@@ -1088 +1088 @@
  */
 static HRESULT WINAPI OLEPictureImpl_GetTypeInfo(
-  IDispatch*  iface,
+  IDispatch*  iface, 
   UINT      iTInfo,
-  LCID        lcid,
+  LCID        lcid, 
   ITypeInfo** ppTInfo)
 {
@@ -1105 +1105 @@
 static HRESULT WINAPI OLEPictureImpl_GetIDsOfNames(
   IDispatch*  iface,
-  REFIID      riid,
-  LPOLESTR* rgszNames,
-  UINT      cNames,
+  REFIID      riid, 
+  LPOLESTR* rgszNames, 
+  UINT      cNames, 
   LCID        lcid,
   DISPID*     rgDispId)
@@ -1123 +1123 @@
 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 +1202 @@
  */
 HRESULT WINAPI OleCreatePictureIndirect(LPPICTDESC lpPictDesc, REFIID riid,
-                    BOOL fOwn, LPVOID *ppvObj )
+                            BOOL fOwn, LPVOID *ppvObj )
 {
   OLEPictureImpl* newPict = NULL;
@@ -1244 +1244 @@
  */
 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 +1276 @@
  */
 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 +1308 @@
 // ----------------------------------------------------------------------
 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

@@ -26 +26 @@
  *
  * 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 +45 @@
 
 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 +66 @@
 "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 +91 @@
 
 /*****************************************************************************
- *   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 +108 @@
  */
 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 +275 @@
  * 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 +290 @@
 
 /* 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 +304 @@
 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 +353 @@
 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 +485 @@
  * 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 +740 @@
 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 +853 @@
 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 +955 @@
  * 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 +1013 @@
 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 +1136 @@
 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 +1217 @@
 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 +1255 @@
  * 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 +1309 @@
 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

@@ -25 +25 @@
 
 /* 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 +59 @@
 {
   /* 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 +109 @@
 
 /*************************************************************************
- *      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 +124 @@
 
   /* Allocate memory for SAFEARRAY struc */
-  if(( (*ppsaOut)=HeapAlloc(
+  if(( (*ppsaOut)=HeapAlloc( 
         GetProcessHeap(), HEAP_ZERO_MEMORY, allocSize)) == NULL){
     return(E_UNEXPECTED);
@@ -134 +134 @@
 
 /*************************************************************************
- *      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 +144 @@
   dprintf(("SafeArrayAllocData %x", psa));
 
-  if(! validArg(psa))
+  if(! validArg(psa)) 
     return E_INVALIDARG;
 
@@ -150 +150 @@
 
   /* 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 +161 @@
 
 /*************************************************************************
- *      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 +184 @@
     return NULL;
 
-  /* setup data members... */
+  /* setup data members... */ 
   psa->cDims     = cDims;
   psa->fFeatures = getFeatures(vt);
@@ -197 +197 @@
   }
 
-  /* 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 +217 @@
 
   /* 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 +229 @@
 
 /*************************************************************************
- *      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 +241 @@
   dprintf(("SafeArrayLock %x", psa));
 
-  if(! validArg(psa))
+  if(! validArg(psa))     
     return E_INVALIDARG;
 
@@ -250 +250 @@
 
 /*************************************************************************
- *      SafeArrayUnlock
+ *              SafeArrayUnlock
  * Decrement the lock counter
  */
@@ -258 +258 @@
   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 +269 @@
 
 /*************************************************************************
- *      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 +285 @@
 
   /* Validate the index given */
-  if(! validCoordinate(rgIndices, psa))
+  if(! validCoordinate(rgIndices, psa)) 
     return DISP_E_BADINDEX;
   if(! validArg(psa))
@@ -294 +294 @@
     /* 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 +323 @@
 
   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 +343 @@
   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 +353 @@
     /* 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 +375 @@
   }
 
-  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 +390 @@
   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 +403 @@
 
 /*************************************************************************
- *      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 +422 @@
 
 /*************************************************************************
- *      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 +439 @@
 
 /*************************************************************************
- *      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 +456 @@
 
 /*************************************************************************
- *      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 +471 @@
 
   switch (hRes) {
-    case S_OK:
+    case S_OK: 
       (*ppvData) = psa->pvData;
       break;
@@ -478 +478 @@
       return E_INVALIDARG;
   }
-
+  
   return S_OK;
 }
@@ -484 +484 @@
 
 /*************************************************************************
- *      SafeArrayUnaccessData
+ *              SafeArrayUnaccessData
  * Decrement the access count
  */
 HRESULT WINAPI SafeArrayUnaccessData(
   SAFEARRAY * psa)
-{
-  if(! validArg(psa))
+{ 
+  if(! validArg(psa)) 
     return E_INVALIDARG;
 
@@ -496 +496 @@
 }
 
-/************************************************************************
- *      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 +522 @@
 }
 
-/************************************************************************
- *      SafeArrayDestroyData
+/************************************************************************ 
+ *              SafeArrayDestroyData
  * Frees the memory data bloc
  */
 HRESULT WINAPI SafeArrayDestroyData(
   SAFEARRAY *psa)
-{
+{ 
   HRESULT  hRes;
   ULONG    ulWholeArraySize; /* count spot in array  */
@@ -535 +535 @@
   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 +546 @@
 
     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 +557 @@
       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 +573 @@
     psa->pvData = NULL;
   }
-
+  
   return S_OK;
 }
 
-/************************************************************************
- *      SafeArrayCopyData
+/************************************************************************ 
+ *              SafeArrayCopyData
  * Copy the psaSource's data block into psaTarget if dimension and size
  * permits it.
@@ -585 +585 @@
   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 +598 @@
     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 +612 @@
         ((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 +630 @@
 }
 
-/************************************************************************
- *      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 +652 @@
 }
 
-/************************************************************************
- *      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 +670 @@
 
     /* Duplicate the SAFEARRAY struc */
-    memcpy(*ppsaOut, psa,
+    memcpy(*ppsaOut, psa, 
             sizeof(*psa)+(sizeof(*(psa->rgsabound))*(psa->cDims-1)));
 
@@ -677 +677 @@
     /* 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 +693 @@
         return hRes;
       }
-
+        
     } else { /* failed to allocate or dupplicate... */
       SafeArrayDestroyDescriptor(*ppsaOut);
@@ -705 +705 @@
 }
 
-/************************************************************************
- *      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 +723 @@
 
   /* 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 +739 @@
   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 +774 @@
 
   } 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 +789 @@
  ************************************************************************/
 
-/************************************************************************
+/************************************************************************ 
  * Used to validate the SAFEARRAY type of arg
  */
 static BOOL validArg(
-  SAFEARRAY *psa)
+  SAFEARRAY *psa) 
 {
   SAFEARRAYBOUND *sab;
@@ -822 +822 @@
 }
 
-/************************************************************************
+/************************************************************************ 
  * 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 +838 @@
   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 +858 @@
   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 +873 @@
   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 +887 @@
 }
 
-/************************************************************************
- * 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 +901 @@
 }
 
-/************************************************************************
- * 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 +915 @@
 }
 
-/************************************************************************
- * Used to calculate the displacement when accessing or modifying
+/************************************************************************ 
+ * Used to calculate the displacement when accessing or modifying 
  * safearray data set.
  *
@@ -926 +926 @@
  */
 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 +942 @@
 }
 
-/************************************************************************
- * 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 +977 @@
     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 +987 @@
   }
   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 +1001 @@
     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 +1018 @@
 
   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 +1032 @@
 
     /* 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 +1046 @@
       }
 
-      *((BSTR*)((char *) (*ppsaOut)->pvData+(lDelta * psa->cbElements))) =
+      *((BSTR*)((char *) (*ppsaOut)->pvData+(lDelta * psa->cbElements))) = 
         pbstrReAllocStr;
     }
@@ -1052 +1052 @@
   } else { /* Simply copy the source array data into target array */
 
-    memcpy((*ppsaOut)->pvData, psa->pvData,
+    memcpy((*ppsaOut)->pvData, psa->pvData, 
       ulWholeArraySize*psa->cbElements);
   }
@@ -1062 +1062 @@
 
 
-/************************************************************************
- *      SafeArrayGetVarType
+/************************************************************************ 
+ *              SafeArrayGetVarType
  * Returns the VARTYPE stored in the given safearray
  */
@@ -1099 +1099 @@
     hr = S_OK;
   }
-
+  
   TRACE("HRESULT = %08lx", hr);
   return hr;

trunk/src/oleaut32/typelib.c

@@ -2394 +2394 @@
 }
 
-static void SLTG_ProcessCoClass(char *pBlk, ITypeInfoImpl *pTI,
-                                char *pNameTable)
+static SLTG_TypeInfoTail *SLTG_ProcessCoClass(char *pBlk, ITypeInfoImpl *pTI,
+                                              char *pNameTable)
 {
     SLTG_TypeInfoHeader *pTIHeader = (SLTG_TypeInfoHeader*)pBlk;
@@ -2415 +2415 @@
     }
 
-    return;
-}
-
-
-static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
-                                  char *pNameTable)
+    return (SLTG_TypeInfoTail*)(pFirstItem + pMemHeader->cbExtra);
+}
+
+
+static SLTG_TypeInfoTail *SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
+                                                char *pNameTable)
 {
     SLTG_TypeInfoHeader *pTIHeader = (SLTG_TypeInfoHeader*)pBlk;
@@ -2451 +2451 @@
            pFunc->magic != SLTG_FUNCTION_WITH_FLAGS_MAGIC) {
             FIXME("func magic = %02x\n", pFunc->magic);
-            return;
+            return NULL;
         }
         *ppFuncDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
@@ -2530 +2530 @@
     pTI->TypeAttr.cFuncs = num;
     dump_TLBFuncDesc(pTI->funclist);
-}
-
-static void SLTG_ProcessRecord(char *pBlk, ITypeInfoImpl *pTI, char *pNameTable)
+    return (SLTG_TypeInfoTail*)(pFirstItem + pMemHeader->cbExtra);
+}
+
+static SLTG_TypeInfoTail *SLTG_ProcessRecord(char *pBlk, ITypeInfoImpl *pTI,
+                                             char *pNameTable)
 {
   SLTG_TypeInfoHeader *pTIHeader = (SLTG_TypeInfoHeader*)pBlk;
@@ -2550 +2552 @@
       if(pItem->magic != SLTG_RECORD_MAGIC) {
           FIXME("record magic = %02x\n", pItem->magic);
-          return;
+          return NULL;
       }
       *ppVarDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
@@ -2579 +2581 @@
   }
   pTI->TypeAttr.cVars = num;
-}
-
-static void SLTG_ProcessEnum(char *pBlk, ITypeInfoImpl *pTI, char *pNameTable)
+  return (SLTG_TypeInfoTail*)(pFirstItem + pMemHeader->cbExtra);
+}
+
+static SLTG_TypeInfoTail *SLTG_ProcessEnum(char *pBlk, ITypeInfoImpl *pTI,
+                                           char *pNameTable)
 {
   SLTG_TypeInfoHeader *pTIHeader = (SLTG_TypeInfoHeader*)pBlk;
@@ -2616 +2620 @@
   }
   pTI->TypeAttr.cVars = num;
+  return (SLTG_TypeInfoTail*)(pFirstItem + pMemHeader->cbExtra);
 }
 
@@ -2801 +2806 @@
 
       SLTG_TypeInfoHeader *pTIHeader;
+      SLTG_TypeInfoTail *pTITail;
 
       if(strcmp(pBlkEntry[order].index_string + (char*)pMagic,
@@ -2841 +2847 @@
       switch(pTIHeader->typekind) {
       case TKIND_ENUM:
-        SLTG_ProcessEnum(pBlk, *ppTypeInfoImpl, pNameTable); 
+        pTITail = SLTG_ProcessEnum(pBlk, *ppTypeInfoImpl, pNameTable); 
         break;
 
       case TKIND_RECORD:
-        SLTG_ProcessRecord(pBlk, *ppTypeInfoImpl, pNameTable); 
+        pTITail = SLTG_ProcessRecord(pBlk, *ppTypeInfoImpl, pNameTable); 
         break;
 
       case TKIND_INTERFACE:
-        SLTG_ProcessInterface(pBlk, *ppTypeInfoImpl, pNameTable);
+        pTITail = SLTG_ProcessInterface(pBlk, *ppTypeInfoImpl, pNameTable);
         break;
 
       case TKIND_COCLASS:
-        SLTG_ProcessCoClass(pBlk, *ppTypeInfoImpl, pNameTable);
+        pTITail = SLTG_ProcessCoClass(pBlk, *ppTypeInfoImpl, pNameTable);
         break;
 
       default:
         FIXME("Not processing typekind %d\n", pTIHeader->typekind);
+        pTITail = NULL;
         break;
 
       }
 
+      if(pTITail) { /* could get cFuncs, cVars and cImplTypes from here
+                       but we've already set those */
+          (*ppTypeInfoImpl)->TypeAttr.cbAlignment = pTITail->cbAlignment;
+          (*ppTypeInfoImpl)->TypeAttr.cbSizeInstance = pTITail->cbSizeInstance;
+          (*ppTypeInfoImpl)->TypeAttr.cbSizeVft = pTITail->cbSizeVft;
+      }
       ppTypeInfoImpl = &((*ppTypeInfoImpl)->next);
 #ifdef __WIN32OS2__
@@ -3098 +3111 @@
     ICOM_THIS( ITypeLibImpl, iface);
     TRACE("(%p)\n",This);
-    /* FIXME: must do a copy here */
-    *ppTLibAttr=&This->LibAttr;
+    *ppTLibAttr = HeapAlloc(GetProcessHeap(), 0, sizeof(**ppTLibAttr));
+    memcpy(*ppTLibAttr, &This->LibAttr, sizeof(**ppTLibAttr));
     return S_OK;
 }
@@ -3294 +3307 @@
     ICOM_THIS( ITypeLibImpl, iface);
     TRACE("freeing (%p)\n",This);
-    /* nothing to do */
+    HeapFree(GetProcessHeap(),0,pTLibAttr);
+
 }
 

trunk/src/oleaut32/typelib.h

@@ -23 +23 @@
 
 /* There are two known file formats, those created with ICreateTypeLib
- * have the signature "SLGT" as their first four bytes, while those created
+ * have the signature "SLTG" as their first four bytes, while those created
  * with ICreateTypeLib2 have "MSFT".
  */
@@ -377 +377 @@
 
 typedef struct {
+/*00*/  WORD cFuncs;
+/*02*/  WORD cVars;
+/*04*/  WORD cImplTypes;
+/*06*/  WORD res06;
+/*08*/  WORD res08;
+/*0a*/  WORD res0a;
+/*0c*/  WORD res0c;
+/*0e*/  WORD res0e;
+/*10*/  WORD res10;
+/*12*/  WORD res12;
+/*14*/  WORD res14;
+/*16*/  WORD res16;
+/*18*/  WORD res18;
+/*1a*/  WORD res1a;
+/*1c*/  WORD res1c;
+/*1e*/  WORD res1e;
+/*20*/  WORD cbSizeInstance;
+/*22*/  WORD cbAlignment;
+/*24*/  WORD res24;
+/*26*/  WORD res26;
+/*28*/  WORD cbSizeVft;
+/*2a*/  WORD res2a;
+/*2c*/  WORD res2c;
+/*2e*/  WORD res2e;
+/*30*/  WORD res30;
+/*32*/  WORD res32;
+/*34*/  WORD res34;
+} SLTG_TypeInfoTail;
+
+typedef struct {
 /*00*/ WORD res00; /* 0x0001 sometimes 0x0003 ?? */
 /*02*/ WORD res02; /* 0xffff */

trunk/src/oleaut32/variant.c

@@ -28 +28 @@
 
 #include "config.h"
-
+ 
 #include <string.h>
 #include <stdlib.h>
@@ -106 +106 @@
 
 /******************************************************************************
- *     DateTimeStringToTm   [INTERNAL]
+ *         DateTimeStringToTm   [INTERNAL]
  *
  * Converts a string representation of a date and/or time to a tm structure.
@@ -122 +122 @@
 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 +216 @@
  * 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 +235 @@
 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 +339 @@
 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 +528 @@
 }
 /******************************************************************************
- *     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 +556 @@
    nSign = (d >= 0.0) ? 1 : -1;
     d = fabs( d );
-
-    /* Remove the decimals.
-     */
+    
+        /* Remove the decimals.
+         */
    integerValue = floor( d );
 
@@ -573 +573 @@
     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 +603 @@
     }
 
-    return roundedValue * nSign;
-}
-
-/******************************************************************************
- *      RemoveCharacterFromString       [INTERNAL]
+        return roundedValue * nSign;
+}
+
+/******************************************************************************
+ *              RemoveCharacterFromString               [INTERNAL]
  *
  * Removes any of the characters in "strOfCharToRemove" from the "str" argument.
@@ -613 +613 @@
 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 +640 @@
 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 +700 @@
      * 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 +880 @@
  *
  * 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 +916 @@
         }
         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 +1039 @@
             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 +1608 @@
 
 /******************************************************************************
- *      ValidateVartype [INTERNAL]
+ *              ValidateVartype [INTERNAL]
  *
  * Used internally by the hi-level Variant API to determine
@@ -1615 +1615 @@
 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 +1626 @@
         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 +1636 @@
         res = ValidateVtRange( vt );
     }
-
-    return res;
-}
-
-/******************************************************************************
- *      ValidateVt  [INTERNAL]
+                
+        return res;
+}
+
+/******************************************************************************
+ *              ValidateVt      [INTERNAL]
  *
  * Used internally by the hi-level Variant API to determine
@@ -1648 +1648 @@
 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 +1659 @@
         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 +1669 @@
         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 +1694 @@
 
 /******************************************************************************
- *      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 +1716 @@
       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 +1756 @@
 
 /******************************************************************************
- *      VariantCopy [OLEAUT32.10]
+ *              VariantCopy     [OLEAUT32.10]
  *
  * Frees up the designation variant and makes a copy of the source.
@@ -1774 +1774 @@
   {
     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 +1839 @@
 
 /******************************************************************************
- *      VariantCopyInd  [OLEAUT32.11]
+ *              VariantCopyInd  [OLEAUT32.11]
  *
  * Frees up the destination variant and makes a copy of the source.  If
@@ -1854 +1854 @@
   if( res != S_OK )
     return res;
-
+  
   if( V_VT(pvargSrc) & VT_BYREF )
   {
@@ -1876 +1876 @@
       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 +1968 @@
 
 /******************************************************************************
- *      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 +2262 @@
 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 +2270 @@
 
 /******************************************************************************
- *      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 +2468 @@
 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 +2476 @@
 
 /******************************************************************************
- *      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 +2661 @@
 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 +2669 @@
 
 /******************************************************************************
- *      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 +2835 @@
 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 +2985 @@
 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 +3038 @@
 
     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 +3054 @@
     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 +3074 @@
  *
  * 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 +3083 @@
  *
  * The formats for the date and time string are has follows.
- * date[whitespace][time]
+ * date[whitespace][time] 
  * [time][whitespace]date
  *
@@ -3111 +3111 @@
 
 
-    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 +3184 @@
 
 /******************************************************************************
- *      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 +3251 @@
  */
 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 +3274 @@
  * 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 +3293 @@
 
     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 +3597 @@
       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 +3800 @@
 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 +3808 @@
 
 /******************************************************************************
- *      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 +4034 @@
 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 +4095 @@
     fltIn = round( fltIn );
     if( fltIn < UI4_MIN || fltIn > UI4_MAX )
-    {
-        return DISP_E_OVERFLOW;
+        {
+                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 );
+
+    dblIn = round( dblIn );
+        if( dblIn < UI4_MIN || dblIn > UI4_MAX )
+        {
+                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 );
-
-    dblIn = round( dblIn );
-    if( dblIn < UI4_MIN || dblIn > UI4_MAX )
-    {
-        return DISP_E_OVERFLOW;
-    }
-
-    *pulOut = (ULONG) dblIn;
-
-    return S_OK;
-}
-
-/******************************************************************************
- *      VarUI4FromDate      [OLEAUT32.275]
+        *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 +4182 @@
 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 +4197 @@
    pcyOut->s.Hi = 0;
    pcyOut->s.Lo = ((ULONG)bIn) * 10000;
-
+   
    return S_OK;
 }
@@ -4209 +4209 @@
    else pcyOut->s.Hi = 0;
    pcyOut->s.Lo = ((ULONG)sIn) * 10000;
-
+   
    return S_OK;
 }
@@ -4222 +4222 @@
       pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
       if (lIn < 0) pcyOut->s.Hi--;
-
+   
       return S_OK;
 }
@@ -4235 +4235 @@
    pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
    if (fltIn < 0) pcyOut->s.Hi--;
-
+   
    return S_OK;
 }
@@ -4269 +4269 @@
  */
 HRESULT WINAPI VarCyFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pcyOut) {
-                /* FIXME */
-        return E_NOTIMPL;
-}
-
-
+                                /* FIXME */
+                return E_NOTIMPL;
+}
+
+ 
 /**********************************************************************
  *              VarCyFromBool [OLEAUT32.106]
@@ -4282 +4282 @@
    else pcyOut->s.Hi = 0;
    pcyOut->s.Lo = (ULONG)boolIn * (ULONG)10000;
-
+   
    return S_OK;
 }
@@ -4294 +4294 @@
    else pcyOut->s.Hi = 0;
    pcyOut->s.Lo = (ULONG)cIn * (ULONG)10000;
-
+   
    return S_OK;
 }
@@ -4305 +4305 @@
    pcyOut->s.Hi = 0;
    pcyOut->s.Lo = (ULONG)usIn * (ULONG)10000;
-
+   
    return S_OK;
 }
@@ -4317 +4317 @@
    pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
    pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
-
+      
    return S_OK;
 }
@@ -4333 +4333 @@
 
     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 +4363 @@
     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;
-        }
+        if ((strIn[i]>='0') && (strIn[i]<='9')) {
+            if (pnumprs->cDig > cDig) {
+                *(rgbDig++)=strIn[i]-'0';
+                cDig++;
+                lastent = i;
+            }
+        }
     }
-    }
-    pnumprs->cDig   = cDig;
+    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 +4394 @@
     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 +4659 @@
  *              VarBstrCmp [OLEAUT32.440]
  *
- * flags can be:
+ * flags can be: 
  *   NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
  *   NORM_IGNORESTRINGWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA