[ITSS] Sync with Wine Staging 4.18. CORE-16441

dll/win32/itss/chm_lib.c

···
  *                                                                         *
  ***************************************************************************/
 
-#include "config.h"
-#include "wine/port.h"
 
 #include <stdarg.h>
 #include <stdio.h>
···
 
 #include "windef.h"
 #include "winbase.h"
-#include "wine/unicode.h"
+#include "winnls.h"
 
 #include "chm_lib.h"
 #include "lzx.h"
···
             return NULL;
 
         /* check if it is the right name */
-        if (! strcmpiW(buffer, objPath))
+        if (! wcsicmp(buffer, objPath))
             return temp;
 
         _chm_skip_PMGL_entry_data(&cur);
···
             return -1;
 
         /* check if it is the right name */
-        if (strcmpiW(buffer, objPath) > 0)
+        if (wcsicmp(buffer, objPath) > 0)
             return page;
 
         /* load next value for path */
···
     /* data request not satisfied, so... start up the decompressor machine */
     if (! h->lzx_state)
     {
-        int window_size = ffs(h->window_size) - 1;
         h->lzx_last_block = -1;
-        h->lzx_state = LZXinit(window_size);
+        h->lzx_state = LZXinit(h->window_size);
     }
 
     /* decompress some data */
···
 
     /* initialize pathname state */
     lstrcpynW(prefixRectified, prefix, CHM_MAX_PATHLEN);
