diff --git a/dlls/shell32/shellpath.c b/dlls/shell32/shellpath.c
new file mode 100644
index 0000000..4f49275
--- /dev/null
+++ b/dlls/shell32/shellpath.c
@@ -0,0 +1,633 @@
+/*
+ * Path Functions
+ *
+ * Many of this functions are in SHLWAPI.DLL also
+ *
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include "windows.h"
+#include "winerror.h"
+#include "file.h"
+#include "shell.h"
+#include "shlobj.h"
+#include "debug.h"
+#include "winnls.h"
+#include "winversion.h"
+#include "shell32_main.h"
+
+/*************************************************************************
+ * PathIsRoot [SHELL32.29]
+ */
+BOOL32 WINAPI PathIsRoot32A(LPCSTR x)
+{	TRACE(shell,"%s\n",x);
+	if (*(x+1)==':' && *(x+2)=='\\')		/* "X:\" */
+	  return 1;
+	if (*x=='\\')		/* "\" */
+	  return 0;
+	if (x[0]=='\\' && x[1]=='\\')		/* UNC "\\<xx>\" */
+	{ int	foundbackslash = 0;
+	  x=x+2;
+	  while (*x)
+	  { if (*x++=='\\')
+	      foundbackslash++;
+	  }
+	  if (foundbackslash<=1)	/* max 1 \ more ... */
+	    return 1;
+	}
+	return 0;
+}
+BOOL32 WINAPI PathIsRoot32W(LPCWSTR x) 
+{	TRACE(shell,"%s\n",debugstr_w(x));
+	if (*(x+1)==':' && *(x+2)=='\\')		/* "X:\" */
+	  return 1;
+	if (*x == (WCHAR) '\\')		/* "\" */
+	  return 0;
+	if (x[0]==(WCHAR)'\\' && x[1]==(WCHAR)'\\')	/* UNC "\\<xx>\" */
+	{ int	foundbackslash = 0;
+	  x=x+2;
+	  while (*x) 
+	  { if (*x++==(WCHAR)'\\')
+	      foundbackslash++;
+	  }
+	  if (foundbackslash<=1)	/* max 1 \ more ... */
+	    return 1;
+	}
+	return 0;
+}
+BOOL32 WINAPI PathIsRoot32AW(LPCVOID x) 
+{	if (VERSION_OsIsUnicode())
+	  return PathIsRoot32W(x);
+	return PathIsRoot32A(x);
+
+}
+/*************************************************************************
+ * PathBuildRoot [SHELL32.30]
+ */
+LPSTR WINAPI PathBuildRoot(LPSTR root,BYTE drive) {
+  TRACE(shell,"%p %i\n",root, drive);
+	strcpy(root,"A:\\");
+	root[0]+=drive;
+	return root;
+}
+
+/*************************************************************************
+ * PathFindExtension [SHELL32.31]
+ *
+ * NOTES
+ *     returns pointer to last . in last pathcomponent or at \0.
+ */
+LPCSTR WINAPI PathFindExtension32A(LPCSTR path) 
+{	LPCSTR   lastpoint = NULL;
+	TRACE(shell,"%p %s\n",path,path);
+	while (*path) 
+	{ if (*path=='\\'||*path==' ')
+	    lastpoint=NULL;
+	  if (*path=='.')
+	    lastpoint=path;
+	  path++;
+	}
+	return lastpoint?lastpoint:path;
+}
+LPCWSTR WINAPI PathFindExtension32W(LPCWSTR path) 
+{	LPCWSTR   lastpoint = NULL;
+	TRACE(shell,"%p L%s\n",path,debugstr_w(path));
+	while (*path)
+	{ if (*path==(WCHAR)'\\'||*path==(WCHAR)' ')
+	    lastpoint=NULL;
+	  if (*path==(WCHAR)'.')
+	    lastpoint=path;
+	  path++;
+	}
+	return lastpoint?lastpoint:path;
+}
+LPCVOID WINAPI PathFindExtension32AW(LPCVOID path) 
+{	if (VERSION_OsIsUnicode())
+	  return PathFindExtension32W(path);
+	return PathFindExtension32A(path);
+
+}
+
+/*************************************************************************
+ * PathAddBackslash [SHELL32.32]
+ * 
+ * NOTES
+ *     append \ if there is none
+ */
+LPSTR WINAPI PathAddBackslash32A(LPSTR path)
+{	int len;
+	TRACE(shell,"%p->%s\n",path,path);
+
+	len = strlen(path);
+	if (len && path[len-1]!='\\') 
+	{ path[len]  = '\\';
+	  path[len+1]= 0x00;
+	  return path+len+1;
+	}
+	return path+len;
+}
+LPWSTR WINAPI PathAddBackslash32W(LPWSTR path)
+{	int len;
+	TRACE(shell,"%p->%s\n",path,debugstr_w(path));
+
+	len = lstrlen32W(path);
+	if (len && path[len-1]!=(WCHAR)'\\') 
+	{ path[len]  = (WCHAR)'\\';
+	  path[len+1]= 0x00;
+	  return path+len+1;
+	}
+	return path+len;
+}
+LPVOID WINAPI PathAddBackslash32AW(LPVOID path)
+{	if(VERSION_OsIsUnicode())
+	  return PathAddBackslash32W(path);
+	return PathAddBackslash32A(path);
+}
+
+/*************************************************************************
+ * PathRemoveBlanks [SHELL32.33]
+ * 
+ * NOTES
+ *     remove spaces from beginning and end of passed string
+ */
+LPSTR WINAPI PathRemoveBlanks32A(LPSTR str)
+{	LPSTR x = str;
+	TRACE(shell,"%s\n",str);
+	while (*x==' ') x++;
+	if (x!=str)
+	  strcpy(str,x);
+	if (!*str)
+	  return str;
+	x=str+strlen(str)-1;
+	while (*x==' ')
+	  x--;
+	if (*x==' ')
+	  *x='\0';
+	return x;
+}
+LPWSTR WINAPI PathRemoveBlanks32W(LPWSTR str)
+{	LPWSTR x = str;
+	TRACE(shell,"%s\n",debugstr_w(str));
+	while (*x==' ') x++;
+	if (x!=str)
+	  lstrcpy32W(str,x);
+	if (!*str)
+	  return str;
+	x=str+lstrlen32W(str)-1;
+	while (*x==' ')
+	  x--;
+	if (*x==' ')
+	  *x='\0';
+	return x;
+}
+LPVOID WINAPI PathRemoveBlanks32AW(LPVOID str)
+{	if(VERSION_OsIsUnicode())
+	  return PathRemoveBlanks32W(str);
+	return PathRemoveBlanks32A(str);
+}
+
+
+
+/*************************************************************************
+ * PathFindFilename [SHELL32.34]
+ * 
+ * NOTES
+ *     basename(char *fn);
+ */
+LPCSTR WINAPI PathFindFilename32A(LPCSTR aptr)
+{	LPCSTR aslash;
+	aslash = aptr;
+
+	TRACE(shell,"%s\n",aslash);
+	while (aptr[0]) 
+	{ if (((aptr[0]=='\\') || (aptr[0]==':')) && aptr[1] && aptr[1]!='\\')
+	      aslash = aptr+1;
+	  aptr++;
+	}
+	return aslash;
+
+}
+LPCWSTR WINAPI PathFindFilename32W(LPCWSTR wptr)
+{	LPCWSTR wslash;
+	wslash = wptr;
+
+	TRACE(shell,"L%s\n",debugstr_w(wslash));
+	while (wptr[0]) 
+	{ if (((wptr[0]=='\\') || (wptr[0]==':')) && wptr[1] && wptr[1]!='\\')
+	    wslash = wptr+1;
+	  wptr++;
+	}
+	return wslash;	
+}
+LPCVOID WINAPI PathFindFilename32AW(LPCVOID fn)
+{
+	if(VERSION_OsIsUnicode())
+	  return PathFindFilename32W(fn);
+	return PathFindFilename32A(fn);
+}
+
+/*************************************************************************
+ * PathRemoveFileSpec [SHELL32.35]
+ * 
+ * NOTES
+ *     bool getpath(char *pathname); truncates passed argument to a valid path
+ *     returns if the string was modified or not.
+ *     "\foo\xx\foo"-> "\foo\xx"
+ *     "\" -> "\"
+ *     "a:\foo"	-> "a:\"
+ */
+DWORD WINAPI PathRemoveFileSpec(LPSTR fn) {
+	LPSTR	x,cutplace;
+  TRACE(shell,"%s\n",fn);
+	if (!fn[0])
+		return 0;
+	x=fn;
+	cutplace = fn;
+	while (*x) {
+		if (*x=='\\') {
+			cutplace=x++;
+			continue;
+		}
+		if (*x==':') {
+			x++;
+			if (*x=='\\')
+				cutplace=++x;
+			continue; /* already x++ed */
+		}
+		x++;
+	}
+	if (!*cutplace)
+		return 0;
+	if (cutplace==fn) {
+		if (fn[0]=='\\') {
+			if (!fn[1])
+				return 0;
+			fn[0]='\0';
+			return 1;
+		}
+	}
+	*cutplace='\0';
+	return 1;
+}
+
+/*************************************************************************
+ * PathAppend [SHELL32.36]
+ * 
+ * NOTES
+ *     concat_paths(char*target,const char*add);
+ *     concats "target\\add" and writes them to target
+ */
+LPSTR WINAPI PathAppend(LPSTR x1,LPSTR x2) {
+  TRACE(shell,"%s %s\n",x1,x2);
+  while (x2[0]=='\\') x2++;
+  return PathCombine32A(x1,x1,x2);
+}
+
+/*************************************************************************
+ * PathCombine [SHELL32.37]
+ * 
+ * NOTES
+ *  if lpszFile='.' skip it
+ *  szDest can be equal to lpszFile. Thats why we use sTemp
+ */
+LPSTR WINAPI PathCombine32A(LPSTR szDest, LPCSTR lpszDir, LPCSTR lpszFile) 
+{	char sTemp[MAX_PATH];
+	TRACE(shell,"%p %p->%s %p->%s\n",szDest, lpszDir, lpszDir, lpszFile, lpszFile);
+	
+	
+	if (!lpszFile || !lpszFile[0] || (lpszFile[0]=='.' && !lpszFile[1]) ) 
+	{ strcpy(szDest,lpszDir);
+	  return szDest;
+	}
+
+	/*  if lpszFile is a complete path don't care about lpszDir */
+	if (PathIsRoot32A(lpszFile))
+	{ strcpy(szDest,lpszFile);
+	}
+	strcpy(sTemp,lpszDir);
+	PathAddBackslash32A(sTemp);
+	strcat(sTemp,lpszFile);
+	strcpy(szDest,sTemp);
+	return szDest;
+}
+LPWSTR WINAPI PathCombine32W(LPWSTR szDest, LPCWSTR lpszDir, LPCWSTR lpszFile) 
+{	WCHAR sTemp[MAX_PATH];
+	TRACE(shell,"%p %p->%s %p->%s\n",szDest, lpszDir, debugstr_w(lpszDir),
+			 lpszFile, debugstr_w(lpszFile));
+	
+	
+	if (!lpszFile || !lpszFile[0] || (lpszFile[0]==(WCHAR)'.' && !lpszFile[1]) ) 
+	{ lstrcpy32W(szDest,lpszDir);
+	  return szDest;
+	}
+
+	/*  if lpszFile is a complete path don't care about lpszDir */
+	if (PathIsRoot32W(lpszFile))
+	{ lstrcpy32W(szDest,lpszFile);
+	}
+	lstrcpy32W(sTemp,lpszDir);
+	PathAddBackslash32W(sTemp);
+	lstrcat32W(sTemp,lpszFile);
+	lstrcpy32W(szDest,sTemp);
+	return szDest;
+}
+LPVOID WINAPI PathCombine32AW(LPVOID szDest, LPCVOID lpszDir, LPCVOID lpszFile) 
+{	if (VERSION_OsIsUnicode())
+	  return PathCombine32W( szDest, lpszDir, lpszFile );
+	return PathCombine32A( szDest, lpszDir, lpszFile );
+}
+
+/*************************************************************************
+ * PathIsUNC [SHELL32.39]
+ * 
+ * NOTES
+ *     PathIsUNC(char*path);
+ */
+BOOL32 WINAPI PathIsUNC(LPCSTR path) {
+  TRACE(shell,"%s\n",path);
+	if ((path[0]=='\\') && (path[1]=='\\'))
+		return TRUE;
+	return FALSE;
+}
+/*************************************************************************
+ *  PathIsExe [SHELL32.43]
+ * 
+ */
+BOOL32 WINAPI PathIsExe (LPCSTR path)
+{  TRACE(shell,"path=%s\n",path);
+    return FALSE;
+}
+
+/*************************************************************************
+ * PathFileExists [SHELL32.45]
+ * 
+ * NOTES
+ *     file_exists(char *fn);
+ */
+BOOL32 WINAPI PathFileExists(LPSTR fn) {
+  TRACE(shell,"%s\n",fn);
+   if (GetFileAttributes32A(fn)==-1)
+    	return FALSE;
+    else
+    	return TRUE;
+}
+/*************************************************************************
+ * PathMatchSpec [SHELL32.46]
+ * 
+ * NOTES
+ *     used from COMDLG32
+ */
+
+BOOL32 WINAPI PathMatchSpec32A(LPCSTR name, LPCSTR mask) 
+{	LPCSTR _name;
+
+	TRACE(shell,"%s %s stub\n",name,mask);
+
+	_name = name;
+	while (*_name && *mask)
+	{ if (*mask ==';')
+	  { mask++;
+	    _name = name;
+	  }
+	  else if (*mask == '*')
+	  { mask++;
+	    while (*mask == '*') mask++;		/* Skip consecutive '*' */
+	    if (!*mask || *mask==';') return TRUE;	/* '*' matches everything */
+	    while (*_name && (toupper(*_name) != toupper(*mask))) _name++;
+	    if (!*_name)
+	    { while ( *mask && *mask != ';') mask++;
+	      _name = name;
+	    }
+	  }
+	  else if ( (*mask == '?') || (toupper(*mask) == toupper(*_name)) )
+	  { mask++;
+	    _name++;
+	  }
+	  else
+	  { while ( *mask && *mask != ';') mask++;
+	  }
+	}
+	return (!*_name && (!*mask || *mask==';'));
+}
+BOOL32 WINAPI PathMatchSpec32W(LPCWSTR name, LPCWSTR mask) 
+{	WCHAR stemp[4];
+	LPCWSTR _name;
+	
+	TRACE(shell,"%s %s stub\n",debugstr_w(name),debugstr_w(mask));
+
+	lstrcpyAtoW(stemp,"*.*");	
+	if (!lstrcmp32W( mask, stemp )) return 1;
+
+	_name = name;
+	while (*_name && *mask)
+	{ if (*mask ==';')
+	  { mask++;
+	    _name = name;
+	  }
+	  else if (*mask == '*')
+	  { mask++;
+	    while (*mask == '*') mask++;		/* Skip consecutive '*' */
+	    if (!*mask || *mask==';') return TRUE;	/* '*' matches everything */
+	    while (*_name && (towupper(*_name) != towupper(*mask))) _name++;
+	    if (!*_name)
+	    { while ( *mask && *mask != ';') mask++;
+	      _name = name;
+	    }
+	  }
+	  else if ( (*mask == '?') || (towupper(*mask) == towupper(*_name)) )
+	  { mask++;
+	    _name++;
+	  }
+	  else
+	  { while ( *mask && *mask != ';') mask++;
+	  }
+	}
+	return (!*_name && (!*mask || *mask==';'));
+}
+BOOL32 WINAPI PathMatchSpec32AW(LPVOID name, LPVOID mask) 
+{	if (VERSION_OsIsUnicode())
+	  return PathMatchSpec32W( name, mask );
+	return PathMatchSpec32A( name, mask );
+}
+/*************************************************************************
+ * PathSetDlgItemPath32AW [SHELL32.48]
+ * NOTES
+ *  use PathCompactPath to make sure, the path fits into the control
+ */
+
+BOOL32 WINAPI PathSetDlgItemPath32A(HWND32 hDlg, int id, LPCSTR pszPath) 
+{	TRACE(shell,"%x %x %s\n",hDlg, id, pszPath);
+	return SetDlgItemText32A(hDlg, id, pszPath);
+}
+BOOL32 WINAPI PathSetDlgItemPath32W(HWND32 hDlg, int id, LPCWSTR pszPath) 
+{	TRACE(shell,"%x %x %s\n",hDlg, id, debugstr_w(pszPath));
+	return SetDlgItemText32W(hDlg, id, pszPath);
+}
+BOOL32 WINAPI PathSetDlgItemPath32AW(HWND32 hDlg, int id, LPCVOID pszPath) 
+{	if (VERSION_OsIsUnicode())
+	  return PathSetDlgItemPath32W(hDlg, id, pszPath);
+	return PathSetDlgItemPath32A(hDlg, id, pszPath);
+}
+
+/*************************************************************************
+ * PathResolve [SHELL32.51]
+ */
+DWORD WINAPI PathResolve(LPCSTR s,DWORD x2,DWORD x3) {
+	FIXME(shell,"(%s,0x%08lx,0x%08lx),stub!\n",s,x2,x3);
+	return 0;
+}
+
+/*************************************************************************
+ * PathGetArgs [SHELL32.52]
+ *
+ * NOTES
+ *     look for next arg in string. handle "quoted" strings
+ *     returns pointer to argument *AFTER* the space. Or to the \0.
+ */
+LPVOID WINAPI PathGetArgs(LPVOID cmdline) 
+{	BOOL32	qflag = FALSE;
+	LPWSTR wptr;
+	LPSTR aptr;
+	
+	if (VERSION_OsIsUnicode())
+	{ TRACE(shell,"%sL\n",debugstr_w((LPWSTR)cmdline));
+	  wptr=(LPWSTR) cmdline;
+	  while (*wptr) 
+	  { if ((*wptr==' ') && !qflag)
+		return wptr+1;
+	    if (*wptr=='"')
+		qflag=!qflag;
+	    wptr++;
+	  }
+	  return (LPVOID) wptr;
+	}
+	TRACE(shell,"%s\n",(LPSTR)cmdline);
+	aptr=(LPSTR) cmdline;
+	while (*aptr) 
+	{ if ((*aptr==' ') && !qflag)
+	    return aptr+1;
+	  if (*aptr=='"')
+	    qflag=!qflag;
+	  aptr++;
+	}
+	return (LPVOID) aptr;
+}
+/*************************************************************************
+ * PathQuoteSpaces [SHELL32.55]
+ * 
+ * NOTES
+ *     basename(char *fn);
+ */
+LPSTR WINAPI PathQuoteSpaces32A(LPCSTR aptr)
+{	FIXME(shell,"%s\n",aptr);
+	return 0;
+
+}
+LPWSTR WINAPI PathQuoteSpaces32W(LPCWSTR wptr)
+{	FIXME(shell,"L%s\n",debugstr_w(wptr));
+	return 0;	
+}
+LPVOID WINAPI PathQuoteSpaces32AW (LPCVOID fn)
+{	if(VERSION_OsIsUnicode())
+	  return PathQuoteSpaces32W(fn);
+	return PathQuoteSpaces32A(fn);
+}
+
+
+/*************************************************************************
+ * PathUnquoteSpaces [SHELL32.56]
+ * 
+ * NOTES
+ *     unquote string (remove ")
+ */
+VOID WINAPI PathUnquoteSpaces(LPSTR str) {
+    DWORD      len = lstrlen32A(str);
+    TRACE(shell,"%s\n",str);
+    if (*str!='"') return;
+    if (str[len-1]!='"') return;
+    str[len-1]='\0';
+    lstrcpy32A(str,str+1);
+    return;
+}
+
+/*************************************************************************
+ * PathGetDriveNumber32 [SHELL32.57]
+ *
+ */
+HRESULT WINAPI PathGetDriveNumber32(LPSTR u)
+{	FIXME(shell,"%s stub\n",debugstr_a(u));
+	return 0;
+}
+
+/*************************************************************************
+ * PathYetAnotherMakeUniqueName [SHELL32.75]
+ * 
+ * NOTES
+ *     exported by ordinal
+ */
+BOOL32 WINAPI PathYetAnotherMakeUniqueName(LPDWORD x,LPDWORD y) {
+    FIXME(shell,"(%p,%p):stub.\n",x,y);
+    return TRUE;
+}
+
+/*************************************************************************
+ * IsLFNDrive [SHELL32.119]
+ * 
+ * NOTES
+ *     exported by ordinal Name
+ */
+BOOL32 WINAPI IsLFNDrive(LPCSTR path) {
+    DWORD	fnlen;
+
+    if (!GetVolumeInformation32A(path,NULL,0,NULL,&fnlen,NULL,NULL,0))
+	return FALSE;
+    return fnlen>12;
+}
+/*************************************************************************
+ * PathGetExtension [SHELL32.158]
+ *
+ * NOTES
+ *     exported by ordinal
+ */
+LPCSTR WINAPI PathGetExtension32A(LPCSTR path,DWORD y,DWORD z)
+{	TRACE(shell,"(%s,%08lx,%08lx)\n",path,y,z);
+	path = PathFindExtension32A(path);
+	return *path?(path+1):path;
+}
+LPCWSTR WINAPI PathGetExtension32W(LPCWSTR path,DWORD y,DWORD z)
+{	TRACE(shell,"(L%s,%08lx,%08lx)\n",debugstr_w(path),y,z);
+	path = PathFindExtension32W(path);
+	return *path?(path+1):path;
+}
+LPCVOID WINAPI PathGetExtension32AW(LPCVOID path,DWORD y,DWORD z) 
+{	if (VERSION_OsIsUnicode())
+	  return PathGetExtension32W(path,y,z);
+	return PathGetExtension32A(path,y,z);
+}
+
+/*************************************************************************
+ * SheGetDirW [SHELL32.281]
+ *
+ */
+HRESULT WINAPI SheGetDir32W(LPWSTR u, LPWSTR v)
+{	FIXME(shell,"%s %s stub\n",debugstr_w(u),debugstr_w(v) );
+	return 0;
+}
+
+/*************************************************************************
+ * SheChangeDirW [SHELL32.274]
+ *
+ */
+HRESULT WINAPI SheChangeDir32W(LPWSTR u)
+{	FIXME(shell,"(%s),stub\n",debugstr_w(u));
+	return 0;
+}
+
+/*************************************************************************
+*	PathProcessCommand	[SHELL32.653]
+*/
+HRESULT WINAPI PathProcessCommand (DWORD u, DWORD v, DWORD w, DWORD x)
+{	FIXME(shell,"0x%04lx 0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w,x);
+	return 0;
+}