-    prefixLen = strlenW(prefixRectified);
+    prefixLen = lstrlenW(prefixRectified);
     if (prefixLen != 0)
     {
         if (prefixRectified[prefixLen-1] != '/')
···
             /* check if we should start */
             if (! it_has_begun)
             {
-                if (ui.length == 0  &&  strncmpiW(ui.path, prefixRectified, prefixLen) == 0)
+                if (ui.length == 0  &&  _wcsnicmp(ui.path, prefixRectified, prefixLen) == 0)
                     it_has_begun = TRUE;
                 else
                     continue;
···
             /* check if we should stop */
             else
             {
-                if (strncmpiW(ui.path, prefixRectified, prefixLen) != 0)
+                if (_wcsnicmp(ui.path, prefixRectified, prefixLen) != 0)
                 {
                     HeapFree(GetProcessHeap(), 0, page_buf);
                     return TRUE;
···
             /* check if we should include this path */
             if (lastPathLen != -1)
             {
-                if (strncmpiW(ui.path, lastPath, lastPathLen) == 0)
+                if (_wcsnicmp(ui.path, lastPath, lastPathLen) == 0)
                     continue;
             }
-            strcpyW(lastPath, ui.path);
-            lastPathLen = strlenW(lastPath);
+            lstrcpyW(lastPath, ui.path);
+            lastPathLen = lstrlenW(lastPath);
 
             /* get the length of the path */
-            ui_path_len = strlenW(ui.path)-1;
+            ui_path_len = lstrlenW(ui.path)-1;
 
             /* check for DIRS */
             if (ui.path[ui_path_len] == '/'  &&  !(what & CHM_ENUMERATE_DIRS))

dll/win32/itss/itss.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
 
 #include <stdarg.h>
 #include <stdio.h>
···
 #include "rpcproxy.h"
 #include "advpub.h"
 
-#include "wine/unicode.h"
 #include "wine/debug.h"
 
 #include "itsstor.h"

dll/win32/itss/lzx.c

···
     1835008, 1966080, 2097152
 };
 
-struct LZXstate *LZXinit(int window)
+struct LZXstate *LZXinit(int wndsize)
 {
     struct LZXstate *pState=NULL;
-    ULONG wndsize = 1 << window;
     int i, posn_slots;
-
-    /* LZX supports window sizes of 2^15 (32Kb) through 2^21 (2Mb) */
-    /* if a previously allocated window is big enough, keep it     */
-    if (window < 15 || window > 21) return NULL;
 
     /* allocate state and associated window */
     pState = HeapAlloc(GetProcessHeap(), 0, sizeof(struct LZXstate));
···
     pState->window_size = wndsize;
 
     /* calculate required position slots */
-    if (window == 20) posn_slots = 42;
-    else if (window == 21) posn_slots = 50;
-    else posn_slots = window << 1;
-
-    /** alternatively **/
-    /* posn_slots=i=0; while (i < wndsize) i += 1 << extra_bits[posn_slots++]; */
+    posn_slots = i = 0;
+    while (i < wndsize) i += 1 << extra_bits[posn_slots++];
 
     /* initialize other state */
     pState->R0  =  pState->R1  = pState->R2 = 1;
···
     int i;
     int count=0;
     int w = atoi(v[1]);
-    LZXinit(&state, w);
+    LZXinit(&state, 1 << w);
     fout = fopen(v[2], "wb");
     for (i=3; i<c; i++)
     {

dll/win32/itss/moniker.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
 
 #include <stdarg.h>
 #include <stdio.h>
···
 #include "ole2.h"
 
 #include "wine/itss.h"
-#include "wine/unicode.h"
 #include "wine/debug.h"
 
 #include "itsstor.h"
···
 
     TRACE("%p %p %p %p\n", iface, pbc, pmkToLeft, ppszDisplayName);
 
-    len = strlenW( This->szFile ) + strlenW( This->szHtml );
+    len = lstrlenW( This->szFile ) + lstrlenW( This->szHtml );
     str = CoTaskMemAlloc( len*sizeof(WCHAR) );
-    sprintfW( str, szFormat, This->szFile, This->szHtml );
+    swprintf( str, szFormat, This->szFile, This->szHtml );
 
     *ppszDisplayName = str;
     
···
     DWORD sz;
 
     /* szFile[1] has space for one character already */
-    sz = FIELD_OFFSET( ITS_IMonikerImpl, szFile[strlenW( name ) + 1] );
+    sz = FIELD_OFFSET( ITS_IMonikerImpl, szFile[lstrlenW( name ) + 1] );
 
     itsmon = HeapAlloc( GetProcessHeap(), 0, sz );
     itsmon->IMoniker_iface.lpVtbl = &ITS_IMonikerImpl_Vtbl;
     itsmon->ref = 1;
-    strcpyW( itsmon->szFile, name );
+    lstrcpyW( itsmon->szFile, name );
     itsmon->szHtml = &itsmon->szFile[n];
 
     while( *itsmon->szHtml == ':' )
···
     TRACE("%p %s %p %p\n", This,
           debugstr_w( pszDisplayName ), pchEaten, ppmkOut );
 
-    if( strncmpiW( pszDisplayName, szPrefix, prefix_len ) )
+    if( _wcsnicmp( pszDisplayName, szPrefix, prefix_len ) )
         return MK_E_SYNTAX;
 
     /* search backwards for a double colon */
-    for( n = strlenW( pszDisplayName ) - 3; prefix_len <= n; n-- )
+    for( n = lstrlenW( pszDisplayName ) - 3; prefix_len <= n; n-- )
         if( ( pszDisplayName[n] == ':' ) && ( pszDisplayName[n+1] == ':' ) )
             break;
 
···
     if( !pszDisplayName[n+2] )
         return MK_E_SYNTAX;
 
-    *pchEaten = strlenW( pszDisplayName ) - n - 3;
+    *pchEaten = lstrlenW( pszDisplayName ) - n - 3;
 
     return ITS_IMoniker_create( ppmkOut,
               &pszDisplayName[prefix_len], n-prefix_len );

dll/win32/itss/precomp.h

···
 #ifndef _ITSS_PCH_
 #define _ITSS_PCH_
 
-#include <wine/config.h>
-#include <wine/port.h>
-
 #include <stdarg.h>
 
 #define WIN32_NO_STATUS
···
 #include <objbase.h>
 
 #include <wine/itss.h>
-#include <wine/unicode.h>
 #include <wine/debug.h>
 
 #include "chm_lib.h"

dll/win32/itss/protocol.c

···
 #include "chm_lib.h"
 
 #include "wine/debug.h"
-#include "wine/unicode.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(itss);
 
···
     static const WCHAR msits_schema[] = {'m','s','-','i','t','s',':'};
     static const WCHAR mk_schema[] = {'m','k',':','@','M','S','I','T','S','t','o','r','e',':'};
 
-    if(!strncmpiW(its_schema, url, ARRAY_SIZE(its_schema)))
+    if(!_wcsnicmp(its_schema, url, ARRAY_SIZE(its_schema)))
         return url + ARRAY_SIZE(its_schema);
-    if(!strncmpiW(msits_schema, url, ARRAY_SIZE(msits_schema)))
+    if(!_wcsnicmp(msits_schema, url, ARRAY_SIZE(msits_schema)))
         return url + ARRAY_SIZE(msits_schema);
-    if(!strncmpiW(mk_schema, url, ARRAY_SIZE(mk_schema)))
+    if(!_wcsnicmp(mk_schema, url, ARRAY_SIZE(mk_schema)))
         return url + ARRAY_SIZE(mk_schema);
 
     return NULL;
···
 
     ReleaseBindInfo(&bindinfo);
 
-    len = strlenW(ptr)+3;
+    len = lstrlenW(ptr)+3;
     file_name = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
     memcpy(file_name, ptr, len*sizeof(WCHAR));
     hres = UrlUnescapeW(file_name, NULL, &len, URL_UNESCAPE_INPLACE);
···
         return hres;
     }
 
-    p = strstrW(file_name, separator);
+    p = wcsstr(file_name, separator);
     if(!p) {
         WARN("invalid url\n");
         HeapFree(GetProcessHeap(), 0, file_name);
···
     }
 
     object_name = p+2;
-    len = strlenW(object_name);
+    len = lstrlenW(object_name);
 
     if(*object_name != '/' && *object_name != '\\') {
         memmove(object_name+1, object_name, (len+1)*sizeof(WCHAR));
···
     }
 
     IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST,
-                                         strrchrW(object_name, '/')+1);
+                                         wcsrchr(object_name, '/')+1);
 
     /* FIXME: Native doesn't use FindMimeFromData */
     hres = FindMimeFromData(NULL, object_name, NULL, 0, NULL, 0, &mime, 0);
···
             debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult,
             pcchResult, dwReserved);
 
-    base_end = strstrW(pwzBaseUrl, separator);
+    base_end = wcsstr(pwzBaseUrl, separator);
     if(!base_end)
         return 0x80041001;
     base_end += 2;
···
     if(!skip_schema(pwzBaseUrl))
         return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
 
-    if(strchrW(pwzRelativeUrl, ':'))
+    if(wcschr(pwzRelativeUrl, ':'))
         return STG_E_INVALIDNAME;
 
     if(pwzRelativeUrl[0] == '#') {
-        base_end += strlenW(base_end);
+        base_end += lstrlenW(base_end);
     }else if(pwzRelativeUrl[0] != '/') {
-        ptr = strrchrW(base_end, '/');
+        ptr = wcsrchr(base_end, '/');
         if(ptr)
             base_end = ptr+1;
         else
-            base_end += strlenW(base_end);
+            base_end += lstrlenW(base_end);
     }
 
-    rel_len = strlenW(pwzRelativeUrl)+1;
+    rel_len = lstrlenW(pwzRelativeUrl)+1;
 
     *pcchResult = rel_len + (base_end-pwzBaseUrl);
 
···
         return E_OUTOFMEMORY;
 
     memcpy(pwzResult, pwzBaseUrl, (base_end-pwzBaseUrl)*sizeof(WCHAR));
-    strcpyW(pwzResult + (base_end-pwzBaseUrl), pwzRelativeUrl);
+    lstrcpyW(pwzResult + (base_end-pwzBaseUrl), pwzRelativeUrl);
 
     return S_OK;
 }

dll/win32/itss/storage.c

···
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include "config.h"
 
 #include <stdarg.h>
 #include <stdio.h>
···
 #include "itsstor.h"
 
 #include "wine/itss.h"
-#include "wine/unicode.h"
 #include "wine/debug.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(itss);
···
         str = cur->ui.path;
         if( *str == '/' )
             str++;
-        len = strlenW( str ) + 1;
+        len = lstrlenW( str ) + 1;
         rgelt->pwcsName = CoTaskMemAlloc( len*sizeof(WCHAR) );
-        strcpyW( rgelt->pwcsName, str );
+        lstrcpyW( rgelt->pwcsName, str );
 
         /* determine the type */
         if( rgelt->pwcsName[len-2] == '/' )
···
     TRACE("%p %s %p %u %u %p\n", This, debugstr_w(pwcsName),
           reserved1, grfMode, reserved2, ppstm );
 
-    len = strlenW( This->dir ) + strlenW( pwcsName ) + 1;
+    len = lstrlenW( This->dir ) + lstrlenW( pwcsName ) + 1;
     path = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
-    strcpyW( path, This->dir );
+    lstrcpyW( path, This->dir );
 
     if( pwcsName[0] == '/' || pwcsName[0] == '\\' )
     {
-        p = &path[strlenW( path ) - 1];
+        p = &path[lstrlenW( path ) - 1];
         while( ( path <= p ) && ( *p == '/' ) )
             *p-- = 0;
     }
-    strcatW( path, pwcsName );
+    lstrcatW( path, pwcsName );
 
     for(p=path; *p; p++) {
         if(*p == '\\')
···
     if( !chmfile )
         return E_FAIL;
 
-    len = strlenW( This->dir ) + strlenW( pwcsName ) + 2; /* need room for a terminating slash */
+    len = lstrlenW( This->dir ) + lstrlenW( pwcsName ) + 2; /* need room for a terminating slash */
     path = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
-    strcpyW( path, This->dir );
+    lstrcpyW( path, This->dir );
 
     if( pwcsName[0] == '/' || pwcsName[0] == '\\' )
     {
-        p = &path[strlenW( path ) - 1];
+        p = &path[lstrlenW( path ) - 1];
         while( ( path <= p ) && ( *p == '/' ) )
             *p-- = 0;
     }
-    strcatW( path, pwcsName );
+    lstrcatW( path, pwcsName );
 
     for(p=path; *p; p++) {
         if(*p == '\\')
···
     TRACE("%p %s\n", chmfile, debugstr_w( dir ) );
 
     stg = HeapAlloc( GetProcessHeap(), 0,
-                     FIELD_OFFSET( ITSS_IStorageImpl, dir[strlenW( dir ) + 1] ));
+                     FIELD_OFFSET( ITSS_IStorageImpl, dir[lstrlenW( dir ) + 1] ));
     stg->IStorage_iface.lpVtbl = &ITSS_IStorageImpl_Vtbl;
     stg->ref = 1;
     stg->chmfile = chmfile;
-    strcpyW( stg->dir, dir );
+    lstrcpyW( stg->dir, dir );
 
     *ppstgOpen = &stg->IStorage_iface;
 

media/doc/README.WINE

···
 dll/win32/inseng              # Synced to WineStaging-4.18
 dll/win32/iphlpapi            # Out of sync
 dll/win32/itircl              # Synced to WineStaging-4.18
-dll/win32/itss                # Synced to WineStaging-3.17
+dll/win32/itss                # Synced to WineStaging-4.18
 dll/win32/jscript             # Synced to WineStaging-4.0
 dll/win32/jsproxy             # Synced to WineStaging-4.0
 dll/win32/loadperf            # Synced to WineStaging-3.3